Preserve input computed names in output declaration files when they are entity name expressions

weswigham · weswigham · commit 37c14b89b59d · 2024-09-24T15:28:50.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -157,6 +157,7 @@ import {
     ElementAccessChain,
     ElementAccessExpression,
     ElementFlags,
+    ElementWithComputedPropertyName,
     EmitFlags,
     EmitHint,
     emitModuleKindIsNonNodeESM,
@@ -6700,7 +6701,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
                 function shouldWriteTypeOfFunctionSymbol() {
                     const isStaticMethodSymbol = !!(symbol.flags & SymbolFlags.Method) && // typeof static method
-                        some(symbol.declarations, declaration => isStatic(declaration));
+                        some(symbol.declarations, declaration => isStatic(declaration) && !isLateBindableIndexSignature(getNameOfDeclaration(declaration)!));
                     const isNonLocalFunctionSymbol = !!(symbol.flags & SymbolFlags.Function) &&
                         (symbol.parent || // is exported function symbol
                             forEach(symbol.declarations, declaration => declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock));
@@ -7056,6 +7057,37 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 return ids;
             }
 
+            function indexInfoToObjectComputedNamesOrSignatureDeclaration(indexInfo: IndexInfo, context: NodeBuilderContext, typeNode: TypeNode | undefined): [IndexSignatureDeclaration] | PropertySignature[] {
+                if (indexInfo.components) {
+                    // Index info is derived from object or class computed property names (plus explicit named members) - we can clone those instead of writing out the result computed index signature
+                    let unusableResult = false;
+                    const result = map(indexInfo.components, e => {
+                        if (e.name && isComputedPropertyName(e.name) && isEntityNameExpression(e.name.expression)) {
+                            trackComputedName(e.name.expression, context.enclosingDeclaration, context);
+                        }
+                        else {
+                            // Computed name didn't take the form `[a.b.c]: something` - bail on using the computed name.
+                            // TODO: Issue isolated declarations error on this fallback?
+                            unusableResult = true;
+                        }
+                        return setTextRange(
+                            context,
+                            factory.createPropertySignature(
+                                indexInfo.isReadonly ? [factory.createModifier(SyntaxKind.ReadonlyKeyword)] : undefined,
+                                e.name,
+                                /*questionToken*/ undefined,
+                                typeNode || typeToTypeNodeHelper(getTypeOfSymbol(e.symbol), context),
+                            ),
+                            e,
+                        );
+                    });
+                    if (!unusableResult) {
+                        return result;
+                    }
+                }
+                return [indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, typeNode)];
+            }
+
             function createTypeNodesFromResolvedType(resolvedType: ResolvedType): TypeElement[] | undefined {
                 if (checkTruncationLength(context)) {
                     if (context.flags & NodeBuilderFlags.NoTruncation) {
@@ -7072,7 +7104,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     typeElements.push(signatureToSignatureDeclarationHelper(signature, SyntaxKind.ConstructSignature, context) as ConstructSignatureDeclaration);
                 }
                 for (const info of resolvedType.indexInfos) {
-                    typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & ObjectFlags.ReverseMapped ? createElidedInformationPlaceholder(context) : undefined));
+                    typeElements.push(...indexInfoToObjectComputedNamesOrSignatureDeclaration(info, context, resolvedType.objectFlags & ObjectFlags.ReverseMapped ? createElidedInformationPlaceholder(context) : undefined));
                 }
 
                 const properties = resolvedType.properties;
@@ -16247,8 +16279,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return symbolTable.get(InternalSymbolName.Index);
     }
 
