Array.filter with a user-defined type guard predicate (arrow function) resolves to the wrong overload

[afroozeh]

TypeScript Version: 2.6.1

Code

interface Animal {
}

interface Cat extends Animal {
  meow(): void;
}

interface Dog extends Animal {
  bark(): void;
}

function isCat(animal: Animal): animal is Cat {
  return animal.hasOwnProperty("meow");
}

function isDog(animal: Animal): animal is Dog {
  return animal.hasOwnProperty("bark");
}

let animals: Animal[];

const cats: Cat[] = animals.filter(isCat);            // OK
const cats2: Cat[] = animals.filter(a => isCat(a));   // Type error

Expected behavior:
No errors

Actual behavior:

Error at cats2:

[ts]
Type 'Animal[]' is not assignable to type 'Cat[]'.
  Type 'Animal' is not assignable to type 'Cat'.
    Property 'meow' is missing in type 'Animal'.

The first call to filter on animals resolves to the function

filter<S extends T>(callbackfn: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];

while the second call resolves to:

filter(callbackfn: (value: T, index: number, array: T[]) => any, thisArg?: any): T[];

Duplicate of #5101 -- a => isCat(a) isn't explicitly annotated as being a type predicate, and we don't infer those.

[afroozeh]

A question: what's the difference between animals.filter(isCat) and animals.filter(a => isCat(a))? I thought the first one is a syntactic sugar for the second one, when there is only argument.

a => isCat(a) is a function literal expression that creates a new function. isCat is an identifier referring to an existing function. isCat has a type annotation declaring it to be a type predicate, but a => isCat(a) has no type annotations and relies on type inference. We will never infer a type predicate type, only boolean (#5101).

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.