Cascade type narrowing to child constants

Suggestion

🔍 Search Terms

narrow child variable related

✅ Viability 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, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

Constants that were assigned a child value of another variable or constant should have their type narrowed alongside their parent.

📃 Motivating Example

Consider the following code:

type SomeUnion = (
  | {type: "string", values: readonly string[]}
  | {type: "number", values: readonly number[]}
  | {type: "date", values: readonly Date[]}
);

function someFunction(union:SomeUnion, index:number): void {
  const value = union.values[index];
  if (union.type === "string") {
    union.values; // readonly string[]
    value; // string | number | Date
  }
}

In someFunction, TypeScript keeps the type of value as it was originally assigned (string | number | Date).

What if dev expects value to have been narrowed to string?

This already happens with the root keys of an object

type AnotherUnion = (
    | {type: "string", sibling: string, foo: {bar: string}}
    | {type: "number", sibling: number, foo: {bar: number}}
    | {type: "date", sibling: Date, foo: {bar: Date}}
);

function manualDestructure(union: AnotherUnion): void {
  const {type, sibling, foo: {bar}} = union;
  if (type === "string") {
    sibling; // string ✔️ 
    bar; // string | number | Date 😿 
  }
}

function argumentDestructure({type, sibling, foo: {bar}}: AnotherUnion): void {
  if (type === "string") {
    sibling; // string ✔️ 
    bar; // string | number | Date 😿 
  }
}

This is observable in both examples.

💻 Use Cases

Use case: Working with discriminated unions holding nested objects and arrays

To achieve such narrowing, one currently must adjust coding style. ie:

function adjustedScope(union:SomeUnion, index:number): void {
  if (union.type === "string") {
    const value = union.values[index];
    value; // string
  } else if (union.type === "number") {
    const value = union.values[index]; // 😭 
    value; // number
  }
}

// or

function typeAssertion(union:SomeUnion, index:number): void {
  const value = union.values[index];
  if (union.type === "string") {
    (value as string); // string
  } else if (union.type === "number") {
    (value as number); // number 😭 & risky?
  }
}

Issue の動機となっている TypeScript の例から始め、特にインデックス付きの子の値とネストされた分割代入のケースを確認します。判別共用体の絞り込みが子プロパティから派生した値にどのような影響を与えるべきかを判断し、その後、例が示されているとおり string、number、または Date に絞り込まれることを検証します。