Suggestion: Reference expression type during cast

Search Terms

cast reference expression type

Suggestion

I would like to be able to reference original type of the expression during cast.
For example:

const o = {
    x: { a: 1 } as typeof & { b?: number }
}

// type of o.x is now { a: number; b?: number }

I am not attached to typeof syntax here, can be anything that makes sense.

Use Cases

1. Defining optional properties without actually initializing them.
   Current approach would require me to do something like:

const o = {
    x: { a: 1 } as { a: number; b?: number }
}

which is unweildy and repeats all the properties.
It is possible to do through a function, but it has an overhead and is complicated due to partial generics:

function extend<T>(T data) {
    return <TExtra>() => data as T & TExtra;
}

const o = {
    x: extend({ a: 1 })<{ b?: number }>()
}

2. Adding indexers to object literals:

function map1(key: string) {
    return { a: 1, b: 2 }[key] || 3; // does not work due to https://github.com/microsoft/TypeScript/issues/14951
}

function map2(key: string) {
    return ({ a: 1, b: 2 } as { [key: string]: typeof[keyof typeof]|undefined })[key] || 3;
}

Examples

See use cases.

Checklist

My suggestion meets these guidelines:

• 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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Aucun fichier source, test ou point d'entrée n'est nommé dans l'issue. Commencez par examiner la syntaxe de cast proposée et les deux cas d'utilisation, puis déterminez la conception nécessaire du système de types et de la syntaxe ; le travail serait considéré comme terminé avec une approche acceptée et le périmètre d'implémentation correspondant.