[ID-Prep] Preserve type nodes from function expressions in initialisers

🔍 Search Terms

declaration emit preserve types from functions

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Preserve types from function expressions in initializers when emitting declarations.

📃 Motivating Example

// index.ts
type P = {} & { foo: boolean };
export let fn = (p: P, p2:typeof p) => {}

// index-current.d.ts
type P = {} & { foo: boolean };
export declare let fn: (p: P, p2: {
    foo: boolean;
}) => void;
export {};

// index-proposed.d.ts
type P = {} & { foo: boolean };
export declare let fn: (p: P, p2: typeof p2) => void;
export {};

💻 Use Cases

1. What do you want to use this for?
   This would improvement would can bring us closer to external declaration emitters being a reality.
2. What shortcomings exist with current approaches?
   An external tool can extract the type from the function expression, but then they would have different declarations. It would be great if, where possible, typescript would also preserve types as written.
3. What workarounds are you using in the meantime?
   We could force users to always specify the type even when it's obvious from the function expression, but this makes for very frustrating DX

Non vengono indicati file sorgente, test o punti di ingresso. Riproduci l’esempio alla base del problema e analizza il comportamento di TypeScript nell’emissione delle dichiarazioni; il lavoro è completato quando i tipi degli inizializzatori delle espressioni di funzione vengono preservati così come sono scritti nella dichiarazione emessa, senza modificare l’output JavaScript.