Infer extra parameter types from default values

[falsandtru]

TypeScript Version: nightly (2.5.0-dev.20170801)

Code

const cb: () => void = (a = 0) => a;
((cb: () => void) => cb)((a = 0) => a);

Expected behavior:

a is number type.

Actual behavior:

a is any type.

[olegdunkan]

When a function expression with no type parameters and no parameter type annotations is contextually typed (section 4.23) by a type T and a contextual signature S can be extracted from T, the function expression is processed as if it had explicitly specified parameter type annotations as they exist in S. Parameters are matched by position and need not have matching names. If the function expression has fewer parameters than S, the additional parameters in S are ignored. If the function expression has more parameters than S, the additional parameters are all considered to have type Any.

Isn't that case?

[DanielRosenwasser]

Thanks for linking to that @olegdunkan! It's indeed the specified behavior, though it's certainly surprising and it looks like noImplicitAny doesn't catch it.

[falsandtru]

This spec seems to say about default behaviors that has no default value. @ahejlsberg Does this spec mean that type inference has to ignore a type of default value too and still should be so even today?

[simonbuchan]

Seems like a spec bug: considered to have type Any should probably be whatever spec language would be for considered to have the type that would be inferred without a contextual signature.

[RyanCavanaugh]

@falsandtru how did you even end up in this state?

[falsandtru]

To define and initialize local variables. For example,

const count = ((a = 0) => () => ++a)();

can be used as shorthand for

const count = (() => {
    let a = 0;
    return () => ++a;
})();

[falsandtru]

Sorry, my previous example is wrong. Here is a correct one.

f((a = 0) => ++a);

function f(cb: () => void) {
}

[RyanCavanaugh]

Example in OP now works as hoped

[simonbuchan]

Aww, I was hoping that that would mean this works:

function getOr<T, K extends keyof T, D>(
  obj: T,
  key: K,
  // Type 'undefined' is not assignable to type 'D'.
  //  'D' could be instantiated with an arbitrary type which could be unrelated to 'undefined'.(2322)
  defaultValue: D = undefined,
): T[K] | D {
    if (key in obj) {
        return obj[key];
    } else {
        return defaultValue;
    }
}

// $ExpectType string | undefined
getOr(process.env, "SOME_VAR");
// $ExpectType string | null
getOr(process.env, "SOME_VAR", null);
// $ExpectType string
getOr(process.env, "SOME_VAR", "DEFAULT");