Repository: TypeScript
Issue: Mechanism for late inferred types in control flow analysis
Labels: Suggestion,Awaiting More Feedback

### 🔍 Search Terms

"control flow analysis" with variations of array, widening, callbacks, etc



### ✅ Viability Checklist

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

### ⭐ Suggestion

I have an issue where I want to capture a type defined in a scope that is inaccessible from my current scope. For example, I want to create a wrapper for some OpenAI function.


[Playground](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAcgmApgOwIbAQbjgenzgCkBXAZ3hgjgHMUqALFOGAT1XNZoBsIMAJgCgh7VHACyGWsADGcALxw0KAG4ooOIYTg8GcFAA8wGNAOBpaAQShQMbAFxwbdtgB4pM2QD5FcANoAuiJ68EYmZhbWtvZ+QSKiHCwAwjzA6PBKAJJolKayKAAqSW5iKBAAZnCgkLAAFEiomNgAlAB0APJNVlneIrIQufDI6Fh+AN4AvnAYXKnpaDBaieJdMMCDXErjQnB7cIMSKOTk0igASseQuShOdSDHp2dOZZUGxqbmli72-mikIAARhpAnAWopfKoIMBhJN+pt4AIIABlGCkCpVJR1ZDrTZONYbXLghS+Hb7A5NLBtWSMDAwakQcChQnkalQFB0lB1Mnk-YgCACFA8JwIGl02hgGAAWgALBApTxOZQEAAaXa8vYPE5nchOeLkybtGDMNB1dnka7kFgkuA8jUDIa2qAQPQquBtD3mmDTJTmy0oamMaEFcj+AAMgTaWtO9BEGr2OgAEhoUAguAB3ZjsuBZOAVCwYHg8Nhwc0u9RwIPpnNwdOmJgsci08TUXQQCAAa10wA7KHVGvCnyiPzYbTAFEYdX78b24w9bS9brKIpAbClsgo1BAUrKCBmXAdlDhM5a0-JZTgAHF2wI-K8qoPIt8Ymw-gDgVBAngdNeBdUuGUt4DLYKCyDAxZwICpDwHwsiFtwrCMMAXDkAMqBxvGOIsm0hyPGclwWpsXKPl80SuOGgTgjohRIShQakDwt7AqwSRwKcFQsJ8ygQPAABWm7KGoGjToaQhwiIF4AEKCHeSRvCRw4vjgQA)


```ts
import 'openai'; // Just to get the types to load

type Magic = never;
// let expandingArray: Array<Magic> = []

let expandingArray = []

type Client = InstanceType<typeof import('openai').OpenAI>

const openai = {} as Client;

type Options = {
    onMessageResponse: (message: typeof expandingArray[number]) => void
}

const doStuff = (options: Options) => {
    openai.chat.completions.create({
        model: 'chatgpt-4o-latest',
        messages: []
    }).then(response => {
        const {role, ...rest} = response.choices[0].message

        // Here's where I finally resolve how I want the shape to look like
        expandingArray.push(
            {...rest, type: 'my-custom-type' as const}
        )
        type Good = typeof expandingArray[number]; // Good is typed correctly but local to this scope

        options.onMessageResponse(expandingArray[0]) // This should be type-safe and not just never
    })
}

type Bad = typeof expandingArray;
```

As you can see, the goal is to have an auto-widening type based on usage later on (within the same file). This somewhat already works with control flow analysis for arrays, as you can see in the `type Good = ...` type above.

Realistically, when this situation occurs, application authors will type `onMessageResponse` as `(message: any) => void`, which is unfortunate because all the type information is there and just needs a way to be bubbled up to the higher scope.

It would be nice if there was an escape hatch to tell the type system that I care about the typeof a value declared somewhere inaccessible to the current type scope within the file. Obviously, this wouldn't actually use an untyped array with some annotation on the type; this would probably be a special new named type like LateInferredType or something similar, e.g.:

```ts
type Message = LateInferredType;

type Options = {
    onMessageResponse: (message: Message) => void
}

/// ...
    .then(response => {
        const {role, ...rest} = response.choices[0].message

        // Here's where I finally resolve how I want the shape to look like
        const message = {...rest, type: 'my-custom-type' as const}

        options.onMessageResponse(message as Message) // Perhaps casting signals to the type system to recognize it
    })
```

Or perhaps there's a non-breaking way of declaring this syntax that I'm not thinking of.



### 📃 Motivating Example

This allows smarter inference without needing to chase down every derived property. Sometime the specific types aren't even exported by the upstream libraries and there's no good way to mention them without recreating a large complex type which is fragile and error prone.

### 💻 Use Cases

1. What do you want to use this for?
  This is useful for writing type safe code where you want to expose a complex type that doesn't have a concrete definition and is more tied to the specific shape of a single step in a complex application
2. What shortcomings exist with current approaches?
  There's no way to signal later in a program or without a callback that a type should be widened, but sometimes that exact functionality is needed
3. What workarounds are you using in the meantime?
  None