Support some late-bound special property assignments

Author: weswigham

src/compiler/binder.ts

@@ -2521,7 +2521,14 @@ namespace ts {
                         // Declare a 'member' if the container is an ES5 class or ES6 constructor
                         constructorSymbol.members = constructorSymbol.members || createSymbolTable();
                         // It's acceptable for multiple 'this' assignments of the same identifier to occur
-                        declareSymbol(constructorSymbol.members, constructorSymbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
+                        if (hasDynamicName(node)) {
+                            bindAnonymousDeclaration(node, SymbolFlags.Property, InternalSymbolName.Computed);
+                            const members = constructorSymbol.assignmentDeclarationMembers || (constructorSymbol.assignmentDeclarationMembers = createMap());
+                            members.set("" + getNodeId(node), node);
+                        }
+                        else {
+                            declareSymbol(constructorSymbol.members, constructorSymbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes & ~SymbolFlags.Property);
+                        }
                         addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, SymbolFlags.Class);
                     }
                     break;
@@ -2535,7 +2542,14 @@ namespace ts {
                     // Bind this property to the containing class
                     const containingClass = thisContainer.parent;
                     const symbolTable = hasModifier(thisContainer, ModifierFlags.Static) ? containingClass.symbol.exports! : containingClass.symbol.members!;
-                    declareSymbol(symbolTable, containingClass.symbol, node, SymbolFlags.Property, SymbolFlags.None, /*isReplaceableByMethod*/ true);
+                    if (hasDynamicName(node)) {
+                        bindAnonymousDeclaration(node, SymbolFlags.Property, InternalSymbolName.Computed);
+                        const members = containingClass.symbol.assignmentDeclarationMembers || (containingClass.symbol.assignmentDeclarationMembers = createMap());
+                        members.set("" + getNodeId(node), node);
+                    }
+                    else {
+                        declareSymbol(symbolTable, containingClass.symbol, node, SymbolFlags.Property, SymbolFlags.None, /*isReplaceableByMethod*/ true);
+                    }
                     break;
                 case SyntaxKind.SourceFile:
                     // this.property = assignment in a source file -- declare symbol in exports for a module, in locals for a script
@@ -2621,7 +2635,17 @@ namespace ts {
                 bindExportsPropertyAssignment(node);
             }
             else {
-                bindStaticPropertyAssignment(lhs);
+                if (hasDynamicName(node)) {
+                    bindAnonymousDeclaration(node, SymbolFlags.Property | SymbolFlags.Assignment, InternalSymbolName.Computed);
+                    const sym = bindPotentiallyMissingNamespaces(parentSymbol, lhs.expression, isTopLevelNamespaceAssignment(lhs), /*isPrototype*/ false, /*containerIsClass*/ false);
+                    if (sym) {
+                        const members = sym.assignmentDeclarationMembers || (sym.assignmentDeclarationMembers = createMap());
+                        members.set("" + getNodeId(node), node);
+                    }
+                }
+                else {
+                    bindStaticPropertyAssignment(lhs);
+                }
             }
         }
 

src/compiler/checker.ts

@@ -2817,7 +2817,7 @@ namespace ts {
         }
 
         function getExportsOfSymbol(symbol: Symbol): SymbolTable {
-            return symbol.flags & SymbolFlags.Class ? getResolvedMembersOrExportsOfSymbol(symbol, MembersOrExportsResolutionKind.resolvedExports) :
+            return symbol.flags & SymbolFlags.LateBindingContainer ? getResolvedMembersOrExportsOfSymbol(symbol, MembersOrExportsResolutionKind.resolvedExports) :
                 symbol.flags & SymbolFlags.Module ? getExportsOfModule(symbol) :
                 symbol.exports || emptySymbols;
         }
