GeezerVison

This changes allows the use of an Identifier or PropertyAccessExpression as part of a computed property name in an interface, class, or type literal as long as the type of the expression is a string or numeric literal type, or is a unique symbol type.

Unique Symbol Types

A unique symbol type is created in specific cases when calling the global Symbol function or the global Symbol.for function, or when you use the unique symbol type.

Unique symbol types have several rules and restrictions:

• The unique symbol type may only be used on a const variable or readonly property declaration.
• The unique symbol type widens to symbol.
• Two unique symbol types are not assignable to each other.
• A unique symbol type is bound to the symbol of the declaration where it was defined.
  • This prevents assignability errors when merging declarations of the same variable/property that both define their type as unique symbol, as the names for these declarations merge into the same symbol.
• NOTE: Even though Symbol.for(x) would return the same ES Symbol at runtime if called multiple times for the same x, we currently treat separate calls to Symbol.for(x) as unique symbols. We may choose to revisit this in the future.

Examples

// main.ts (input)
const x = Symbol();
const y = x;
const z: typeof x = x;
interface SymbolConstructor {
  readonly iterator: unique symbol; 
}
interface SymbolConstructor {
  readonly iterator: unique symbol; // ok
}

// main.d.ts (declaration output)
const x: unique symbol;
const y: symbol;
const z: typeof x;
interface SymbolConstructor {
  readonly iterator: unique symbol; 
}
interface SymbolConstructor {
  readonly iterator: unique symbol;
}

Late Binding

Dynamic member names are resolved and "bound" in the checker on-demand whenever the members of a symbol are requested, allowing members with dynamic names to participate in type relationships.

Since dynamic members are bound later than syntactically recognizable member names, we disallow defining a member both syntactically and via a dynamic name so as not to introduce inconsistencies with overload resolution as the declarations might end up in the wrong order.

Examples

// main.ts (input)
export const x = "literal name";
const y = 1;
export interface A {
  [x]: string;
  [y]: string; // error: Interface 'A' has or is using private name '[y]' (when using --declaration)
}
type B {
  [x]: string;
  [y]: boolean;
}
let a: A;
let b: B;
a = b; // error: Type 'B' is not assignable to type 'A'. Types of property '[y]' are incompatible.

// main.d.ts (declaration output)
export declare const x = "literal name";
export interface A { 
  [x]: string; 
}

Fixes #2012
Fixes #5579
Fixes #7436 (via typeof SAYHELLO)
Fixes #11736 (via typeof opAdd)
Partially Fixes #13031 (via unique symbol type, though there are other issues that still block this)