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.

In der Issue wird keine Quelldatei, kein Test und kein Einstiegspunkt genannt. Beginne damit, die vorgeschlagene Cast-Syntax und beide Anwendungsfälle zu prüfen, und bestimme anschließend das erforderliche Design für Typsystem und Syntax; abgeschlossen wäre dies mit einem akzeptierten Ansatz und dem entsprechenden Implementierungsumfang.