Creates a class body scoped alias to the class to avoid class name double binding.

Fixes #5386.

Author: rbuckton

src/compiler/checker.ts

@@ -7192,11 +7192,33 @@ namespace ts {
                 markAliasSymbolAsReferenced(symbol);
             }
 
+            const localSymbol = 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
+                && localSymbol
+                && localSymbol.valueDeclaration
+                && localSymbol.valueDeclaration.kind === SyntaxKind.ClassDeclaration
+                && nodeIsDecorated(localSymbol.valueDeclaration)) {
+                let container = getContainingClass(node);
+                while (container !== undefined) {
+                    if (container === localSymbol.valueDeclaration && container.name !== node) {
+                        getNodeLinks(container).flags |= NodeCheckFlags.ClassWithBodyScopedClassBinding;
+                        getNodeLinks(node).flags |= NodeCheckFlags.BodyScopedClassBinding;
+                        break;
+                    }
+
+                    container = getContainingClass(container);
+                }
+            }
+
             checkCollisionWithCapturedSuperVariable(node, node);
             checkCollisionWithCapturedThisVariable(node, node);
             checkNestedBlockScopedBinding(node, symbol);
 
-            return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node);
+            return getNarrowedTypeOfSymbol(localSymbol, node);
         }
 
         function isInsideFunction(node: Node, threshold: Node): boolean {
@@ -7238,7 +7260,7 @@ namespace ts {
 
             if (containedInIterationStatement) {
                 if (usedInFunction) {
-                    // mark iteration statement as containing block-scoped binding captured in some function 
+                    // mark iteration statement as containing block-scoped binding captured in some function
                     getNodeLinks(current).flags |= NodeCheckFlags.LoopWithCapturedBlockScopedBinding;
                 }
                 // set 'declared inside loop' bit on the block-scoped binding
@@ -15734,7 +15756,7 @@ namespace ts {
                             // - binding is not top level - top level bindings never collide with anything
                             // AND
                             //   - binding is not declared in loop, should be renamed to avoid name reuse across siblings
-                            //     let a, b 
+                            //     let a, b
                             //     { let x = 1; a = () => x;  }
                             //     { let x = 100; b = () => x; }
                             //     console.log(a()); // should print '1'

src/compiler/emitter.ts

@@ -2068,8 +2068,10 @@ namespace ts {
         EnumValuesComputed          = 0x00004000,
         LexicalModuleMergesWithClass    = 0x00008000,    // Instantiated lexical module declaration is merged with a previous class declaration.
         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
+        CapturedBlockScopedBinding  = 0x00020000,        // Block-scoped binding that is captured in some function
+        BlockScopedBindingInLoop    = 0x00040000,        // Block-scoped binding with declaration nested inside iteration statement
+        ClassWithBodyScopedClassBinding = 0x00080000,    // Decorated class that contains a binding to itself inside of the class body.
+        BodyScopedClassBinding      = 0x00100000,        // Binding to a decorated class inside of the class's body.
     }
 
     /* @internal */

src/compiler/types.ts

@@ -17,7 +17,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 function decorate(target) { }
-let Decorated = class {
+let Decorated = class Decorated {
 };
 Decorated = __decorate([
     decorate

tests/baselines/reference/decoratedClassFromExternalModule.js

@@ -23,7 +23,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 define(["require", "exports"], function (require, exports) {
     "use strict";
     var decorator;
-    let Foo = class {
+    let Foo = class Foo {
     };
     Foo = __decorate([
         decorator

tests/baselines/reference/decoratedDefaultExportsGetExportedAmd.js

@@ -22,7 +22,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var decorator;
-let Foo = class {
+let Foo = class Foo {
 };
 Foo = __decorate([
     decorator

tests/baselines/reference/decoratedDefaultExportsGetExportedCommonjs.js

@@ -25,7 +25,7 @@ System.register([], function(exports_1) {
     return {
         setters:[],
         execute: function() {
-            let Foo = class {
+            let Foo = class Foo {
             };
             Foo = __decorate([
                 decorator

tests/baselines/reference/decoratedDefaultExportsGetExportedSystem.js

@@ -30,7 +30,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 })(function (require, exports) {
     "use strict";
     var decorator;
-    let Foo = class {
+    let Foo = class Foo {
     };
     Foo = __decorate([
         decorator

tests/baselines/reference/decoratedDefaultExportsGetExportedUmd.js

@@ -0,0 +1,22 @@
+//// [decoratorOnClass1.es6.ts]
+declare function dec<T>(target: T): T;
+
+@dec
+class C {
+}
+
+let c = new C();
+
+//// [decoratorOnClass1.es6.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+let C = class C {
+};
+C = __decorate([
+    dec
+], C);
+let c = new C();

tests/baselines/reference/decoratorOnClass1.es6.js

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass1.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : Symbol(dec, Decl(decoratorOnClass1.es6.ts, 0, 0))
+>T : Symbol(T, Decl(decoratorOnClass1.es6.ts, 0, 21))
+>target : Symbol(target, Decl(decoratorOnClass1.es6.ts, 0, 24))
+>T : Symbol(T, Decl(decoratorOnClass1.es6.ts, 0, 21))
+>T : Symbol(T, Decl(decoratorOnClass1.es6.ts, 0, 21))
+
+@dec
+>dec : Symbol(dec, Decl(decoratorOnClass1.es6.ts, 0, 0))
+
+class C {
+>C : Symbol(C, Decl(decoratorOnClass1.es6.ts, 0, 38))
+}
+
+let c = new C();
+>c : Symbol(c, Decl(decoratorOnClass1.es6.ts, 6, 3))
+>C : Symbol(C, Decl(decoratorOnClass1.es6.ts, 0, 38))
+

tests/baselines/reference/decoratorOnClass1.es6.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass1.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : <T>(target: T) => T
+>T : T
+>target : T
+>T : T
+>T : T
+
+@dec
+>dec : <T>(target: T) => T
+
+class C {
+>C : C
+}
+
+let c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+

tests/baselines/reference/decoratorOnClass1.es6.types

@@ -0,0 +1,22 @@
+//// [decoratorOnClass2.es6.ts]
+declare function dec<T>(target: T): T;
+
+@dec
+export class C {
+}
+
+let c = new C();
+
+//// [decoratorOnClass2.es6.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+export let C = class C {
+};
+C = __decorate([
+    dec
+], C);
+let c = new C();

tests/baselines/reference/decoratorOnClass2.es6.js

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass2.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : Symbol(dec, Decl(decoratorOnClass2.es6.ts, 0, 0))
+>T : Symbol(T, Decl(decoratorOnClass2.es6.ts, 0, 21))
+>target : Symbol(target, Decl(decoratorOnClass2.es6.ts, 0, 24))
+>T : Symbol(T, Decl(decoratorOnClass2.es6.ts, 0, 21))
+>T : Symbol(T, Decl(decoratorOnClass2.es6.ts, 0, 21))
+
+@dec
+>dec : Symbol(dec, Decl(decoratorOnClass2.es6.ts, 0, 0))
+
+export class C {
+>C : Symbol(C, Decl(decoratorOnClass2.es6.ts, 0, 38))
+}
+
+let c = new C();
+>c : Symbol(c, Decl(decoratorOnClass2.es6.ts, 6, 3))
+>C : Symbol(C, Decl(decoratorOnClass2.es6.ts, 0, 38))
+

tests/baselines/reference/decoratorOnClass2.es6.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass2.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : <T>(target: T) => T
+>T : T
+>target : T
+>T : T
+>T : T
+
+@dec
+>dec : <T>(target: T) => T
+
+export class C {
+>C : C
+}
+
+let c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+

tests/baselines/reference/decoratorOnClass2.es6.types

@@ -0,0 +1,23 @@
+//// [decoratorOnClass3.es6.ts]
+declare function dec<T>(target: T): T;
+
+@dec
+export default class C {
+}
+
+let c = new C();
+
+//// [decoratorOnClass3.es6.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+let C = class C {
+};
+C = __decorate([
+    dec
+], C);
+export default C;
+let c = new C();

tests/baselines/reference/decoratorOnClass3.es6.js

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass3.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : Symbol(dec, Decl(decoratorOnClass3.es6.ts, 0, 0))
+>T : Symbol(T, Decl(decoratorOnClass3.es6.ts, 0, 21))
+>target : Symbol(target, Decl(decoratorOnClass3.es6.ts, 0, 24))
+>T : Symbol(T, Decl(decoratorOnClass3.es6.ts, 0, 21))
+>T : Symbol(T, Decl(decoratorOnClass3.es6.ts, 0, 21))
+
+@dec
+>dec : Symbol(dec, Decl(decoratorOnClass3.es6.ts, 0, 0))
+
+export default class C {
+>C : Symbol(C, Decl(decoratorOnClass3.es6.ts, 0, 38))
+}
+
+let c = new C();
+>c : Symbol(c, Decl(decoratorOnClass3.es6.ts, 6, 3))
+>C : Symbol(C, Decl(decoratorOnClass3.es6.ts, 0, 38))
+

tests/baselines/reference/decoratorOnClass3.es6.symbols

@@ -0,0 +1,20 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass3.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : <T>(target: T) => T
+>T : T
+>target : T
+>T : T
+>T : T
+
+@dec
+>dec : <T>(target: T) => T
+
+export default class C {
+>C : C
+}
+
+let c = new C();
+>c : C
+>new C() : C
+>C : typeof C
+

tests/baselines/reference/decoratorOnClass3.es6.types

@@ -0,0 +1,20 @@
+//// [decoratorOnClass4.es6.ts]
+declare function dec<T>(target: T): T;
+
+@dec
+export default class {
+}
+
+//// [decoratorOnClass4.es6.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+let default_1 = class {
+};
+default_1 = __decorate([
+    dec
+], default_1);
+export default default_1;

tests/baselines/reference/decoratorOnClass4.es6.js

@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass4.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : Symbol(dec, Decl(decoratorOnClass4.es6.ts, 0, 0))
+>T : Symbol(T, Decl(decoratorOnClass4.es6.ts, 0, 21))
+>target : Symbol(target, Decl(decoratorOnClass4.es6.ts, 0, 24))
+>T : Symbol(T, Decl(decoratorOnClass4.es6.ts, 0, 21))
+>T : Symbol(T, Decl(decoratorOnClass4.es6.ts, 0, 21))
+
+@dec
+>dec : Symbol(dec, Decl(decoratorOnClass4.es6.ts, 0, 0))
+
+export default class {
+}

tests/baselines/reference/decoratorOnClass4.es6.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/conformance/es6/decorators/class/decoratorOnClass4.es6.ts ===
+declare function dec<T>(target: T): T;
+>dec : <T>(target: T) => T
+>T : T
+>target : T
+>T : T
+>T : T
+
+@dec
+>dec : <T>(target: T) => T
+
+export default class {
+}

tests/baselines/reference/decoratorOnClass4.es6.types

@@ -0,0 +1,27 @@
+//// [decoratorOnClass5.es6.ts]
+declare function dec<T>(target: T): T;
+
+@dec
+class C {
+    static x() { return C.y; }
+    static y = 1;
+}
+
+let c = new C();
+
+//// [decoratorOnClass5.es6.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+let C_1;
+let C = C_1 = class C {
+    static x() { return C_1.y; }
+};
+C.y = 1;
+C = C_1 = __decorate([
+    dec
+], C);
+let c = new C();