Type parameter gets optionalized during call signature comparison

Bug Report

🔎 Search Terms

type parameter union undefined optional

🕗 Version & Regression Information

3.3.3333, 4.1.3, master (303ed3a357)

⏯ Playground Link

Playground link with relevant code

💻 Code

interface A {
  <T>(
    executor: (
      resolve: {
        (value: T): void;
      } & {
        (value?: T): void;
      }
    ) => void
  ): T;
}

interface B {
  <T>(
    executor: (
      resolve: {
        (value: T): void;
      } & {
        (value?: T): void;
      }
    ) => void
  ): T;
}

const a: B = {} as A;

🙁 Actual behavior

Compile error at the last line:

Type 'A' is not assignable to type 'B'.
  Type 'T | undefined' is not assignable to type 'T'.
    'T' could be instantiated with an arbitrary type which could be unrelated to 'T | undefined'.
      Type 'undefined' is not assignable to type 'T'.
        'T' could be instantiated with an arbitrary type which could be unrelated to 'undefined'.

🙂 Expected behavior

There should be no compile error, as A and B have exactly the same definition.

Start by reproducing the assignment error from the linked Playground example and inspect the compiler's call-signature comparison and type-parameter handling. Trace why the identical definitions produce T | undefined versus T, then verify that the example compiles without error while preserving the reported behavior.