Allow any key type as an index signature parameter type

src/compiler/binder.ts

@@ -173,6 +173,10 @@ namespace ts {
 
     const binder = createBinder();
 
+    function createSymbolTable() {
+        return Debug.flagCheckerImmutableObject(ts.createSymbolTable());
+    };
+
     export function bindSourceFile(file: SourceFile, options: CompilerOptions) {
         tracing?.push(tracing.Phase.Bind, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);
         performance.mark("beforeBind");

src/compiler/core.ts

@@ -92,6 +92,22 @@ namespace ts {
         return undefined;
     }
 
+    export function forEachType<T>(type: Type, f: (t: Type) => T | undefined): T | undefined {
+        return type.flags & TypeFlags.Union ? forEach((<UnionType>type).types, f) : f(type);
+    }
+
+    export function someType(type: Type, f: (t: Type) => boolean): boolean {
+        return type.flags & TypeFlags.Union ? some((<UnionType>type).types, f) : f(type);
+    }
+
+    export function everyType(type: Type, f: (t: Type) => boolean): boolean {
+        return type.flags & TypeFlags.Union ? every((<UnionType>type).types, f) : f(type);
+    }
+
+    export function everyContainedType(type: Type, f: (t: Type) => boolean): boolean {
+        return type.flags & TypeFlags.UnionOrIntersection ? every((type as UnionOrIntersectionType).types, f) : f(type);
+    }
+
     /**
      * Like `forEach`, but iterates in reverse order.
      */

src/compiler/debug.ts

@@ -171,6 +171,22 @@ namespace ts {
             return value;
         }
 
+        export function flagCheckerImmutableObject<T extends object>(object: T): T {
+            if (isDebugging) {
+                Object.defineProperties(object, {
+                    __debugImmutable: {
+                        value: true
+                    }
+                });
+            }
+            return object;
+        }
+
+        export function assertMutable<T extends object>(object: T): T {
+            assert(!(object as any).__debugImmutable, "Object is flagged as checker-immutable, but is used in a position requiring mutation");
+            return object;
+        }
+
         /**
          * @deprecated Use `checkDefined` to check whether a value is defined inline. Use `assertIsDefined` to check whether
          * a value is defined at the statement level.

src/compiler/diagnosticMessages.json

@@ -75,7 +75,7 @@
         "category": "Error",
         "code": 1022
     },
-    "An index signature parameter type must be either 'string' or 'number'.": {
+    "An index signature parameter type must be assignable to 'string | number | symbol'.": {
         "category": "Error",
         "code": 1023
     },
@@ -992,14 +992,6 @@
         "category": "Error",
         "code": 1335
     },
-    "An index signature parameter type cannot be a type alias. Consider writing '[{0}: {1}]: {2}' instead.": {
-        "category": "Error",
-        "code": 1336
-    },
-    "An index signature parameter type cannot be a union type. Consider using a mapped object type instead.": {
-        "category": "Error",
-        "code": 1337
-    },
     "'infer' declarations are only permitted in the 'extends' clause of a conditional type.": {
         "category": "Error",
         "code": 1338
@@ -1522,7 +1514,7 @@
         "category": "Error",
         "code": 2329
     },
-    "Index signatures are incompatible.": {
+    "'{0}' and '{1}' index signatures are incompatible.": {
         "category": "Error",
         "code": 2330
     },
@@ -1842,15 +1834,11 @@
         "category": "Error",
         "code": 2410
     },
-    "Property '{0}' of type '{1}' is not assignable to string index type '{2}'.": {
+    "Property '{0}' of type '{1}' is not assignable to '{2}' index type '{3}'.": {
         "category": "Error",
         "code": 2411
     },
-    "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'.": {
-        "category": "Error",
-        "code": 2412
-    },
-    "Numeric index type '{0}' is not assignable to string index type '{1}'.": {
+    "'{0}' index type '{1}' is not assignable to '{2}' index type '{3}'.": {
         "category": "Error",
         "code": 2413
     },
@@ -2682,6 +2670,10 @@
         "category": "Error",
         "code": 2633
     },
+    "'{0}' index signatures are incompatible.": {
+        "category": "Error",
+        "code": 2634
+    },
 
     "Cannot augment module '{0}' with value exports because it resolves to a non-module entity.": {
         "category": "Error",

src/compiler/symbolWalker.ts

@@ -8,7 +8,7 @@ namespace ts {
         resolveStructuredTypeMembers: (type: ObjectType) => ResolvedType,
         getTypeOfSymbol: (sym: Symbol) => Type,
         getResolvedSymbol: (node: Node) => Symbol,
-        getIndexTypeOfStructuredType: (type: Type, kind: IndexKind) => Type | undefined,
+        getIndexInfosOfType: (type: Type) => readonly IndexInfo[] | undefined,
         getConstraintOfTypeParameter: (typeParameter: TypeParameter) => Type | undefined,
         getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier,
         getTypeArguments: (type: TypeReference) => readonly Type[]) {
@@ -140,10 +140,13 @@ namespace ts {
             }
 
             function visitObjectType(type: ObjectType): void {
-                const stringIndexType = getIndexTypeOfStructuredType(type, IndexKind.String);
-                visitType(stringIndexType);
-                const numberIndexType = getIndexTypeOfStructuredType(type, IndexKind.Number);
-                visitType(numberIndexType);
+                const infos = getIndexInfosOfType(type);
+                if (infos) {
+                    for (const info of infos) {
+                        visitType(info.indexType);
+                        visitType(info.type);
+                    }
+                }
 
                 // The two checks above *should* have already resolved the type (if needed), so this should be cached
                 const resolved = resolveStructuredTypeMembers(type);

src/compiler/types.ts

@@ -4056,9 +4056,9 @@ namespace ts {
         getPropertyOfType(type: Type, propertyName: string): Symbol | undefined;
         getPrivateIdentifierPropertyOfType(leftType: Type, name: string, location: Node): Symbol | undefined;
         /* @internal */ getTypeOfPropertyOfType(type: Type, propertyName: string): Type | undefined;
-        getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined;
+        getIndexInfosOfType(type: Type, indexType?: Type): readonly IndexInfo[] | undefined;
         getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[];
-        getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined;
+        getIndexTypeOfType(type: Type, indexType: Type): Type | undefined;
         getBaseTypes(type: InterfaceType): BaseType[];
         getBaseTypeOfLiteralType(type: Type): Type;
         getWidenedType(type: Type): Type;
@@ -4086,8 +4086,8 @@ namespace ts {
         signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): SignatureDeclaration & {typeArguments?: NodeArray<TypeNode>} | undefined;
         /* @internal */ signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined, tracker?: SymbolTracker): SignatureDeclaration & {typeArguments?: NodeArray<TypeNode>} | undefined; // eslint-disable-line @typescript-eslint/unified-signatures
         /** Note that the resulting nodes cannot be checked. */
-        indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): IndexSignatureDeclaration | undefined;
-        /* @internal */ indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined, tracker?: SymbolTracker): IndexSignatureDeclaration | undefined; // eslint-disable-line @typescript-eslint/unified-signatures
+        indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, enclosingDeclaration: Node | undefined, flags?: NodeBuilderFlags): IndexSignatureDeclaration | undefined;
+        /* @internal */ indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, enclosingDeclaration: Node | undefined, flags?: NodeBuilderFlags, tracker?: SymbolTracker): IndexSignatureDeclaration | undefined;  // eslint-disable-line @typescript-eslint/unified-signatures
         /** Note that the resulting nodes cannot be checked. */
         symbolToEntityName(symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): EntityName | undefined;
         /** Note that the resulting nodes cannot be checked. */