-    function createIndexInfo(keyType: Type, type: Type, isReadonly: boolean, declaration?: IndexSignatureDeclaration): IndexInfo {
-        return { keyType, type, isReadonly, declaration };
+    function createIndexInfo(keyType: Type, type: Type, isReadonly: boolean, declaration?: IndexSignatureDeclaration, components?: ElementWithComputedPropertyName[]): IndexInfo {
+        return { keyType, type, isReadonly, declaration, components };
     }
 
     function getIndexInfosOfSymbol(symbol: Symbol): IndexInfo[] {
@@ -19845,7 +19877,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function getIndexInfoWithReadonly(info: IndexInfo, readonly: boolean) {
-        return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info;
+        return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration, info.components) : info;
     }
 
     function createLiteralType(flags: TypeFlags, value: string | number | PseudoBigInt, symbol?: Symbol, regularType?: LiteralType) {
@@ -20722,7 +20754,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function instantiateIndexInfo(info: IndexInfo, mapper: TypeMapper) {
-        return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration);
+        return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration, info.components);
     }
 
     // Returns true if the given expression contains (at any level of nesting) a function or arrow expression
@@ -25506,7 +25538,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
             }
         }
-        const result = createAnonymousType(type.symbol, members, emptyArray, emptyArray, sameMap(getIndexInfosOfType(type), info => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly)));
+        const result = createAnonymousType(type.symbol, members, emptyArray, emptyArray, sameMap(getIndexInfosOfType(type), info => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly, info.declaration, info.components)));
         result.objectFlags |= getObjectFlags(type) & (ObjectFlags.JSLiteral | ObjectFlags.NonInferrableType); // Retain js literal flag through widening
         return result;
     }
@@ -32881,9 +32913,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), TypeFlags.ESSymbol));
     }
 
