From d59d7332afba4ac65e58655d2bea4e8b6de3d8ab Mon Sep 17 00:00:00 2001
From: Georgios Kalpakas <kalpakas.g@gmail.com>
Date: Tue, 24 Jan 2017 00:12:29 +0200
Subject: [PATCH] chore(*): correctly scope disabled `max-line-length` tslint
 rule

The max line length is set to 150 in 'tslint.json'. In specific regions, it is
desirable to allow longer lines, so these regions should be wrapped in comments
like the following:

```js
// Max line length enforced here.

/* tslint:disable:max-line-length */
// Max line length NOT enforced here.
/* tslint:enable:max-line-length */   <-- CORRECT

// Max line length enforced here.
```

In many cases, the re-enabling comment incorrectly included `disable` instead of
`enable` (as shown below), which essentially keeps the `max-line-length`
**disabled** for the rest of the file:

```js
// Max line length enforced here.

/* tslint:disable:max-line-length */
// Max line length NOT enforced here.
/* tslint:disable:max-line-length */   <-- INCORRECT

// Max line length NOT enforced here.
```

This commit fixes these comments, so the `max-line-length` rule is properly
enforced in regions that don't need longer lines.
---
 src/operator/bufferTime.ts              | 2 +-
 src/operator/combineLatest.ts           | 2 +-
 src/operator/concat.ts                  | 2 +-
 src/operator/concatAll.ts               | 2 +-
 src/operator/concatMap.ts               | 2 +-
 src/operator/concatMapTo.ts             | 2 +-
 src/operator/defaultIfEmpty.ts          | 2 +-
 src/operator/distinctUntilChanged.ts    | 2 +-
 src/operator/distinctUntilKeyChanged.ts | 2 +-
 src/operator/do.ts                      | 2 +-
 src/operator/exhaustMap.ts              | 2 +-
 src/operator/expand.ts                  | 2 +-
 src/operator/filter.ts                  | 2 +-
 src/operator/find.ts                    | 2 +-
 src/operator/groupBy.ts                 | 2 +-
 src/operator/last.ts                    | 2 +-
 src/operator/merge.ts                   | 2 +-
 src/operator/mergeMap.ts                | 2 +-
 src/operator/mergeMapTo.ts              | 2 +-
 src/operator/multicast.ts               | 2 +-
 src/operator/onErrorResumeNext.ts       | 2 +-
 src/operator/publish.ts                 | 2 +-
 src/operator/race.ts                    | 2 +-
 src/operator/reduce.ts                  | 2 +-
 src/operator/scan.ts                    | 5 +++--
 src/operator/startWith.ts               | 2 +-
 src/operator/switchMap.ts               | 2 +-
 src/operator/switchMapTo.ts             | 2 +-
 src/operator/timeoutWith.ts             | 2 +-
 src/operator/toPromise.ts               | 2 +-
 src/operator/withLatestFrom.ts          | 2 +-
 src/operator/zip.ts                     | 2 +-
 32 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/src/operator/bufferTime.ts b/src/operator/bufferTime.ts
index 3488290376..d15b8fc674 100644
--- a/src/operator/bufferTime.ts
+++ b/src/operator/bufferTime.ts
@@ -11,7 +11,7 @@ import { isScheduler } from '../util/isScheduler';
 export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, scheduler?: IScheduler): Observable<T[]>;
 export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, scheduler?: IScheduler): Observable<T[]>;
 export function bufferTime<T>(this: Observable<T>, bufferTimeSpan: number, bufferCreationInterval: number, maxBufferSize: number, scheduler?: IScheduler): Observable<T[]>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Buffers the source Observable values for a specific time period.
