style(linting): enable ' --noUnusedLocals' option

package.json

@@ -72,9 +72,9 @@
     "copy_src_cjs": "mkdirp ./dist/cjs/src && shx cp -r ./src/* ./dist/cjs/src",
     "copy_src_es6": "mkdirp ./dist/es6/src && shx cp -r ./src/* ./dist/es6/src",
     "commit": "git-cz",
-    "compile_dist_cjs": "tsc ./dist/cjs/src/Rx.ts ./dist/cjs/src/add/observable/of.ts                         -m commonjs --lib es5,es2015.iterable,es2015.collection,es2015.promise,dom --sourceMap --outDir ./dist/cjs --target ES5 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns --suppressImplicitAnyIndexErrors --moduleResolution node",
-    "compile_module_es6": "tsc                                          ./dist/es6/src/Rx.ts ./dist/es6/src/add/observable/of.ts                             -m es2015   --sourceMap --outDir ./dist/es6 --target ES5 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns --suppressImplicitAnyIndexErrors --moduleResolution node --noEmitHelpers --lib es5,es2015.iterable,es2015.collection,es2015.promise,dom ",
-    "compile_dist_es6_for_docs": "tsc                                 ./dist/es6/src/Rx.ts ./dist/es6/src/add/observable/of.ts ./dist/es6/src/MiscJSDoc.ts -m es2015   --sourceMap --outDir ./dist/es6 --target ES6 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns --suppressImplicitAnyIndexErrors --moduleResolution node",
+    "compile_dist_cjs": "tsc ./dist/cjs/src/Rx.ts ./dist/cjs/src/add/observable/of.ts                         -m commonjs --lib es5,es2015.iterable,es2015.collection,es2015.promise,dom --sourceMap --outDir ./dist/cjs --target ES5 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns  --noUnusedLocals --suppressImplicitAnyIndexErrors --moduleResolution node",
+    "compile_module_es6": "tsc                                          ./dist/es6/src/Rx.ts ./dist/es6/src/add/observable/of.ts                             -m es2015   --sourceMap --outDir ./dist/es6 --target ES5 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns --noUnusedLocals --suppressImplicitAnyIndexErrors --moduleResolution node --noEmitHelpers --lib es5,es2015.iterable,es2015.collection,es2015.promise,dom ",
+    "compile_dist_es6_for_docs": "tsc                                 ./dist/es6/src/Rx.ts ./dist/es6/src/add/observable/of.ts ./dist/es6/src/MiscJSDoc.ts -m es2015   --sourceMap --outDir ./dist/es6 --target ES6 -d --diagnostics --pretty --noImplicitAny --noImplicitReturns  --noUnusedLocals --suppressImplicitAnyIndexErrors --moduleResolution node",
     "cover": "shx rm -rf dist/cjs && tsc src/Rx.ts src/add/observable/of.ts -m commonjs --lib es5,es2015.iterable,es2015.collection,es2015.promise,dom --outDir dist/cjs --sourceMap --target ES5 -d && nyc --reporter=lcov --reporter=html --exclude=spec/support/**/* --exclude=spec-js/**/* --exclude=node_modules mocha --opts spec/support/default.opts spec-js",
     "decision_tree_widget": "cd doc/decision-tree-widget && npm run build && cd ../..",
     "doctoc": "doctoc CONTRIBUTING.md",

src/Operator.ts

@@ -1,6 +1,7 @@
+import { Observable } from './Observable';
 import { Subscriber } from './Subscriber';
 import { TeardownLogic } from './Subscription';
 
 export interface Operator<T, R> {
-  call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+  call(subscriber: Subscriber<R>, source: Observable<T>): TeardownLogic;
 }

src/Rx.ts

@@ -188,7 +188,12 @@ import { $$observable as observable } from './symbol/observable';
  * @property {Scheduler} animationFrame Schedules work with `requestAnimationFrame`.
  * Use this for synchronizing with the platform's painting
  */
