Optional parameter makes the compiler resolve types prematurely for declaration

[devanshj]

Bug Report

🔎 Search Terms

optional parameter, resolution of types, declaration, optimization

🕗 Version & Regression Information

v4.4.4

⏯ Playground Link

Playground for test1.ts Playground for test2.ts

💻 Code

// @file test1.ts
export interface Types {}
  
type Key = 
  Types extends { key: unknown[] }
    ? Types["key"]
    : unknown[]

export const clear = (key: [...Key]) => {}

// @file test2.ts
export interface Types {}
  
type Key = 
  Types extends { key: unknown[] }
    ? Types["key"]
    : unknown[]

export const clear = (key?: [...Key]) => {} // change here, key is optional

🙁 Actual behavior

// @file test1.d.ts
export interface Types {
}
declare type Key = Types extends {
    key: unknown[];
} ? Types["key"] : unknown[];
export declare const clear: (key: [...Key]) => void;
export {};

// @file test2.d.ts
export interface Types {
}
export declare const clear: (key?: unknown[] | undefined) => void;

Compiler prematurely resolves Key to unknown[] in test2

🙂 Expected behavior

Compiler should emit declaration of test2 same as test1 (except the "?" part of course), it should not prematurely resolve Key to unknown[] because one could add a key property to Types via module augmentation which makes the Key type no longer unknown[]

[tadhgmister]

adding |undefined to the optional parameter fixes this. I suspect the adding of | undefined is to support legacy stuff and it resolves early, if you explicitly say the optional parameter can be passed as undefined then it doesn't need to try to resolve your type to see if adding it would be redundant.