diff --git a/src/operator/combineLatest.ts b/src/operator/combineLatest.ts
index d06d1dfa24..317d1cba3b 100644
--- a/src/operator/combineLatest.ts
+++ b/src/operator/combineLatest.ts
@@ -23,7 +23,7 @@ export function combineLatest<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: Ob
 export function combineLatest<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): Observable<R>;
 export function combineLatest<T, R>(this: Observable<T>, array: ObservableInput<T>[]): Observable<Array<T>>;
 export function combineLatest<T, TOther, R>(this: Observable<T>, array: ObservableInput<TOther>[], project: (v1: T, ...values: Array<TOther>) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Combines multiple Observables to create an Observable whose values are
diff --git a/src/operator/concat.ts b/src/operator/concat.ts
index 1e1a32313f..42d348402c 100644
--- a/src/operator/concat.ts
+++ b/src/operator/concat.ts
@@ -13,7 +13,7 @@ export function concat<T, T2, T3, T4, T5>(this: Observable<T>, v2: ObservableInp
 export function concat<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler?: IScheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
 export function concat<T>(this: Observable<T>, ...observables: Array<ObservableInput<T> | IScheduler>): Observable<T>;
 export function concat<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | IScheduler>): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Creates an output Observable which sequentially emits all values from every
diff --git a/src/operator/concatAll.ts b/src/operator/concatAll.ts
index e8228a94b3..e81ed990f7 100644
--- a/src/operator/concatAll.ts
+++ b/src/operator/concatAll.ts
@@ -5,7 +5,7 @@ import { MergeAllOperator } from './mergeAll';
 /* tslint:disable:max-line-length */
 export function concatAll<T>(this: Observable<T>): T;
 export function concatAll<T, R>(this: Observable<T>): Subscribable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Converts a higher-order Observable into a first-order Observable by
diff --git a/src/operator/concatMap.ts b/src/operator/concatMap.ts
index 1fdb1807d0..fa1391765b 100644
--- a/src/operator/concatMap.ts
+++ b/src/operator/concatMap.ts
@@ -4,7 +4,7 @@ import { Observable, ObservableInput } from '../Observable';
 /* tslint:disable:max-line-length */
 export function concatMap<T, R>(this: Observable<T>, project: (value: T, index: number) =>  ObservableInput<R>): Observable<R>;
 export function concatMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) =>  ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to an Observable which is merged in the output