@@ -4210,9 +4210,10 @@ namespace ts {
         /* @internal */ createArrayType(elementType: Type): Type;
         /* @internal */ getElementTypeOfArrayType(arrayType: Type): Type | undefined;
         /* @internal */ createPromiseType(type: Type): Type;
+        /* @internal */ createAnonymousType(symbol: Symbol | undefined, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[] | undefined): Type; // tslint:disable-line unified-signatures
+        /* @internal */ createAnonymousType(symbol: Symbol | undefined, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo | undefined, numberIndexInfo: IndexInfo | undefined): Type;
 
         /* @internal */ isTypeAssignableTo(source: Type, target: Type): boolean;
-        /* @internal */ createAnonymousType(symbol: Symbol | undefined, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo | undefined, numberIndexInfo: IndexInfo | undefined): Type;
         /* @internal */ createSignature(
             declaration: SignatureDeclaration,
             typeParameters: readonly TypeParameter[] | undefined,
@@ -4224,7 +4225,7 @@ namespace ts {
             flags: SignatureFlags
         ): Signature;
         /* @internal */ createSymbol(flags: SymbolFlags, name: __String): TransientSymbol;
-        /* @internal */ createIndexInfo(type: Type, isReadonly: boolean, declaration?: SignatureDeclaration): IndexInfo;
+        /* @internal */ createIndexInfo(indexType: Type, type: Type, isReadonly: boolean, declaration?: IndexSignatureDeclaration): IndexInfo;
         /* @internal */ isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         /* @internal */ tryFindAmbientModule(moduleName: string): Symbol | undefined;
         /* @internal */ tryFindAmbientModuleWithoutAugmentations(moduleName: string): Symbol | undefined;
@@ -5239,8 +5240,7 @@ namespace ts {
         /* @internal */ properties?: Symbol[];             // Properties
         /* @internal */ callSignatures?: readonly Signature[];      // Call signatures of type
         /* @internal */ constructSignatures?: readonly Signature[]; // Construct signatures of type
-        /* @internal */ stringIndexInfo?: IndexInfo;      // String indexing info
-        /* @internal */ numberIndexInfo?: IndexInfo;      // Numeric indexing info
+        /* @internal */ indexInfos?: readonly IndexInfo[];          // Index infos
         /* @internal */ objectTypeWithoutAbstractConstructSignatures?: ObjectType;
     }
 
@@ -5265,8 +5265,7 @@ namespace ts {
         declaredProperties: Symbol[];                   // Declared members
         declaredCallSignatures: Signature[];            // Declared call signatures
         declaredConstructSignatures: Signature[];       // Declared construct signatures
-        declaredStringIndexInfo?: IndexInfo; // Declared string indexing info
-        declaredNumberIndexInfo?: IndexInfo; // Declared numeric indexing info
+        declaredIndexInfos?: IndexInfo[];               // Declared indexing infos
     }
 
     /**
@@ -5424,6 +5423,7 @@ namespace ts {
         properties: Symbol[];             // Properties
         callSignatures: readonly Signature[];      // Call signatures of type
         constructSignatures: readonly Signature[]; // Construct signatures of type
+        indexKeysConstrainedInstantiation?: Type;
     }
 
     /* @internal */
@@ -5649,6 +5649,7 @@ namespace ts {
     }
 
     export interface IndexInfo {
+        indexType: Type;
         type: Type;
         isReadonly: boolean;
         declaration?: IndexSignatureDeclaration;

src/harness/fourslashImpl.ts

@@ -843,7 +843,7 @@ namespace FourSlash {
             else {
                 for (const marker of toArray(options.marker)) {
                     this.goToMarker(marker);
-                    this.verifyCompletionsWorker(options);
+                    this.verifyCompletionsWorker({ ...options, marker });
                 }
             }
         }

src/lib/es5.d.ts

@@ -94,7 +94,7 @@ interface PropertyDescriptor {
 }
 
 interface PropertyDescriptorMap {
-    [s: string]: PropertyDescriptor;
+    [s: string | number | symbol]: PropertyDescriptor;
 }
 
 interface Object {