@@ -4118,7 +4118,15 @@ namespace ts {
                 if (context.tracker.trackSymbol && getCheckFlags(propertySymbol) & CheckFlags.Late) {
                     const decl = first(propertySymbol.declarations);
                     if (hasLateBindableName(decl)) {
-                        trackComputedName(decl.name, saveEnclosingDeclaration, context);
+                        if (!isBinaryExpression(decl)) {
+                            trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
+                        }
+                        else {
+                            const name = getNameOfDeclaration(decl);
+                            if (name && isElementAccessExpression(name) && isPropertyAccessEntityNameExpression(name.argumentExpression)) {
+                                trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
+                            }
+                        }
                     }
                 }
                 const propertyName = symbolToName(propertySymbol, context, SymbolFlags.Value, /*expectsIdentifier*/ true);
@@ -4324,7 +4332,7 @@ namespace ts {
                     return <BindingName>elideInitializerAndSetEmitFlags(node);
                     function elideInitializerAndSetEmitFlags(node: Node): Node {
                         if (context.tracker.trackSymbol && isComputedPropertyName(node) && isLateBindableName(node)) {
-                            trackComputedName(node, context.enclosingDeclaration, context);
+                            trackComputedName(node.expression, context.enclosingDeclaration, context);
                         }
                         const visited = visitEachChild(node, elideInitializerAndSetEmitFlags, nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags)!;
                         const clone = nodeIsSynthesized(visited) ? visited : getSynthesizedClone(visited);
@@ -4336,10 +4344,10 @@ namespace ts {
                 }
             }
 
-            function trackComputedName(node: LateBoundName, enclosingDeclaration: Node | undefined, context: NodeBuilderContext) {
+            function trackComputedName(accessExpression: EntityNameOrEntityNameExpression, enclosingDeclaration: Node | undefined, context: NodeBuilderContext) {
                 if (!context.tracker.trackSymbol) return;
                 // get symbol of the first identifier of the entityName
-                const firstIdentifier = getFirstIdentifier(node.expression);
+                const firstIdentifier = getFirstIdentifier(accessExpression);
                 const name = resolveName(firstIdentifier, firstIdentifier.escapedText, SymbolFlags.Value | SymbolFlags.ExportValue, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true);
                 if (name) {
                     context.tracker.trackSymbol(name, enclosingDeclaration, SymbolFlags.Value);
@@ -5831,6 +5839,9 @@ namespace ts {
             if (declaration.kind === SyntaxKind.ExportAssignment) {
                 type = widenTypeForVariableLikeDeclaration(checkExpressionCached((<ExportAssignment>declaration).expression), declaration);
             }
+            else if (isBinaryExpression(declaration)) {
+                type = getWidenedTypeForAssignmentDeclaration(symbol);
+            }
             else if (isInJSFile(declaration) &&
                 (isCallExpression(declaration) || isBinaryExpression(declaration) || isPropertyAccessExpression(declaration) && isBinaryExpression(declaration.parent))) {
                 type = getWidenedTypeForAssignmentDeclaration(symbol);
@@ -6836,9 +6847,12 @@ namespace ts {
          * - The type of its expression is a string or numeric literal type, or is a `unique symbol` type.
          */
         function isLateBindableName(node: DeclarationName): node is LateBoundName {
-            return isComputedPropertyName(node)
-                && isEntityNameExpression(node.expression)
-                && isTypeUsableAsPropertyName(checkComputedPropertyName(node));
+            if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
+                return false;
+            }
+            const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
+            return isEntityNameExpression(expr)
+                && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
         }
 
         function isLateBoundName(name: __String): boolean {
@@ -6850,7 +6864,7 @@ namespace ts {
         /**
          * Indicates whether a declaration has a late-bindable dynamic name.
          */
-        function hasLateBindableName(node: Declaration): node is LateBoundDeclaration {
+        function hasLateBindableName(node: Declaration): node is LateBoundDeclaration | BinaryExpression {
             const name = getNameOfDeclaration(node);
             return !!name && isLateBindableName(name);
         }
@@ -6887,7 +6901,7 @@ namespace ts {
          * late-bound members that `addDeclarationToSymbol` in binder.ts performs for early-bound
          * members.
          */
-        function addDeclarationToLateBoundSymbol(symbol: Symbol, member: LateBoundDeclaration, symbolFlags: SymbolFlags) {
+        function addDeclarationToLateBoundSymbol(symbol: Symbol, member: LateBoundDeclaration | BinaryExpression, symbolFlags: SymbolFlags) {
             Debug.assert(!!(getCheckFlags(symbol) & CheckFlags.Late), "Expected a late-bound symbol.");
             symbol.flags |= symbolFlags;
             getSymbolLinks(member.symbol).lateSymbol = symbol;
@@ -6932,14 +6946,15 @@ namespace ts {
          * @param lateSymbols The late-bound symbols of the parent.
          * @param decl The member to bind.
          */
-        function lateBindMember(parent: Symbol, earlySymbols: SymbolTable | undefined, lateSymbols: SymbolTable, decl: LateBoundDeclaration) {
+        function lateBindMember(parent: Symbol, earlySymbols: SymbolTable | undefined, lateSymbols: SymbolTable, decl: LateBoundDeclaration | BinaryExpression) {
             Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
             const links = getNodeLinks(decl);
             if (!links.resolvedSymbol) {
                 // In the event we attempt to resolve the late-bound name of this member recursively,
                 // fall back to the early-bound name of this member.
                 links.resolvedSymbol = decl.symbol;
-                const type = checkComputedPropertyName(decl.name);
+                const declName = isBinaryExpression(decl) ? (getNameOfDeclaration(decl) as ElementAccessExpression) : decl.name;
+                const type = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
                 if (isTypeUsableAsPropertyName(type)) {
                     const memberName = getPropertyNameFromType(type);
                     const symbolFlags = decl.symbol.flags;
@@ -6956,9 +6971,9 @@ namespace ts {
                         // If we have an existing early-bound member, combine its declarations so that we can
                         // report an error at each declaration.
                         const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
-                        const name = !(type.flags & TypeFlags.UniqueESSymbol) && unescapeLeadingUnderscores(memberName) || declarationNameToString(decl.name);
+                        const name = !(type.flags & TypeFlags.UniqueESSymbol) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
                         forEach(declarations, declaration => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
-                        error(decl.name || decl, Diagnostics.Duplicate_property_0, name);
+                        error(declName || decl, Diagnostics.Duplicate_property_0, name);
                         lateSymbol = createSymbol(SymbolFlags.None, memberName, CheckFlags.Late);
                     }
                     lateSymbol.nameType = type;
@@ -7000,6 +7015,20 @@ namespace ts {
                         }
                     }
                 }
+                const assignments = symbol.assignmentDeclarationMembers;
+                if (assignments) {
+                    const decls = arrayFrom(assignments.values());
+                    for (const member of decls) {
+                        const assignmentKind = getAssignmentDeclarationKind(member as BinaryExpression | CallExpression);
+                        const isInstanceMember = assignmentKind === AssignmentDeclarationKind.PrototypeProperty
+                            || assignmentKind === AssignmentDeclarationKind.ThisProperty
+                            || assignmentKind === AssignmentDeclarationKind.ObjectDefinePrototypeProperty
+                            || assignmentKind === AssignmentDeclarationKind.Prototype; // A straight `Prototype` assignment probably can never have a computed name
+                        if (isStatic === !isInstanceMember && hasLateBindableName(member)) {
+                            lateBindMember(symbol, earlySymbols, lateSymbols, member);
+                        }
+                    }
+                }
 
                 links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
             }

src/compiler/transformers/declarations.ts

@@ -1137,7 +1137,7 @@ namespace ts {
                         fakespace.symbol = props[0].parent!;
                         const declarations = mapDefined(props, p => {
                             if (!isPropertyAccessExpression(p.valueDeclaration)) {
-                                return undefined;
+                                return undefined; // TODO: Handle element access expressions that created late bound names (rather than silently omitting them)
                             }
                             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
                             const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, symbolTracker);

src/compiler/types.ts

@@ -805,7 +805,7 @@ namespace ts {
 
     export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
 
-    export type DeclarationName = Identifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | BindingPattern;
+    export type DeclarationName = Identifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern;
 
     export interface Declaration extends Node {
         _declarationBrand: any;
@@ -3746,7 +3746,7 @@ namespace ts {
         Classifiable = Class | Enum | TypeAlias | Interface | TypeParameter | Module | Alias,
 
         /* @internal */
-        LateBindingContainer = Class | Interface | TypeLiteral | ObjectLiteral,
+        LateBindingContainer = Class | Interface | TypeLiteral | ObjectLiteral | Function,
     }
 
     export interface Symbol {
@@ -3766,6 +3766,7 @@ namespace ts {
         /* @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
         /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
         /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
+        /* @internal */ assignmentDeclarationMembers?: Map<Declaration>;
     }
 
     /* @internal */