[Transforms] Merge master 07/11 into transform

src/compiler/checker.ts

@@ -8354,22 +8354,41 @@ namespace ts {
 
             const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
 
-            // Due to the emit for class decorators, any reference to the class from inside of the class body
-            // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
-            // behavior of class names in ES6.
-            if (languageVersion === ScriptTarget.ES6
-                && localOrExportSymbol.flags & SymbolFlags.Class
-                && localOrExportSymbol.valueDeclaration.kind === SyntaxKind.ClassDeclaration
-                && nodeIsDecorated(localOrExportSymbol.valueDeclaration)) {
-                let container = getContainingClass(node);
-                while (container !== undefined) {
-                    if (container === localOrExportSymbol.valueDeclaration && container.name !== node) {
-                        getNodeLinks(container).flags |= NodeCheckFlags.DecoratedClassWithSelfReference;
-                        getNodeLinks(node).flags |= NodeCheckFlags.SelfReferenceInDecoratedClass;
-                        break;
+            if (localOrExportSymbol.flags & SymbolFlags.Class) {
+                const declaration = localOrExportSymbol.valueDeclaration;
+                // Due to the emit for class decorators, any reference to the class from inside of the class body
+                // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
+                // behavior of class names in ES6.
+                if (languageVersion === ScriptTarget.ES6
+                    && declaration.kind === SyntaxKind.ClassDeclaration
+                    && nodeIsDecorated(declaration)) {
+                    let container = getContainingClass(node);
+                    while (container !== undefined) {
+                        if (container === declaration && container.name !== node) {
+                            getNodeLinks(declaration).flags |= NodeCheckFlags.ClassWithConstructorReference;
+                            getNodeLinks(node).flags |= NodeCheckFlags.ConstructorReferenceInClass;
+                            break;
+                        }
+
+                        container = getContainingClass(container);
                     }
+                }
+                else if (declaration.kind === SyntaxKind.ClassExpression) {
+                    // When we emit a class expression with static members that contain a reference
+                    // to the constructor in the initializer, we will need to substitute that
+                    // binding with an alias as the class name is not in scope.
+                    let container = getThisContainer(node, /*includeArrowFunctions*/ false);
+                    while (container !== undefined) {
+                        if (container.parent === declaration) {
+                            if (container.kind === SyntaxKind.PropertyDeclaration && hasModifier(container, ModifierFlags.Static)) {
+                                getNodeLinks(declaration).flags |= NodeCheckFlags.ClassWithConstructorReference;
+                                getNodeLinks(node).flags |= NodeCheckFlags.ConstructorReferenceInClass;
+                            }
+                            break;
+                        }
 
-                    container = getContainingClass(container);
+                        container = getThisContainer(container, /*includeArrowFunctions*/ false);
+                    }
                 }
             }
 

src/compiler/transformers/ts.ts

@@ -13,7 +13,7 @@ namespace ts {
 
     const enum TypeScriptSubstitutionFlags {
         /** Enables substitutions for decorated classes. */
-        DecoratedClasses = 1 << 0,
+        ClassAliases = 1 << 0,
         /** Enables substitutions for namespace exports. */
         NamespaceExports = 1 << 1,
         /** Enables substitutions for async methods with `super` calls. */
@@ -63,13 +63,7 @@ namespace ts {
          * A map that keeps track of aliases created for classes with decorators to avoid issues
          * with the double-binding behavior of classes.
          */
-        let decoratedClassAliases: Map<Identifier>;
-
-        /**
-         * A map that keeps track of currently active aliases defined in `decoratedClassAliases`
-         * when just-in-time substitution occurs while printing an expression identifier.
-         */
-        let currentDecoratedClassAliases: Map<Identifier>;
+        let classAliases: Map<Identifier>;
 
         /**
          * Keeps track of whether  we are within any containing namespaces when performing
@@ -495,7 +489,7 @@ namespace ts {
             const staticProperties = getInitializedProperties(node, /*isStatic*/ true);
             const hasExtendsClause = getClassExtendsHeritageClauseElement(node) !== undefined;
             const isDecoratedClass = shouldEmitDecorateCallForClass(node);
-            let decoratedClassAlias: Identifier;
+            let classAlias: Identifier;
 
             // emit name if
             // - node has a name
@@ -529,7 +523,7 @@ namespace ts {
                 statements.push(classDeclaration);
             }
             else {
-                decoratedClassAlias = addClassDeclarationHeadWithDecorators(statements, node, name, hasExtendsClause);
+                classAlias = addClassDeclarationHeadWithDecorators(statements, node, name, hasExtendsClause);
             }
 
             // Emit static property assignment. Because classDeclaration is lexically evaluated,
@@ -544,7 +538,7 @@ namespace ts {
             // Write any decorators of the node.
             addClassElementDecorationStatements(statements, node, /*isStatic*/ false);
             addClassElementDecorationStatements(statements, node, /*isStatic*/ true);
-            addConstructorDecorationStatement(statements, node, decoratedClassAlias);
+            addConstructorDecorationStatement(statements, node, classAlias);
 
             // If the class is exported as part of a TypeScript namespace, emit the namespace export.
             // Otherwise, if the class was exported at the top level and was decorated, emit an export
@@ -679,11 +673,11 @@ namespace ts {
             }
 
             // Record an alias to avoid class double-binding.
-            let decoratedClassAlias: Identifier;
-            if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.DecoratedClassWithSelfReference) {
-                enableSubstitutionForDecoratedClasses();
-                decoratedClassAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
-                decoratedClassAliases[getOriginalNodeId(node)] = decoratedClassAlias;
+            let classAlias: Identifier;
+            if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
+                enableSubstitutionForClassAliases();
+                classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
+                classAliases[getOriginalNodeId(node)] = classAlias;
             }
 
             const declaredName = getDeclarationName(node, /*allowComments*/ true);
@@ -696,7 +690,7 @@ namespace ts {
                         /*modifiers*/ undefined,
                         createLetDeclarationList([
                             createVariableDeclaration(
-                                decoratedClassAlias || declaredName,
+                                classAlias || declaredName,
                                 /*type*/ undefined,
                                 classExpression
                             )
@@ -707,7 +701,7 @@ namespace ts {
                 )
             );
 
-            if (decoratedClassAlias) {
+            if (classAlias) {
                 // We emit the class alias as a `let` declaration here so that it has the same
                 // TDZ as the class.
 
@@ -720,7 +714,7 @@ namespace ts {
                                 createVariableDeclaration(
                                     declaredName,
                                     /*type*/ undefined,
-                                    decoratedClassAlias
+                                    classAlias
                                 )
                             ]),
                             /*location*/ location
@@ -730,7 +724,7 @@ namespace ts {
                 );
             }
 
-            return decoratedClassAlias;
+            return classAlias;
         }
 
         /**
@@ -760,6 +754,11 @@ namespace ts {
             if (staticProperties.length > 0) {
                 const expressions: Expression[] = [];
                 const temp = createTempVariable(hoistVariableDeclaration);
+                if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
+                    // record an alias as the class name is not in scope for statics.
+                    enableSubstitutionForClassAliases();
+                    classAliases[getOriginalNodeId(node)] = temp;
+                }
 
                 // To preserve the behavior of the old emitter, we explicitly indent
                 // the body of a class with static initializers.
@@ -3079,18 +3078,16 @@ namespace ts {
             }
         }
 
-        function enableSubstitutionForDecoratedClasses() {
-            if ((enabledSubstitutions & TypeScriptSubstitutionFlags.DecoratedClasses) === 0) {
-                enabledSubstitutions |= TypeScriptSubstitutionFlags.DecoratedClasses;
+        function enableSubstitutionForClassAliases() {
+            if ((enabledSubstitutions & TypeScriptSubstitutionFlags.ClassAliases) === 0) {
+                enabledSubstitutions |= TypeScriptSubstitutionFlags.ClassAliases;
 
                 // We need to enable substitutions for identifiers. This allows us to
                 // substitute class names inside of a class declaration.
                 context.enableSubstitution(SyntaxKind.Identifier);
-                context.enableEmitNotification(SyntaxKind.Identifier);
 
                 // Keep track of class aliases.
-                decoratedClassAliases = {};
-                currentDecoratedClassAliases = {};
+                classAliases = {};
             }
         }
 
@@ -3108,10 +3105,6 @@ namespace ts {
             }
         }
 
-        function isClassWithDecorators(node: Node): node is ClassDeclaration {
-            return node.kind === SyntaxKind.ClassDeclaration && node.decorators !== undefined;
-        }
-
         function isSuperContainer(node: Node): node is SuperContainer {
             const kind = node.kind;
             return kind === SyntaxKind.ClassDeclaration
@@ -3138,21 +3131,6 @@ namespace ts {
         function onEmitNode(node: Node, emit: (node: Node) => void): void {
             const savedApplicableSubstitutions = applicableSubstitutions;
             const savedCurrentSuperContainer = currentSuperContainer;
-
-            // If we need support substitutions for aliases for decorated classes,
-            // we should enable it here.
-            if (enabledSubstitutions & TypeScriptSubstitutionFlags.DecoratedClasses) {
-                if (isClassWithDecorators(node)) {
-                    currentDecoratedClassAliases[getOriginalNodeId(node)] = decoratedClassAliases[getOriginalNodeId(node)];
-                }
-                else if (node.kind === SyntaxKind.Identifier) {
-                    const declaration = resolver.getReferencedValueDeclaration(<Identifier>node);
-                    if (declaration && isClassWithDecorators(declaration)) {
-                        currentDecoratedClassAliases[getOriginalNodeId(declaration)] = decoratedClassAliases[getOriginalNodeId(declaration)];
-                    }
-                }
-            }
-
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & TypeScriptSubstitutionFlags.AsyncMethodsWithSuper && isSuperContainer(node)) {
@@ -3162,16 +3140,13 @@ namespace ts {
             if (enabledSubstitutions & TypeScriptSubstitutionFlags.NamespaceExports && isTransformedModuleDeclaration(node)) {
                 applicableSubstitutions |= TypeScriptSubstitutionFlags.NamespaceExports;
             }
+
             if (enabledSubstitutions & TypeScriptSubstitutionFlags.NonQualifiedEnumMembers && isTransformedEnumDeclaration(node)) {
                 applicableSubstitutions |= TypeScriptSubstitutionFlags.NonQualifiedEnumMembers;
             }
 
             previousOnEmitNode(node, emit);
 
-            if (enabledSubstitutions & TypeScriptSubstitutionFlags.DecoratedClasses && isClassWithDecorators(node)) {
-                currentDecoratedClassAliases[getOriginalNodeId(node)] = undefined;
-            }
-
             applicableSubstitutions = savedApplicableSubstitutions;
             currentSuperContainer = savedCurrentSuperContainer;
         }
@@ -3239,14 +3214,14 @@ namespace ts {
         }
 
         function trySubstituteDecoratedClassName(node: Identifier): Expression {
-            if (enabledSubstitutions & TypeScriptSubstitutionFlags.DecoratedClasses) {
-                if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.SelfReferenceInDecoratedClass) {
+            if (enabledSubstitutions & TypeScriptSubstitutionFlags.ClassAliases) {
+                if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ConstructorReferenceInClass) {
                     // Due to the emit for class decorators, any reference to the class from inside of the class body
                     // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind
                     // behavior of class names in ES6.
                     const declaration = resolver.getReferencedValueDeclaration(node);
                     if (declaration) {
-                        const classAlias = currentDecoratedClassAliases[getOriginalNodeId(declaration)];
+                        const classAlias = classAliases[declaration.id];
                         if (classAlias) {
                             const clone = getSynthesizedClone(classAlias);
                             setSourceMapRange(clone, node);

src/compiler/types.ts

@@ -2261,8 +2261,8 @@ namespace ts {
         LoopWithCapturedBlockScopedBinding  = 0x00010000, // Loop that contains block scoped variable captured in closure
         CapturedBlockScopedBinding          = 0x00020000, // Block-scoped binding that is captured in some function
         BlockScopedBindingInLoop            = 0x00040000, // Block-scoped binding with declaration nested inside iteration statement
-        DecoratedClassWithSelfReference     = 0x00080000, // Decorated class that contains a binding to itself inside of the class body.
-        SelfReferenceInDecoratedClass       = 0x00100000, // Binding to a decorated class inside of the class's body.
+        ClassWithConstructorReference       = 0x00080000, // Class that contains a binding to its constructor inside of the class body.
+        ConstructorReferenceInClass         = 0x00100000, // Binding to a class constructor inside of the class's body.
         NeedsLoopOutParameter               = 0x00200000, // Block scoped binding whose value should be explicitly copied outside of the converted loop
     }
 

tests/baselines/reference/classExpressionWithStaticPropertiesES61.js

@@ -6,10 +6,10 @@ var v = class C {
 };
 
 //// [classExpressionWithStaticPropertiesES61.js]
-var v = (C_1 = class C {
+var v = (_a = class C {
     },
-    C_1.a = 1,
-    C_1.b = 2,
-    C_1.c = C_1.a + 3,
-    C_1);
-var C_1;
+    _a.a = 1,
+    _a.b = 2,
+    _a.c = _a.a + 3,
+    _a);
+var _a;

tests/baselines/reference/classExpressionWithStaticPropertiesES62.js

@@ -9,12 +9,12 @@ var v = class C {
  };
 
 //// [classExpressionWithStaticPropertiesES62.js]
-var v = (C_1 = class C {
+var v = (_a = class C {
     },
-    C_1.a = 1,
-    C_1.c = {
+    _a.a = 1,
+    _a.c = {
         x: "hi"
     },
-    C_1.d = C_1.c.x + " world",
-    C_1);
-var C_1;
+    _a.d = _a.c.x + " world",
+    _a);
+var _a;

tests/baselines/reference/classExpressionWithStaticPropertiesES63.js

@@ -13,11 +13,11 @@ arr.forEach(C => console.log(C.y()));
 //// [classExpressionWithStaticPropertiesES63.js]
 const arr = [];
 for (let i = 0; i < 3; i++) {
-    arr.push((C_1 = class C {
+    arr.push((_a = class C {
         },
-        C_1.x = i,
-        C_1.y = () => C_1.x * 2,
-        C_1));
+        _a.x = i,
+        _a.y = () => _a.x * 2,
+        _a));
 }
 arr.forEach(C => console.log(C.y()));
-var C_1;
+var _a;