Move legacy decorators into separate transform

Author: rbuckton

src/compiler/factory/nodeFactory.ts

@@ -1252,7 +1252,8 @@ namespace ts {
             node.transformFlags |=
                 propagateChildFlags(node.expression) |
                 TransformFlags.ContainsTypeScript |
-                TransformFlags.ContainsTypeScriptClassSyntax;
+                TransformFlags.ContainsTypeScriptClassSyntax |
+                TransformFlags.ContainsDecorators;
             return node;
         }
 

src/compiler/factory/utilities.ts

@@ -1215,4 +1215,16 @@ namespace ts {
             return resultHolder.value;
         }
     }
+
+    /**
+     * If `nodes` is not undefined, creates an empty `NodeArray` that preserves the `pos` and `end` of `nodes`.
+     * @internal
+     */
+    export function elideNodes<T extends Node>(factory: NodeFactory, nodes: NodeArray<T>): NodeArray<T>;
+    export function elideNodes<T extends Node>(factory: NodeFactory, nodes: NodeArray<T> | undefined): NodeArray<T> | undefined;
+    export function elideNodes<T extends Node>(factory: NodeFactory, nodes: NodeArray<T> | undefined): NodeArray<T> | undefined {
+        if (nodes === undefined) return undefined;
+        if (nodes.length === 0) return nodes;
+        return setTextRange(factory.createNodeArray([], nodes.hasTrailingComma), nodes);
+    }
 }

src/compiler/transformer.ts