-let Scheduler = {
+let Scheduler: {
+  asap: AsapScheduler;
+  queue: QueueScheduler;
+  animationFrame: AnimationFrameScheduler;
+  async: AsyncScheduler;
+} = {
   asap,
   queue,
   animationFrame,

src/observable/ArrayLikeObservable.ts

@@ -55,7 +55,8 @@ export class ArrayLikeObservable<T> extends Observable<T> {
 
   protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
     let index = 0;
-    const { arrayLike, scheduler } = this;
+    const arrayLike = this.arrayLike;
+    const scheduler = this.scheduler;
     const length = arrayLike.length;
 
     if (scheduler) {

src/observable/BoundCallbackObservable.ts

@@ -94,8 +94,9 @@ export class BoundCallbackObservable<T> extends Observable<T> {
       if (!subject) {
         subject = this.subject = new AsyncSubject<T>();
         const handler = function handlerFn(...innerArgs: any[]) {
-          const source = (<any>handlerFn).source;
-          const { selector, subject } = source;
+          const source: BoundCallbackObservable<T> = (<any>handlerFn).source;
+          const { subject } = source;
+          const selector = source.selector;
           if (selector) {
             const result = tryCatch(selector).apply(this, innerArgs);
             if (result === errorObject) {

src/observable/BoundNodeCallbackObservable.ts

@@ -90,8 +90,9 @@ export class BoundNodeCallbackObservable<T> extends Observable<T> {
       if (!subject) {
         subject = this.subject = new AsyncSubject<T>();
         const handler = function handlerFn(...innerArgs: any[]) {
-          const source = (<any>handlerFn).source;
-          const { selector, subject } = source;
+          const source: BoundNodeCallbackObservable<T> = (<any>handlerFn).source;
+          const { subject } = source;
+          const selector = source.selector;
           const err = innerArgs.shift();
 
           if (err) {

src/observable/ConnectableObservable.ts

@@ -92,8 +92,7 @@ class RefCountOperator<T> implements Operator<T, T> {
   constructor(private connectable: ConnectableObservable<T>) {
   }
   call(subscriber: Subscriber<T>, source: any): TeardownLogic {
-
-    const { connectable } = this;
+    const connectable = this.connectable;
     (<any> connectable)._refCount++;
 
     const refCounter = new RefCountSubscriber(subscriber, connectable);

src/observable/ErrorObservable.ts

@@ -12,7 +12,7 @@ export interface DispatchArg {
  * @extends {Ignored}
  * @hide true
  */
-export class ErrorObservable extends Observable<any> {
+export class ErrorObservable<E> extends Observable<any> {
 
   /**
    * Creates an Observable that emits no items to the Observer and immediately
@@ -54,7 +54,7 @@ export class ErrorObservable extends Observable<any> {
    * @name throw
    * @owner Observable
    */
-  static create<T>(error: any, scheduler?: Scheduler) {
+  static create<E>(error: E, scheduler?: Scheduler): ErrorObservable<E> {
     return new ErrorObservable(error, scheduler);
   }
 
@@ -63,7 +63,7 @@ export class ErrorObservable extends Observable<any> {
     subscriber.error(error);
   }
 
-  constructor(public error: any, private scheduler?: Scheduler) {
+  constructor(public error: E, private scheduler?: Scheduler) {
     super();
   }
 

src/observable/ForkJoinObservable.ts

@@ -86,7 +86,7 @@ class ForkJoinSubscriber<T> extends OuterSubscriber<T, T> {
   private haveValues = 0;
 
   constructor(destination: Subscriber<T>,
-              private sources: Array<SubscribableOrPromise<any>>,
+              sources: Array<SubscribableOrPromise<any>>,
               private resultSelector?: (...values: Array<any>) => T) {
     super(destination);
 
@@ -117,7 +117,8 @@ class ForkJoinSubscriber<T> extends OuterSubscriber<T, T> {
 
   notifyComplete(innerSub: InnerSubscriber<T, T>): void {
     const destination = this.destination;
-    const { haveValues, resultSelector, values } = this;
+    const { haveValues, values } = this;
+    const resultSelector = this.resultSelector;
     const len = values.length;
 
     if (!(<any>innerSub)._hasValue) {

src/observable/IfObservable.ts

@@ -24,7 +24,9 @@ export class IfObservable<T, R> extends Observable<T> {
   }
 
   protected _subscribe(subscriber: Subscriber<T|R>): TeardownLogic {
-    const { condition, thenSource, elseSource } = this;
+    const condition = this.condition;
+    const thenSource = this.thenSource;
+    const elseSource = this.elseSource;
 
     return new IfSubscriber(subscriber, condition, thenSource, elseSource);
   }
@@ -40,7 +42,9 @@ class IfSubscriber<T, R> extends OuterSubscriber<T, T> {
   }
 
   private tryIf(): void {
-    const { condition, thenSource, elseSource } = this;
+    const condition = this.condition;
+    const thenSource = this.thenSource;
+    const elseSource = this.elseSource;
 
     let result: boolean;
     try {

src/observable/IteratorObservable.ts

@@ -58,7 +58,8 @@ export class IteratorObservable<T> extends Observable<T> {
   protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
 
     let index = 0;
-    const { iterator, scheduler } = this;
+    const iterator = this.iterator;
+    const scheduler = this.scheduler;
 
     if (scheduler) {
       return scheduler.schedule(IteratorObservable.dispatch, 0, {

src/observable/PairsObservable.ts

@@ -76,7 +76,8 @@ export class PairsObservable<T> extends Observable<Array<string | T>> {
   }
 
   protected _subscribe(subscriber: Subscriber<Array<string | T>>): TeardownLogic {
-    const {keys, scheduler} = this;
+    const keys = this.keys;
+    const scheduler = this.scheduler;
     const length = keys.length;
 
     if (scheduler) {

src/observable/UsingObservable.ts

@@ -22,7 +22,8 @@ export class UsingObservable<T> extends Observable<T> {
   }
 
   protected _subscribe(subscriber: Subscriber<T>): TeardownLogic {
-    const { resourceFactory, observableFactory } = this;
+    const resourceFactory = this.resourceFactory;
+    const observableFactory = this.observableFactory;
 
     let resource: AnonymousSubscription;
 

src/operator/bufferCount.ts

@@ -71,7 +71,9 @@ class BufferCountSubscriber<T> extends Subscriber<T> {
 
   protected _next(value: T) {
     const count = this.count++;
-    const { destination, bufferSize, startBufferEvery, buffers } = this;
+    const { destination, buffers } = this;
+    const bufferSize = this.bufferSize;
+    const startBufferEvery = this.startBufferEvery;
     const startOn = (startBufferEvery == null) ? bufferSize : startBufferEvery;
 
     if (count % startOn === 0) {

src/operator/bufferTime.ts

@@ -114,7 +114,7 @@ class BufferTimeSubscriber<T> extends Subscriber<T> {
 
   constructor(destination: Subscriber<T[]>,
               private bufferTimeSpan: number,
-              private bufferCreationInterval: number,
+              bufferCreationInterval: number,
               private maxBufferSize: number,
               private scheduler: Scheduler) {
     super(destination);

src/operator/bufferToggle.ts

@@ -75,7 +75,7 @@ class BufferToggleSubscriber<T, O> extends OuterSubscriber<T, O> {
   private contexts: Array<BufferContext<T>> = [];
 
   constructor(destination: Subscriber<T[]>,
-              private openings: SubscribableOrPromise<O>,
+              openings: SubscribableOrPromise<O>,
               private closingSelector: (value: O) => SubscribableOrPromise<any> | void) {
     super(destination);
     this.add(subscribeToResult(this, openings));

src/operator/concat.ts

@@ -109,7 +109,7 @@ export function concatStatic<T, R>(...observables: (ObservableInput<any> | Sched
  * @name concat
  * @owner Observable
  */
-export function concatStatic<T, R>(...observables: Array<ObservableInput<any> | Scheduler>): Observable<R> {
+export function concatStatic<R>(...observables: Array<ObservableInput<any> | Scheduler>): Observable<R> {
   let scheduler: Scheduler = null;
   let args = <any[]>observables;
   if (isScheduler(args[observables.length - 1])) {

src/operator/delay.ts

@@ -104,7 +104,7 @@ class DelaySubscriber<T> extends Subscriber<T> {
     }));
   }
 
-  private scheduleNotification(notification: Notification<any>): void {
+  private scheduleNotification(notification: Notification<T>): void {
     if (this.errored === true) {
       return;
     }
@@ -134,7 +134,7 @@ class DelaySubscriber<T> extends Subscriber<T> {
 }
 
 class DelayMessage<T> {
-  constructor(private time: number,
-              private notification: any) {
+  constructor(public time: number,
+              public notification: Notification<T>) {
   }
 }

src/operator/exhaustMap.ts

@@ -114,7 +114,8 @@ class SwitchFirstMapSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
              innerSub: InnerSubscriber<T, I>): void {
-    const { resultSelector, destination } = this;
+    const destination = this.destination;
+    const resultSelector = this.resultSelector;
     if (resultSelector) {
       this.trySelectResult(outerValue, innerValue, outerIndex, innerIndex);
     } else {

src/operator/find.ts

@@ -83,7 +83,8 @@ export class FindValueSubscriber<T> extends Subscriber<T> {
   }
 
   protected _next(value: T): void {
-    const { predicate, thisArg } = this;
+    const predicate = this.predicate;
+    const thisArg = this.thisArg;
     const index = this.index++;
     try {
       const result = predicate.call(thisArg || this, value, index, this.source);

src/operator/groupBy.ts

@@ -221,7 +221,8 @@ export class GroupedObservable<K, T> extends Observable<T> {
 
   protected _subscribe(subscriber: Subscriber<T>) {
     const subscription = new Subscription();
-    const {refCountSubscription, groupSubject} = this;
+    const groupSubject = this.groupSubject;
+    const refCountSubscription = this.refCountSubscription;
     if (refCountSubscription && !refCountSubscription.closed) {
       subscription.add(new InnerRefCountSubscription(refCountSubscription));
     }

src/operator/last.ts

@@ -58,7 +58,7 @@ class LastSubscriber<T, R> extends Subscriber<T> {
   constructor(destination: Subscriber<R>,
               private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private resultSelector?: ((value: T, index: number) => R) | void,
-              private defaultValue?: any,
+              defaultValue?: any,
               private source?: Observable<T>) {
     super(destination);
     if (typeof defaultValue !== 'undefined') {

src/operator/merge.ts

@@ -131,7 +131,7 @@ export function mergeStatic<T, R>(...observables: (ObservableInput<any> | Schedu
  * @name merge
  * @owner Observable
  */
-export function mergeStatic<T, R>(...observables: Array<ObservableInput<any> | Scheduler | number>): Observable<R> {
+export function mergeStatic<R>(...observables: Array<ObservableInput<any> | Scheduler | number>): Observable<R> {
  let concurrent = Number.POSITIVE_INFINITY;
  let scheduler: Scheduler = null;
   let last: any = observables[observables.length - 1];

src/operator/multicast.ts

@@ -57,7 +57,7 @@ export class MulticastOperator<T> implements Operator<T, T> {
               private selector: (source: Observable<T>) => Observable<T>) {
   }
   call(subscriber: Subscriber<T>, source: any): any {
-    const { selector } = this;
+    const selector = this.selector;
     const subject = this.subjectFactory();
     const subscription = selector(subject).subscribe(subscriber);
     subscription.add(source._subscribe(subject));

src/operator/repeat.ts

@@ -50,7 +50,8 @@ class RepeatSubscriber<T> extends Subscriber<T> {
   }
   complete() {
     if (!this.isStopped) {
-      const { source, count } = this;
+      const count = this.count;
+      const source = this.source;
       if (count === 0) {
         return super.complete();
       } else if (count > -1) {

src/operator/retry.ts

@@ -47,7 +47,8 @@ class RetrySubscriber<T> extends Subscriber<T> {
   }
   error(err: any) {
     if (!this.isStopped) {
-      const { source, count } = this;
+      const count = this.count;
+      const source = this.source;
       if (count === 0) {
         return super.error(err);
       } else if (count > -1) {

src/operator/sampleTime.ts

@@ -65,8 +65,8 @@ class SampleTimeSubscriber<T> extends Subscriber<T> {
   hasValue: boolean = false;
 
   constructor(destination: Subscriber<T>,
-              private period: number,
-              private scheduler: Scheduler) {
+              period: number,
+              scheduler: Scheduler) {
     super(destination);
     this.add(scheduler.schedule(dispatchNotification, period, { subscriber: this, period }));
   }
@@ -84,7 +84,7 @@ class SampleTimeSubscriber<T> extends Subscriber<T> {
   }
 }
 
-function dispatchNotification<T>(state: any) {
+function dispatchNotification(state: any) {
   let { subscriber, period } = state;
   subscriber.notifyNext();
   (<any>this).schedule(state, period);

src/operator/sequenceEqual.ts

@@ -83,7 +83,7 @@ export class SequenceEqualSubscriber<T, R> extends Subscriber<T> {
   private _oneComplete = false;
 
   constructor(destination: Observer<R>,
-              private compareTo: Observable<T>,
+              compareTo: Observable<T>,
               private comparor: (a: T, b: T) => boolean) {
     super(destination);
     this.add(compareTo.subscribe(new SequenceEqualCompareToSubscriber(destination, this)));
@@ -107,7 +107,8 @@ export class SequenceEqualSubscriber<T, R> extends Subscriber<T> {
   }
 
   checkValues() {
-    const { _a, _b, comparor } = this;
+    const { _a, _b, } = this;
+    const comparor = this.comparor;
     while (_a.length > 0 && _b.length > 0) {
       let a = _a.shift();
       let b = _b.shift();

src/operator/switchMapTo.ts

@@ -117,7 +117,8 @@ class SwitchMapToSubscriber<T, I, R> extends OuterSubscriber<T, I> {
   notifyNext(outerValue: T, innerValue: I,
              outerIndex: number, innerIndex: number,
              innerSub: InnerSubscriber<T, I>): void {
-    const { resultSelector, destination } = this;
+    const resultSelector = this.resultSelector;
+    const destination = this.destination;
     if (resultSelector) {
       this.tryResultSelector(outerValue, innerValue, outerIndex, innerIndex);
     } else {

src/operator/takeUntil.ts

@@ -61,7 +61,7 @@ class TakeUntilOperator<T> implements Operator<T, T> {
 class TakeUntilSubscriber<T, R> extends OuterSubscriber<T, R> {
 
   constructor(destination: Subscriber<any>,
-              private notifier: Observable<any>) {
+              notifier: Observable<any>) {
     super(destination);
     this.add(subscribeToResult(this, notifier));
   }

src/operator/windowTime.ts

@@ -92,9 +92,9 @@ class WindowTimeSubscriber<T> extends Subscriber<T> {
   private windows: Subject<T>[] = [];
 
   constructor(protected destination: Subscriber<Observable<T>>,
-              private windowTimeSpan: number,
-              private windowCreationInterval: number,
-              private scheduler: Scheduler) {
+              windowTimeSpan: number,
+              windowCreationInterval: number,
+              scheduler: Scheduler) {
     super(destination);
     if (windowCreationInterval !== null && windowCreationInterval >= 0) {
       let window = this.openWindow();

src/operator/windowToggle.ts

@@ -155,7 +155,7 @@ class WindowToggleSubscriber<T, O> extends OuterSubscriber<T, any> {
 
     if (outerValue === this.openings) {
 
-      const { closingSelector } = this;
+      const closingSelector = this.closingSelector;
       const closingNotifier = tryCatch(closingSelector)(innerValue);
 
       if (closingNotifier === errorObject) {