diff --git a/src/operator/concatMapTo.ts b/src/operator/concatMapTo.ts
index e1b468c1f2..0d6ddd3a95 100644
--- a/src/operator/concatMapTo.ts
+++ b/src/operator/concatMapTo.ts
@@ -4,7 +4,7 @@ import { MergeMapToOperator } from './mergeMapTo';
 /* tslint:disable:max-line-length */
 export function concatMapTo<T, R>(this: Observable<T>, observable: ObservableInput<R>): Observable<R>;
 export function concatMapTo<T, I, R>(this: Observable<T>, observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to the same Observable which is merged multiple
diff --git a/src/operator/defaultIfEmpty.ts b/src/operator/defaultIfEmpty.ts
index 7de18b7e13..cb33ff6b4e 100644
--- a/src/operator/defaultIfEmpty.ts
+++ b/src/operator/defaultIfEmpty.ts
@@ -5,7 +5,7 @@ import { Subscriber } from '../Subscriber';
 /* tslint:disable:max-line-length */
 export function defaultIfEmpty<T>(this: Observable<T>, defaultValue?: T): Observable<T>;
 export function defaultIfEmpty<T, R>(this: Observable<T>, defaultValue?: R): Observable<T | R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Emits a given value if the source Observable completes without emitting any
diff --git a/src/operator/distinctUntilChanged.ts b/src/operator/distinctUntilChanged.ts
index 06e73d6cb5..354cda140f 100644
--- a/src/operator/distinctUntilChanged.ts
+++ b/src/operator/distinctUntilChanged.ts
@@ -8,7 +8,7 @@ import { TeardownLogic } from '../Subscription';
 /* tslint:disable:max-line-length */
 export function distinctUntilChanged<T>(this: Observable<T>, compare?: (x: T, y: T) => boolean): Observable<T>;
 export function distinctUntilChanged<T, K>(this: Observable<T>, compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.
diff --git a/src/operator/distinctUntilKeyChanged.ts b/src/operator/distinctUntilKeyChanged.ts
index 02ee938219..7447d75391 100644
--- a/src/operator/distinctUntilKeyChanged.ts
+++ b/src/operator/distinctUntilKeyChanged.ts
@@ -4,7 +4,7 @@ import { Observable } from '../Observable';
 /* tslint:disable:max-line-length */
 export function distinctUntilKeyChanged<T>(this: Observable<T>, key: string): Observable<T>;
 export function distinctUntilKeyChanged<T, K>(this: Observable<T>, key: string, compare: (x: K, y: K) => boolean): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item,
diff --git a/src/operator/do.ts b/src/operator/do.ts
index a48acaeba9..0e76094b2d 100644
--- a/src/operator/do.ts
+++ b/src/operator/do.ts
@@ -7,7 +7,7 @@ import { TeardownLogic } from '../Subscription';
 /* tslint:disable:max-line-length */
 export function _do<T>(this: Observable<T>, next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable<T>;
 export function _do<T>(this: Observable<T>, observer: PartialObserver<T>): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Perform a side effect for every emission on the source Observable, but return
diff --git a/src/operator/exhaustMap.ts b/src/operator/exhaustMap.ts
index 6f65db9ff6..7fca11d226 100644
--- a/src/operator/exhaustMap.ts
+++ b/src/operator/exhaustMap.ts
@@ -9,7 +9,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function exhaustMap<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
 export function exhaustMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to an Observable which is merged in the output
diff --git a/src/operator/expand.ts b/src/operator/expand.ts
index 9e7f9f97ea..e4975e4cfe 100644
--- a/src/operator/expand.ts
+++ b/src/operator/expand.ts
@@ -12,7 +12,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function expand<T>(this: Observable<T>, project: (value: T, index: number) => Observable<T>, concurrent?: number, scheduler?: IScheduler): Observable<T>;
 export function expand<T, R>(this: Observable<T>, project: (value: T, index: number) => Observable<R>, concurrent?: number, scheduler?: IScheduler): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Recursively projects each source value to an Observable which is merged in
diff --git a/src/operator/filter.ts b/src/operator/filter.ts
index 06314e5e7b..f0fba4c329 100644
--- a/src/operator/filter.ts
+++ b/src/operator/filter.ts
@@ -10,7 +10,7 @@ export function filter<T, S extends T>(this: Observable<T>,
 export function filter<T>(this: Observable<T>,
                           predicate: (value: T, index: number) => boolean,
                           thisArg?: any): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Filter items emitted by the source Observable by only emitting those that
diff --git a/src/operator/find.ts b/src/operator/find.ts
index e8183a7db4..110c813958 100644
--- a/src/operator/find.ts
+++ b/src/operator/find.ts
@@ -9,7 +9,7 @@ export function find<T, S extends T>(this: Observable<T>,
 export function find<T>(this: Observable<T>,
                         predicate: (value: T, index: number) => boolean,
                         thisArg?: any): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Emits only the first value emitted by the source Observable that meets some
diff --git a/src/operator/groupBy.ts b/src/operator/groupBy.ts
index e94517594b..a64a12f749 100644
--- a/src/operator/groupBy.ts
+++ b/src/operator/groupBy.ts
@@ -11,7 +11,7 @@ export function groupBy<T, K>(this: Observable<T>, keySelector: (value: T) => K)
 export function groupBy<T, K>(this: Observable<T>, keySelector: (value: T) => K, elementSelector: void, durationSelector: (grouped: GroupedObservable<K, T>) => Observable<any>): Observable<GroupedObservable<K, T>>;
 export function groupBy<T, K, R>(this: Observable<T>, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable<K, R>) => Observable<any>): Observable<GroupedObservable<K, R>>;
 export function groupBy<T, K, R>(this: Observable<T>, keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable<K, R>) => Observable<any>, subjectSelector?: () => Subject<R>): Observable<GroupedObservable<K, R>>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Groups the items emitted by an Observable according to a specified criterion,
diff --git a/src/operator/last.ts b/src/operator/last.ts
index 4658e4a8c1..ac4c21bc47 100644
--- a/src/operator/last.ts
+++ b/src/operator/last.ts
@@ -23,7 +23,7 @@ export function last<T>(this: Observable<T>,
                         predicate: (value: T, index: number, source: Observable<T>) => boolean,
                         resultSelector: void,
                         defaultValue?: T): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that emits only the last item emitted by the source Observable.
diff --git a/src/operator/merge.ts b/src/operator/merge.ts
index 1500cb4f19..1345a3d54f 100644
--- a/src/operator/merge.ts
+++ b/src/operator/merge.ts
@@ -19,7 +19,7 @@ export function merge<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: Observable
 export function merge<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent?: number, scheduler?: IScheduler): Observable<T | T2 | T3 | T4 | T5 | T6>;
 export function merge<T>(this: Observable<T>, ...observables: Array<ObservableInput<T> | IScheduler | number>): Observable<T>;
 export function merge<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | IScheduler | number>): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Creates an output Observable which concurrently emits all values from every
diff --git a/src/operator/mergeMap.ts b/src/operator/mergeMap.ts
index 89f64936da..ba5078719b 100644
--- a/src/operator/mergeMap.ts
+++ b/src/operator/mergeMap.ts
@@ -9,7 +9,7 @@ import { InnerSubscriber } from '../InnerSubscriber';
 /* tslint:disable:max-line-length */
 export function mergeMap<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>, concurrent?: number): Observable<R>;
 export function mergeMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to an Observable which is merged in the output