@@ -48,6 +48,7 @@ namespace ts {
         addRange(transformers, customTransformers && map(customTransformers.before, wrapScriptTransformerFactory));
 
         transformers.push(transformTypeScript);
+        transformers.push(transformLegacyDecorators);
         transformers.push(transformClassFields);
 
         if (getJSXTransformEnabled(compilerOptions)) {

src/compiler/transformers/legacyDecorators.ts

@@ -384,4 +384,140 @@ namespace ts {
     export function isNonStaticMethodOrAccessorWithPrivateName(member: ClassElement): member is PrivateIdentifierMethodDeclaration | PrivateIdentifierAccessorDeclaration {
         return !isStatic(member) && isMethodOrAccessor(member) && isPrivateIdentifier(member.name);
     }
+
+    /**
+     * Gets an array of arrays of decorators for the parameters of a function-like node.
+     * The offset into the result array should correspond to the offset of the parameter.
+     *
+     * @param node The function-like node.
+     */
+    function getDecoratorsOfParameters(node: FunctionLikeDeclaration | undefined) {
+        let decorators: (readonly Decorator[] | undefined)[] | undefined;
+        if (node) {
+            const parameters = node.parameters;
+            const firstParameterIsThis = parameters.length > 0 && parameterIsThisKeyword(parameters[0]);
+            const firstParameterOffset = firstParameterIsThis ? 1 : 0;
+            const numParameters = firstParameterIsThis ? parameters.length - 1 : parameters.length;
+            for (let i = 0; i < numParameters; i++) {
+                const parameter = parameters[i + firstParameterOffset];
+                if (decorators || parameter.decorators) {
+                    if (!decorators) {
+                        decorators = new Array(numParameters);
+                    }
+
+                    decorators[i] = parameter.decorators;
+                }
+            }
+        }
+
+        return decorators;
+    }
+
+    /**
+     * Gets an AllDecorators object containing the decorators for the class and the decorators for the
+     * parameters of the constructor of the class.
+     *
+     * @param node The class node.
+     */
+    export function getAllDecoratorsOfClass(node: ClassLikeDeclaration): AllDecorators | undefined {
+        const decorators = node.decorators;
+        const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
+        if (!decorators && !parameters) {
+            return undefined;
+        }
+
+        return {
+            decorators,
+            parameters
+        };
+    }
+
+    /**
+     * Gets an AllDecorators object containing the decorators for the member and its parameters.
+     *
+     * @param parent The class node that contains the member.
+     * @param member The class member.
+     */
+    export function getAllDecoratorsOfClassElement(member: ClassElement, parent: ClassLikeDeclaration): AllDecorators | undefined {
+        switch (member.kind) {
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+                return getAllDecoratorsOfAccessors(member as AccessorDeclaration, parent);
+
+            case SyntaxKind.MethodDeclaration:
+                return getAllDecoratorsOfMethod(member as MethodDeclaration);
+
+            case SyntaxKind.PropertyDeclaration:
+                return getAllDecoratorsOfProperty(member as PropertyDeclaration);
+
+            default:
+                return undefined;
+        }
+    }
+
+    /**
+     * Gets an AllDecorators object containing the decorators for the accessor and its parameters.
+     *
+     * @param parent The class node that contains the accessor.
+     * @param accessor The class accessor member.
+     */
+    function getAllDecoratorsOfAccessors(accessor: AccessorDeclaration, parent: ClassExpression | ClassDeclaration): AllDecorators | undefined {
+        if (!accessor.body) {
+            return undefined;
+        }
+
+        const { firstAccessor, secondAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(parent.members, accessor);
+        const firstAccessorWithDecorators = firstAccessor.decorators ? firstAccessor : secondAccessor && secondAccessor.decorators ? secondAccessor : undefined;
+        if (!firstAccessorWithDecorators || accessor !== firstAccessorWithDecorators) {
+            return undefined;
+        }
+
+        const decorators = firstAccessorWithDecorators.decorators;
+        const parameters = getDecoratorsOfParameters(setAccessor);
+        if (!decorators && !parameters) {
+            return undefined;
+        }
+
+        return {
+            decorators,
+            parameters,
+            getDecorators: getAccessor?.decorators,
+            setDecorators: setAccessor?.decorators
+        };
+    }
+
+    /**
+     * Gets an AllDecorators object containing the decorators for the method and its parameters.
+     *
+     * @param method The class method member.
+     */
+    function getAllDecoratorsOfMethod(method: MethodDeclaration): AllDecorators | undefined {
+        if (!method.body) {
+            return undefined;
+        }
+
+        const decorators = method.decorators;
+        const parameters = getDecoratorsOfParameters(method);
+        if (!decorators && !parameters) {
+            return undefined;
+        }
+
+        return { decorators, parameters };
+    }
+
+    /**
+     * Gets an AllDecorators object containing the decorators for the property.
+     *
+     * @param property The class property member.
+     */
+    function getAllDecoratorsOfProperty(property: PropertyDeclaration): AllDecorators | undefined {
+        const decorators = property.decorators;
+        if (!decorators) {
+            return undefined;
+
+        }
+
+        return { decorators };
+    }
+
 }

src/compiler/transformers/ts.ts

@@ -49,6 +49,8 @@
         "transformers/taggedTemplate.ts",
         "transformers/ts.ts",
         "transformers/classFields.ts",
+        "transformers/typeSerializer.ts",
+        "transformers/legacyDecorators.ts",
         "transformers/es2017.ts",
         "transformers/es2018.ts",
         "transformers/es2019.ts",

src/compiler/transformers/typeSerializer.ts

@@ -4736,6 +4736,14 @@ namespace ts {
         setAccessor: SetAccessorDeclaration | undefined;
     }
 
+    /* @internal */
+    export interface AllDecorators {
+        decorators: NodeArray<Decorator> | undefined;
+        parameters?: readonly (readonly Decorator[] | undefined)[];
+        getDecorators?: NodeArray<Decorator> | undefined;
+        setDecorators?: NodeArray<Decorator> | undefined;
+    }
+
     /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator metadata */
     /* @internal */
     export enum TypeReferenceSerializationKind {
@@ -6812,21 +6820,22 @@ namespace ts {
 
         // Markers
         // - Flags used to indicate that a subtree contains a specific transformation.
-        ContainsTypeScriptClassSyntax = 1 << 12, // Decorators, Property Initializers, Parameter Property Initializers
-        ContainsLexicalThis = 1 << 13,
-        ContainsRestOrSpread = 1 << 14,
-        ContainsObjectRestOrSpread = 1 << 15,
-        ContainsComputedPropertyName = 1 << 16,
-        ContainsBlockScopedBinding = 1 << 17,
-        ContainsBindingPattern = 1 << 18,
-        ContainsYield = 1 << 19,
-        ContainsAwait = 1 << 20,
-        ContainsHoistedDeclarationOrCompletion = 1 << 21,
-        ContainsDynamicImport = 1 << 22,
-        ContainsClassFields = 1 << 23,
-        ContainsPossibleTopLevelAwait = 1 << 24,
-        ContainsLexicalSuper = 1 << 25,
-        ContainsUpdateExpressionForIdentifier = 1 << 26,
+        ContainsTypeScriptClassSyntax = 1 << 13, // Property Initializers, Parameter Property Initializers
+        ContainsLexicalThis = 1 << 14,
+        ContainsRestOrSpread = 1 << 15,
+        ContainsObjectRestOrSpread = 1 << 16,
+        ContainsComputedPropertyName = 1 << 17,
+        ContainsBlockScopedBinding = 1 << 18,
+        ContainsBindingPattern = 1 << 19,
+        ContainsYield = 1 << 20,
+        ContainsAwait = 1 << 21,
+        ContainsHoistedDeclarationOrCompletion = 1 << 22,
+        ContainsDynamicImport = 1 << 23,
+        ContainsClassFields = 1 << 24,
+        ContainsDecorators = 1 << 25,
+        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

src/compiler/transformers/utilities.ts

@@ -3018,6 +3018,11 @@ namespace ts {
         return [child, node];
     }
 
+    export function skipTypeParentheses(node: TypeNode): TypeNode {
+        while (isParenthesizedTypeNode(node)) node = node.type;
+        return node;
+    }
+
     export function skipParentheses(node: Expression, excludeJSDocTypeAssertions?: boolean): Expression;
     export function skipParentheses(node: Node, excludeJSDocTypeAssertions?: boolean): Node;
     export function skipParentheses(node: Node, excludeJSDocTypeAssertions?: boolean): Node {
@@ -5391,7 +5396,7 @@ namespace ts {
      * Moves the start position of a range past any decorators.
      */
     export function moveRangePastDecorators(node: Node): TextRange {
-        return node.decorators && node.decorators.length > 0
+        return node.decorators && !positionIsSynthesized(node.decorators.end)
             ? moveRangePos(node, node.decorators.end)
             : node;
     }
@@ -5400,7 +5405,7 @@ namespace ts {
      * Moves the start position of a range past any decorators or modifiers.
      */
     export function moveRangePastModifiers(node: Node): TextRange {
-        return node.modifiers && node.modifiers.length > 0
+        return node.modifiers && !positionIsSynthesized(node.modifiers.end)
             ? moveRangePos(node, node.modifiers.end)
             : moveRangePastDecorators(node);
     }