+    function isSymbolWithComputedName(symbol: Symbol) {
+        const firstDecl = symbol.declarations?.[0];
+        return firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name);
+    }
+
     // NOTE: currently does not make pattern literal indexers, eg `${number}px`
     function getObjectLiteralIndexInfo(isReadonly: boolean, offset: number, properties: Symbol[], keyType: Type): IndexInfo {
         const propTypes: Type[] = [];
+        let components: ElementWithComputedPropertyName[] | undefined;
         for (let i = offset; i < properties.length; i++) {
             const prop = properties[i];
             if (
@@ -32892,10 +32930,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 keyType === esSymbolType && isSymbolWithSymbolName(prop)
             ) {
                 propTypes.push(getTypeOfSymbol(properties[i]));
+                if (isSymbolWithComputedName(properties[i])) {
+                    components = append(components, properties[i].declarations?.[0]! as ElementWithComputedPropertyName);
+                }
             }
         }
         const unionType = propTypes.length ? getUnionType(propTypes, UnionReduction.Subtype) : undefinedType;
-        return createIndexInfo(keyType, unionType, isReadonly);
+        return createIndexInfo(keyType, unionType, isReadonly, /*declaration*/ undefined, components);
     }
 
     function getImmediateAliasedSymbol(symbol: Symbol): Symbol | undefined {
@@ -45911,9 +45952,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         const typeDeclaration = symbol.valueDeclaration;
         if (typeDeclaration && isClassLike(typeDeclaration)) {
             for (const member of typeDeclaration.members) {
-                // Only process instance properties with computed names here. Static properties cannot be in conflict with indexers,
-                // and properties with literal names were already checked.
-                if (!isStatic(member) && !hasBindableName(member)) {
+                // Only process instance properties against instance index signatures and static properties against static index signatures
+                if (
+                    (
+                        (!isStaticIndex && !isStatic(member)) ||
+                        (isStaticIndex && isStatic(member))
+                    ) && !hasBindableName(member)
+                ) {
                     const symbol = getSymbolOfDeclaration(member);
                     checkIndexConstraintForProperty(type, symbol, getTypeOfExpression((member as DynamicNamedDeclaration).name.expression), getNonMissingTypeOfSymbol(symbol));
                 }
@@ -50540,6 +50585,31 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     result ||= [];
                     for (const info of infoList!) {
                         if (info.declaration) continue;
+                        if (info.components) {
+                            let unusableResult = false;
+                            const recreatedComponents = map(info.components, e => {
+                                if (e.name && isComputedPropertyName(e.name) && isEntityNameExpression(e.name.expression)) {
+                                    trackComputedName(e.name.expression);
+                                }
+                                else {
+                                    // Computed name didn't take the form `[a.b.c]: something` - bail on using the computed name.
+                                    // TODO: Issue isolated declarations error on this fallback?
+                                    unusableResult = true;
+                                }
+                                const mods = infoList === staticInfos ? [factory.createModifier(SyntaxKind.StaticKeyword)] as Modifier[] : undefined;
+                                return factory.createPropertyDeclaration(
+                                    append(mods, info.isReadonly ? factory.createModifier(SyntaxKind.ReadonlyKeyword) : undefined),
+                                    e.name,
+                                    /*questionOrExclamationToken*/ undefined,
+                                    nodeBuilder.typeToTypeNode(getTypeOfSymbol(e.symbol), enclosing, flags, internalFlags, tracker),
+                                    /*initializer*/ undefined,
+                                );
+                            });
+                            if (!unusableResult) {
+                                result.push(...recreatedComponents);
+                                continue;
+                            }
+                        }
                         const node = nodeBuilder.indexInfoToIndexSignatureDeclaration(info, enclosing, flags, internalFlags, tracker);
                         if (node && infoList === staticInfos) {
                             (((node as Mutable<typeof node>).modifiers ||= factory.createNodeArray()) as MutableNodeArray<Modifier>).unshift(factory.createModifier(SyntaxKind.StaticKeyword));
@@ -50550,6 +50620,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     }
                 }
                 return result;
+
+                function trackComputedName(accessExpression: EntityNameOrEntityNameExpression) {
+                    if (!tracker.trackSymbol) return;
+                    // get symbol of the first identifier of the entityName
+                    const firstIdentifier = getFirstIdentifier(accessExpression);
+                    const name = resolveName(firstIdentifier, firstIdentifier.escapedText, SymbolFlags.Value | SymbolFlags.ExportValue, /*nameNotFoundMessage*/ undefined, /*isUse*/ true);
+                    if (name) {
+                        tracker.trackSymbol(name, enclosing, SymbolFlags.Value);
+                    }
+                }
             },
         };
 
@@ -52000,7 +52080,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function checkGrammarForInvalidDynamicName(node: DeclarationName, message: DiagnosticMessage) {
-        if (isNonBindableDynamicName(node)) {
+        // Even non-bindable names are allowed as late-bound implied index signatures so long as the name is a simple `a.b.c` type name expression
+        if (isNonBindableDynamicName(node) && !isEntityNameExpression(isElementAccessExpression(node) ? skipParentheses(node.argumentExpression) : (node as ComputedPropertyName).expression)) {
             return grammarErrorOnNode(node, message);
         }
     }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -5867,7 +5867,7 @@ export interface EmitResolver {
     getDeclarationStatementsForSourceFile(node: SourceFile, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): Statement[] | undefined;
     isImportRequiredByAugmentation(decl: ImportDeclaration): boolean;
     isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
-    createLateBoundIndexSignatures(cls: ClassLikeDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): IndexSignatureDeclaration[] | undefined;
+    createLateBoundIndexSignatures(cls: ClassLikeDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): (IndexSignatureDeclaration | PropertyDeclaration)[] | undefined;
 }
 
 // dprint-ignore
@@ -6995,11 +6995,14 @@ export const enum IndexKind {
     Number,
 }
 
+export type ElementWithComputedPropertyName = (ClassElement | ObjectLiteralElement) & { name: ComputedPropertyName; };
+
 export interface IndexInfo {
     keyType: Type;
     type: Type;
     isReadonly: boolean;
     declaration?: IndexSignatureDeclaration;
+    components?: ElementWithComputedPropertyName[];
 }
 
 /** @internal */
