Transform decorators that reference private names into a 'static {}' …

…block
microsoft · Jul 29, 2022 · 0c04351 · 0c04351
1 parent 8d0c72d
commit 0c04351
Show file tree

Hide file tree

Showing 13 changed files with 337 additions and 26 deletions.
diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -2331,7 +2331,7 @@ namespace ts {
                 propagateChildFlags(node.expression) |
                 (isIdentifier(node.name) ?
                     propagateIdentifierNameFlags(node.name) :
-                    propagateChildFlags(node.name));
+                    propagateChildFlags(node.name) | TransformFlags.ContainsPrivateIdentifierInExpression);
             if (isSuperKeyword(expression)) {
                 // super method calls require a lexical 'this'
                 // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators
@@ -2366,7 +2366,7 @@ namespace ts {
                 propagateChildFlags(node.questionDotToken) |
                 (isIdentifier(node.name) ?
                     propagateIdentifierNameFlags(node.name) :
-                    propagateChildFlags(node.name));
+                    propagateChildFlags(node.name) | TransformFlags.ContainsPrivateIdentifierInExpression);
             return node;
         }
 
@@ -2851,6 +2851,9 @@ namespace ts {
             else if (isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
                 node.transformFlags |= TransformFlags.ContainsES2021;
             }
+            if (operatorKind === SyntaxKind.InKeyword && isPrivateIdentifier(node.left)) {
+                node.transformFlags |= TransformFlags.ContainsPrivateIdentifierInExpression;
+            }
             return node;
         }
 

diff --git a/src/compiler/transformers/legacyDecorators.ts b/src/compiler/transformers/legacyDecorators.ts
@@ -68,52 +68,88 @@ namespace ts {
         function visitClassDeclaration(node: ClassDeclaration): VisitResult<Statement> {
             if (!(classOrConstructorParameterIsDecorated(node) || childIsDecorated(node))) return visitEachChild(node, visitor, context);
 
-            const classStatement = hasDecorators(node) ?
-                createClassDeclarationHeadWithDecorators(node, node.name) :
-                createClassDeclarationHeadWithoutDecorators(node, node.name);
-
-            const statements: Statement[] = [classStatement];
-
-            // Write any decorators of the node.
-            addClassElementDecorationStatements(statements, node, /*isStatic*/ false);
-            addClassElementDecorationStatements(statements, node, /*isStatic*/ true);
-            addConstructorDecorationStatement(statements, node);
+            const statements = hasDecorators(node) ?
+                transformClassDeclarationWithClassDecorators(node, node.name) :
+                transformClassDeclarationWithoutClassDecorators(node, node.name);
 
             if (statements.length > 1) {
                 // Add a DeclarationMarker as a marker for the end of the declaration
                 statements.push(factory.createEndOfDeclarationMarker(node));
-                setEmitFlags(classStatement, getEmitFlags(classStatement) | EmitFlags.HasEndOfDeclarationMarker);
+                setEmitFlags(statements[0], getEmitFlags(statements[0]) | EmitFlags.HasEndOfDeclarationMarker);
             }
 
             return singleOrMany(statements);
         }
 
+        function decoratorContainsPrivateIdentifierInExpression(decorator: Decorator) {
+            return !!(decorator.transformFlags & TransformFlags.ContainsPrivateIdentifierInExpression);
+        }
+
+        function parameterDecoratorsContainPrivateIdentifierInExpression(parameterDecorators: readonly Decorator[] | undefined) {
+            return some(parameterDecorators, decoratorContainsPrivateIdentifierInExpression);
+        }
+
+        function hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node: ClassDeclaration) {
+            for (const member of node.members) {
+                if (!canHaveDecorators(member)) continue;
+                const allDecorators = getAllDecoratorsOfClassElement(member, node);
+                if (some(allDecorators?.decorators, decoratorContainsPrivateIdentifierInExpression)) return true;
+                if (some(allDecorators?.parameters, parameterDecoratorsContainPrivateIdentifierInExpression)) return true;
+            }
+            return false;
+        }
+
+        function transformDecoratorsOfClassElements(node: ClassDeclaration, members: NodeArray<ClassElement>) {
+            let decorationStatements: Statement[] | undefined = [];
+            addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ false);
+            addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ true);
+            if (hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node)) {
+                members = setTextRange(factory.createNodeArray([
+                    ...members,
+                    factory.createClassStaticBlockDeclaration(
+                        factory.createBlock(decorationStatements, /*multiLine*/ true)
+                    )
+                ]), members);
+                decorationStatements = undefined;
+            }
+            return { decorationStatements, members };
+        }
+
         /**
          * Transforms a non-decorated class declaration.
          *
          * @param node A ClassDeclaration node.
          * @param name The name of the class.
          */
