test(typings): Add compile tests for filter, find, first, last

These are from #2119

Author: tetsuharuohzeki

spec/operators/filter-spec.ts

@@ -272,4 +272,22 @@ describe('Observable.prototype.filter', () => {
     expectObservable(r, unsub).toBe(expected);
     expectSubscriptions(source.subscriptions).toBe(subs);
   });
-});
+
+  it('should not be compile error', () => {
+    // tslint:disable no-unused-variable
+
+    {
+      // x is `Observable<string | number>`
+      const x: Rx.Observable<string | number> = Observable.from([1, 'aaa', 3, 'bb']);
+      // This type guard will narrow a `string | number` to a string in the examples below
+      const isString = (x: string | number): x is string => typeof x === 'string';
+
+      // Here, `s` is a string in the second filter predicate after the type guard (yay - intellisense!)
+      const guardedFilter = x.filter(isString).filter(s => s.length === 2); // Observable<string>
+      // In contrast, this type of regular boolean predicate still maintains the original type
+      const boolFilter = x.filter(s => typeof s === 'number'); // Observable<string | number>
+    }
+
+    // tslint:disable enable
+  });
+});

spec/operators/find-spec.ts

@@ -155,4 +155,22 @@ describe('Observable.prototype.find', () => {
     expectObservable((<any>source).find(predicate)).toBe(expected);
     expectSubscriptions(source.subscriptions).toBe(subs);
   });
+
+  it('should not be compile error', () => {
+    // tslint:disable no-unused-variable
+
+    {
+      // x is `Observable<string | number>`
+      const x: Rx.Observable<string | number> = Observable.from([1, 'aaa', 3, 'bb']);
+      // This type guard will narrow a `string | number` to a string in the examples below
+      const isString = (x: string | number): x is string => typeof x === 'string';
+
+      // After the type guard `find` predicate, the type is narrowed to string
+      const guardedFind = x.find(isString).filter(s => s.length > 1).map(s => s.substr(1)); // Observable<string>  
+      // In contrast, a boolean predicate maintains the original type
+      const boolFind = x.find(x => typeof x === 'string'); // Observable<string | number>
+    }
+
+    // tslint:disable enable
+  });
 });

spec/operators/first-spec.ts

@@ -214,4 +214,25 @@ describe('Observable.prototype.first', () => {
     expectObservable(e1.first(predicate, resultSelector)).toBe(expected);
     expectSubscriptions(e1.subscriptions).toBe(sub);
   });
+
+  it('should not be compile error', () => {
+    // tslint:disable no-unused-variable
+
+    {
+      // x is `Observable<string | number>`
+      const x: Rx.Observable<string | number> = Observable.from([1, 'aaa', 3, 'bb']);
+      // This type guard will narrow a `string | number` to a string in the examples below
+      const isString = (x: string | number): x is string => typeof x === 'string';
+
+      // After the type guard `first` predicates, the type is narrowed to string
+      const guardedFirst1 = x.first(isString).filter(s => s.length > 1).map(s => s.substr(1)); // Observable<string>
+      const guardedFirst2 = x.first(isString, s => s.substr(0)).filter(s => s.length > 1); // Observable<string>
+      // Without a resultSelector, `first` maintains the original type (TS can't do this yet)
+      const boolFirst1 = x.first(x => typeof x === 'string', null, ''); // Observable<string | number>
+      // `first` still uses the `resultSelector` return type, if it exists.
+      const boolFirst2 = x.first(x => typeof x === 'string', s => ({str: `${s}`}), {str: ''}); // Observable<{str: string}>
+    }
+
+    // tslint:disable enable
+  });
 });

spec/operators/last-spec.ts

@@ -142,4 +142,25 @@ describe('Observable.prototype.last', () => {
     expectObservable(e1.last(predicate, resultSelector)).toBe(expected);
     expectSubscriptions(e1.subscriptions).toBe(e1subs);
   });
+
+  it('should not be compile error', () => {
+    // tslint:disable no-unused-variable
+
+    {
+      // x is `Observable<string | number>`
+      const x: Rx.Observable<string | number> = Rx.Observable.from([1, 'aaa', 3, 'bb']);
+      // This type guard will narrow a `string | number` to a string in the examples below
+      const isString = (x: string | number): x is string => typeof x === 'string';
+
+      // After the type guard `last` predicates, the type is narrowed to string
+      const guardedLast1 = x.last(isString).filter(s => s.length > 1).map(s => s.substr(1)); // Observable<string>
+      const guardedLast2 = x.last(isString, s => s.substr(0)).filter(s => s.length > 1); // Observable<string>
+      // Without a resultSelector, `last` maintains the original type (TS can't do this yet)
+      const boolLast1 = x.last(x => typeof x === 'string', null, ''); // Observable<string | number>
+      // `last` still uses the `resultSelector` return type, if it exists.
+      const boolLast2 = x.last(x => typeof x === 'string', s => ({str: `${s}`}), {str: ''}); // Observable<{str: string}>
+    }
+
+    // tslint:disable enable
+  });
 });