Conditionally typed parameter and unions not enforced

[jeffijoe]

TypeScript Version: 3.9.2

Search Terms: typescript pass callback undefined conditional type

Expected behavior: passing a callback that specifies T as the parameter type to a target that specifies T | undefined after evaluating the conditional type should emit an error.

Actual behavior: passing a callback that specifies T as the parameter type to a target that specifies T | undefined after evaluating the conditional type does not emit an error, resulting in potentially attempting to access properties of undefined. By wrapping it in (v) => callback(v) however, the behavior is correct.

Related Issues: Some that might have the opposite problem? Not sure though. #26013

Code

interface Params<T, B extends boolean> {
    shouldUseArray: B
    callback(value: B extends true ? T[] : T | undefined): void
}

declare function fn<T, B extends boolean>(value: T, params: Params<T, B>): void

declare function myCallback(num: number): void

const input: number = 123

fn(input, {
    shouldUseArray: false,
    // good, the undefined check is enforced
    callback: v => myCallback(v)
                          //  ^ possible undefined, so this works
})

fn(input, {
    shouldUseArray: false,
    // bad, the undefined check is not enforced
    callback: myCallback
})

Output

"use strict";
const input = 123;
fn(input, {
    shouldUseArray: false,
    // good, the undefined check is enforced
    callback: v => myCallback(v)
});
fn(input, {
    shouldUseArray: false,
    // bad, the undefined check is not enforced
    callback: myCallback
});

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

[RyanCavanaugh]

Functions declared with method syntax are checked bivariantly. You should write it as

    callback: (value: B extends true ? T[] : (T | undefined)) => void

if you want contravariant parameter checking, which you do.

[jeffijoe]

Interesting, I didn't know that! I always thought the 2 were equivalent.

What's the rationale behind that? Is it documented somewhere?

I thought it would be a bug because I got some runtime errors because of it.

[RyanCavanaugh]

See comments in #18654

We need to add this to the reference pages in the new TS Handbook. Unfortunately this is the kind of thing where no one goes digging through the docs to discover it until after they've already noticed, at which point it's already sort of too late.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.