-        function createClassDeclarationHeadWithoutDecorators(node: ClassDeclaration, name: Identifier | undefined) {
+        function transformClassDeclarationWithoutClassDecorators(node: ClassDeclaration, name: Identifier | undefined) {
             //  ${modifiers} class ${name} ${heritageClauses} {
             //      ${members}
             //  }
 
-            return factory.updateClassDeclaration(
+            const modifiers = visitNodes(node.modifiers, modifierVisitor, isModifier);
+            const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);
+            let members = visitNodes(node.members, visitor, isClassElement);
+
+            let decorationStatements: Statement[] | undefined = [];
+            ({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
+
+            const updated = factory.updateClassDeclaration(
                 node,
-                visitNodes(node.modifiers, modifierVisitor, isModifier),
+                modifiers,
                 name,
                 /*typeParameters*/ undefined,
-                visitNodes(node.heritageClauses, visitor, isHeritageClause),
-                visitNodes(node.members, visitor, isClassElement)
+                heritageClauses,
+                members
             );
+
+            return addRange([updated], decorationStatements);
         }
 
         /**
          * Transforms a decorated class declaration and appends the resulting statements. If
          * the class requires an alias to avoid issues with double-binding, the alias is returned.
          */
-        function createClassDeclarationHeadWithDecorators(node: ClassDeclaration, name: Identifier | undefined) {
+        function transformClassDeclarationWithClassDecorators(node: ClassDeclaration, name: Identifier | undefined) {
             // When we emit an ES6 class that has a class decorator, we must tailor the
             // emit to certain specific cases.
             //
@@ -213,8 +249,18 @@ namespace ts {
             //      ${members}
             //  }
             const heritageClauses = visitNodes(node.heritageClauses, visitor, isHeritageClause);
-            const members = visitNodes(node.members, visitor, isClassElement);
-            const classExpression = factory.createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members);
+            let members = visitNodes(node.members, visitor, isClassElement);
+
+            let decorationStatements: Statement[] | undefined = [];
+            ({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
+
+            const classExpression = factory.createClassExpression(
+                /*modifiers*/ undefined,
+                name,
+                /*typeParameters*/ undefined,
+                heritageClauses,
+                members);
+
             setOriginalNode(classExpression, node);
             setTextRange(classExpression, location);
 
@@ -234,7 +280,11 @@ namespace ts {
             setOriginalNode(statement, node);
             setTextRange(statement, location);
             setCommentRange(statement, node);
-            return statement;
+
+            const statements: Statement[] = [statement];
+            addRange(statements, decorationStatements);
+            addConstructorDecorationStatement(statements, node);
+            return statements;
         }
 
         function visitClassExpression(node: ClassExpression) {

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -7041,10 +7041,9 @@ namespace ts {
         ContainsPossibleTopLevelAwait = 1 << 26,
         ContainsLexicalSuper = 1 << 27,
         ContainsUpdateExpressionForIdentifier = 1 << 28,
-        // Please leave this as 1 << 29.
-        // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
-        // It is a good reminder of how much room we have left
-        HasComputedFlags = 1 << 29, // Transform flags have been computed.
+        ContainsPrivateIdentifierInExpression = 1 << 29,
+
+        HasComputedFlags = 1 << 31, // Transform flags have been computed.
 
         // Assertions
         // - Bitmasks that are used to assert facts about the syntax of a node and its subtree.

diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).js b/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).js
@@ -0,0 +1,43 @@
+//// [decoratorOnClassMethod19.ts]
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+
+class Foo {
+    #bar
+
+    @decorator((x: Foo) => x.#bar)
+    baz() {}
+}
+
+
+//// [decoratorOnClassMethod19.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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Foo_bar;
+class Foo {
+    constructor() {
+        _Foo_bar.set(this, void 0);
+    }
+    baz() { }
+}
+_Foo_bar = new WeakMap();
+(() => {
+    __decorate([
+        decorator((x) => __classPrivateFieldGet(x, _Foo_bar, "f")),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], Foo.prototype, "baz", null);
+})();
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).symbols b/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).symbols
@@ -0,0 +1,22 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod19.ts ===
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+>decorator : Symbol(decorator, Decl(decoratorOnClassMethod19.ts, 1, 11))
+
+class Foo {
+>Foo : Symbol(Foo, Decl(decoratorOnClassMethod19.ts, 1, 27))
+
+    #bar
+>#bar : Symbol(Foo.#bar, Decl(decoratorOnClassMethod19.ts, 3, 11))
+
+    @decorator((x: Foo) => x.#bar)
+>decorator : Symbol(decorator, Decl(decoratorOnClassMethod19.ts, 1, 11))
+>x : Symbol(x, Decl(decoratorOnClassMethod19.ts, 6, 16))
+>Foo : Symbol(Foo, Decl(decoratorOnClassMethod19.ts, 1, 27))
+>x.#bar : Symbol(Foo.#bar, Decl(decoratorOnClassMethod19.ts, 3, 11))
+>x : Symbol(x, Decl(decoratorOnClassMethod19.ts, 6, 16))
+
+    baz() {}
+>baz : Symbol(Foo.baz, Decl(decoratorOnClassMethod19.ts, 4, 8))
+}
+
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).types b/tests/baselines/reference/decoratorOnClassMethod19(target=es2015).types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod19.ts ===
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+>decorator : any
+
+class Foo {
+>Foo : Foo
+
+    #bar
+>#bar : any
+
+    @decorator((x: Foo) => x.#bar)
+>decorator((x: Foo) => x.#bar) : any
+>decorator : any
+>(x: Foo) => x.#bar : (x: Foo) => any
+>x : Foo
+>x.#bar : any
+>x : Foo
+
+    baz() {}
+>baz : () => void
+}
+
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).js b/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).js
@@ -0,0 +1,34 @@
+//// [decoratorOnClassMethod19.ts]
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+
+class Foo {
+    #bar
+
+    @decorator((x: Foo) => x.#bar)
+    baz() {}
+}
+
+
+//// [decoratorOnClassMethod19.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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+class Foo {
+    #bar;
+    baz() { }
+    static {
+        __decorate([
+            decorator((x) => x.#bar),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Foo.prototype, "baz", null);
+    }
+}
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).symbols b/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).symbols
@@ -0,0 +1,22 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod19.ts ===
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+>decorator : Symbol(decorator, Decl(decoratorOnClassMethod19.ts, 1, 11))
+
+class Foo {
+>Foo : Symbol(Foo, Decl(decoratorOnClassMethod19.ts, 1, 27))
+
+    #bar
+>#bar : Symbol(Foo.#bar, Decl(decoratorOnClassMethod19.ts, 3, 11))
+
+    @decorator((x: Foo) => x.#bar)
+>decorator : Symbol(decorator, Decl(decoratorOnClassMethod19.ts, 1, 11))
+>x : Symbol(x, Decl(decoratorOnClassMethod19.ts, 6, 16))
+>Foo : Symbol(Foo, Decl(decoratorOnClassMethod19.ts, 1, 27))
+>x.#bar : Symbol(Foo.#bar, Decl(decoratorOnClassMethod19.ts, 3, 11))
+>x : Symbol(x, Decl(decoratorOnClassMethod19.ts, 6, 16))
+
+    baz() {}
+>baz : Symbol(Foo.baz, Decl(decoratorOnClassMethod19.ts, 4, 8))
+}
+
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).types b/tests/baselines/reference/decoratorOnClassMethod19(target=es2022).types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/decorators/class/method/decoratorOnClassMethod19.ts ===
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+>decorator : any
+
+class Foo {
+>Foo : Foo
+
+    #bar
+>#bar : any
+
+    @decorator((x: Foo) => x.#bar)
+>decorator((x: Foo) => x.#bar) : any
+>decorator : any
+>(x: Foo) => x.#bar : (x: Foo) => any
+>x : Foo
+>x.#bar : any
+>x : Foo
+
+    baz() {}
+>baz : () => void
+}
+
diff --git a/tests/baselines/reference/decoratorOnClassMethod19(target=esnext).js b/tests/baselines/reference/decoratorOnClassMethod19(target=esnext).js
@@ -0,0 +1,34 @@
+//// [decoratorOnClassMethod19.ts]
+// https://github.com/microsoft/TypeScript/issues/48515
+declare var decorator: any;
+
+class Foo {
+    #bar
+
+    @decorator((x: Foo) => x.#bar)
+    baz() {}
+}
+
+
+//// [decoratorOnClassMethod19.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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+class Foo {
+    #bar;
+    baz() { }
+    static {
+        __decorate([
+            decorator((x) => x.#bar),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Foo.prototype, "baz", null);
+    }
+}