Function shapes with union typed params incorrectly accept more restrictive functions

[lucasray]

TypeScript Version: 2.0.0 beta

Functions typed to accept union typed params incorrectly typecheck against functions whose params only match a subset of the union. Example:

interface Callback {
  (value: string | number): void;
}

// expect this to work
const many: Callback = (value: string | number | boolean) => {
  // ...
}

// expect a type error here
const one: Callback = (value: string) => {
  // ...
}

many(1);       // should work, does work
one(1);        // shouldn't work, does work *
many("hello"); // should work, does work
one("hello");  // should work, does work
many(true);    // shouldn't work, doesn't work
one(true);     // shouldn't work, doesn't work

Expected
one throws a type error, since string | number is not assignable to string.

Actual
one compiles fine.

This comes up in real code when declaring a callback whose params may not be defined, e.g.

interface SomeLib {
  onChange: (callback: (newValue: string | null) => void) => void;
}

const foo: SomeLib = ...;
foo.onChange((newValue: string) => {
  // oops, I forgot newValue may not be defined, but this compiles
});

[RyanCavanaugh]

See https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-function-parameters-bivariant

[lucasray]

Interesting, makes sense, thanks for the link. I'll keep an eye out for covariant/contravariant annotations.