diff --git a/src/operator/mergeMapTo.ts b/src/operator/mergeMapTo.ts
index 5fc173e701..125fb26a1a 100644
--- a/src/operator/mergeMapTo.ts
+++ b/src/operator/mergeMapTo.ts
@@ -10,7 +10,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function mergeMapTo<T, R>(this: Observable<T>, observable: ObservableInput<R>, concurrent?: number): Observable<R>;
 export function mergeMapTo<T, I, R>(this: Observable<T>, observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R, concurrent?: number): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to the same Observable which is merged multiple
diff --git a/src/operator/multicast.ts b/src/operator/multicast.ts
index dec29ffe7c..4cbece5292 100644
--- a/src/operator/multicast.ts
+++ b/src/operator/multicast.ts
@@ -7,7 +7,7 @@ import { ConnectableObservable, connectableObservableDescriptor } from '../obser
 /* tslint:disable:max-line-length */
 export function multicast<T>(this: Observable<T>, subjectOrSubjectFactory: factoryOrValue<Subject<T>>): ConnectableObservable<T>;
 export function multicast<T>(SubjectFactory: (this: Observable<T>) => Subject<T>, selector?: selector<T>): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that emits the results of invoking a specified selector on items
diff --git a/src/operator/onErrorResumeNext.ts b/src/operator/onErrorResumeNext.ts
index 81147524a5..e2786fc26d 100644
--- a/src/operator/onErrorResumeNext.ts
+++ b/src/operator/onErrorResumeNext.ts
@@ -15,7 +15,7 @@ export function onErrorResumeNext<T, T2, T3, T4, T5, R>(this: Observable<T>, v2:
 export function onErrorResumeNext<T, T2, T3, T4, T5, T6, R>(this: Observable<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<R> ;
 export function onErrorResumeNext<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;
 export function onErrorResumeNext<T, R>(this: Observable<T>, array: ObservableInput<any>[]): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 export function onErrorResumeNext<T, R>(this: Observable<T>, ...nextSources: Array<ObservableInput<any> |
                                                        Array<ObservableInput<any>> |
                                                        ((...values: Array<any>) => R)>): Observable<R> {
diff --git a/src/operator/publish.ts b/src/operator/publish.ts
index 17d2b3f52e..c18b6bf7b2 100644
--- a/src/operator/publish.ts
+++ b/src/operator/publish.ts
@@ -6,7 +6,7 @@ import { ConnectableObservable } from '../observable/ConnectableObservable';
 /* tslint:disable:max-line-length */
 export function publish<T>(this: Observable<T>): ConnectableObservable<T>;
 export function publish<T>(this: Observable<T>, selector: selector<T>): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called
diff --git a/src/operator/race.ts b/src/operator/race.ts
index 60cef58d1e..a36f3fd83b 100644
--- a/src/operator/race.ts
+++ b/src/operator/race.ts
@@ -11,7 +11,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function race<T>(this: Observable<T>, ...observables: Array<Observable<T> | Array<Observable<T>>>): Observable<T>;
 export function race<T, R>(this: Observable<T>, ...observables: Array<Observable<any> | Array<Observable<T>>>): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that mirrors the first source Observable to emit an item
diff --git a/src/operator/reduce.ts b/src/operator/reduce.ts
index 72e29490d9..0ff56b891c 100644
--- a/src/operator/reduce.ts
+++ b/src/operator/reduce.ts
@@ -6,7 +6,7 @@ import { Subscriber } from '../Subscriber';
 export function reduce<T>(this: Observable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable<T>;
 export function reduce<T>(this: Observable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable<T[]>;
 export function reduce<T, R>(this: Observable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Applies an accumulator function over the source Observable, and returns the
diff --git a/src/operator/scan.ts b/src/operator/scan.ts
index 6c78b0a617..558f87667d 100644
--- a/src/operator/scan.ts
+++ b/src/operator/scan.ts
@@ -6,7 +6,7 @@ import { Subscriber } from '../Subscriber';
 export function scan<T>(this: Observable<T>, accumulator: (acc: T, value: T, index: number) => T, seed?: T): Observable<T>;
 export function scan<T>(this: Observable<T>, accumulator: (acc: T[], value: T, index: number) => T[], seed?: T[]): Observable<T[]>;
 export function scan<T, R>(this: Observable<T>, accumulator: (acc: R, value: T, index: number) => R, seed?: R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Applies an accumulator function over the source Observable, and returns each
@@ -84,7 +84,8 @@ class ScanSubscriber<T, R> extends Subscriber<T> {
     this._seed = value;
   }
 
-  constructor(destination: Subscriber<R>, private accumulator: (acc: R, value: T, index: number) => R, private _seed: T | R, private hasSeed: boolean) {
+  constructor(destination: Subscriber<R>, private accumulator: (acc: R, value: T, index: number) => R, private _seed: T | R,
+              private hasSeed: boolean) {
     super(destination);
   }
 
diff --git a/src/operator/startWith.ts b/src/operator/startWith.ts
index f2c8555e33..55b540c7ee 100644
--- a/src/operator/startWith.ts
+++ b/src/operator/startWith.ts
@@ -14,7 +14,7 @@ export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, sc
 export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: IScheduler): Observable<T>;
 export function startWith<T>(this: Observable<T>, v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: IScheduler): Observable<T>;
 export function startWith<T>(this: Observable<T>, ...array: Array<T | IScheduler>): Observable<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the
diff --git a/src/operator/switchMap.ts b/src/operator/switchMap.ts
index b789f1dc78..96d62641e3 100644
--- a/src/operator/switchMap.ts
+++ b/src/operator/switchMap.ts
@@ -9,7 +9,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function switchMap<T, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<R>): Observable<R>;
 export function switchMap<T, I, R>(this: Observable<T>, project: (value: T, index: number) => ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to an Observable which is merged in the output
diff --git a/src/operator/switchMapTo.ts b/src/operator/switchMapTo.ts
index 80bf3f6158..ee65ba41be 100644
--- a/src/operator/switchMapTo.ts
+++ b/src/operator/switchMapTo.ts
@@ -9,7 +9,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function switchMapTo<T, R>(this: Observable<T>, observable: ObservableInput<R>): Observable<R>;
 export function switchMapTo<T, I, R>(this: Observable<T>, observable: ObservableInput<I>, resultSelector: (outerValue: T, innerValue: I, outerIndex: number, innerIndex: number) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Projects each source value to the same Observable which is flattened multiple
diff --git a/src/operator/timeoutWith.ts b/src/operator/timeoutWith.ts
index 8cfce014a9..ce9a26bb28 100644
--- a/src/operator/timeoutWith.ts
+++ b/src/operator/timeoutWith.ts
@@ -12,7 +12,7 @@ import { subscribeToResult } from '../util/subscribeToResult';
 /* tslint:disable:max-line-length */
 export function timeoutWith<T>(this: Observable<T>, due: number | Date, withObservable: ObservableInput<T>, scheduler?: IScheduler): Observable<T>;
 export function timeoutWith<T, R>(this: Observable<T>, due: number | Date, withObservable: ObservableInput<R>, scheduler?: IScheduler): Observable<T | R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * @param due
diff --git a/src/operator/toPromise.ts b/src/operator/toPromise.ts
index de4381e308..3cfe071004 100644
--- a/src/operator/toPromise.ts
+++ b/src/operator/toPromise.ts
@@ -4,7 +4,7 @@ import { root } from '../util/root';
 /* tslint:disable:max-line-length */
 export function toPromise<T>(this: Observable<T>): Promise<T>;
 export function toPromise<T>(this: Observable<T>, PromiseCtor: typeof Promise): Promise<T>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Converts an Observable sequence to a ES2015 compliant promise.
diff --git a/src/operator/withLatestFrom.ts b/src/operator/withLatestFrom.ts
index dc4777b66e..7ccd1506e4 100644
--- a/src/operator/withLatestFrom.ts
+++ b/src/operator/withLatestFrom.ts
@@ -20,7 +20,7 @@ export function withLatestFrom<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: O
 export function withLatestFrom<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;
 export function withLatestFrom<T, R>(this: Observable<T>, array: ObservableInput<any>[]): Observable<R>;
 export function withLatestFrom<T, R>(this: Observable<T>, array: ObservableInput<any>[], project: (...values: Array<any>) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * Combines the source Observable with other Observables to create an Observable
diff --git a/src/operator/zip.ts b/src/operator/zip.ts
index b979956bb5..c02f8c7d30 100644
--- a/src/operator/zip.ts
+++ b/src/operator/zip.ts
@@ -24,7 +24,7 @@ export function zipProto<T, T2, T3, T4, T5, T6>(this: Observable<T>, v2: Observa
 export function zipProto<T, R>(this: Observable<T>, ...observables: Array<ObservableInput<T> | ((...values: Array<T>) => R)>): Observable<R>;
 export function zipProto<T, R>(this: Observable<T>, array: Array<ObservableInput<T>>): Observable<R>;
 export function zipProto<T, TOther, R>(this: Observable<T>, array: Array<ObservableInput<TOther>>, project: (v1: T, ...values: Array<TOther>) => R): Observable<R>;
-/* tslint:disable:max-line-length */
+/* tslint:enable:max-line-length */
 
 /**
  * @param observables