Implement the Stage 3 Decorators Proposal

src/compiler/binder.ts

@@ -2783,7 +2783,7 @@ namespace ts {
         }
 
         function bindNamespaceExportDeclaration(node: NamespaceExportDeclaration) {
-            if (some(node.modifiers)) {
+            if (some(node.decoratorsAndModifiers)) {
                 file.bindDiagnostics.push(createDiagnosticForNode(node, Diagnostics.Modifiers_cannot_appear_here));
             }
             const diag = !isSourceFile(node.parent) ? Diagnostics.Global_module_exports_may_only_appear_at_top_level

src/compiler/commandLineParser.ts

@@ -93,7 +93,10 @@ namespace ts {
         ["esnext.bigint", "lib.es2020.bigint.d.ts"],
         ["esnext.string", "lib.es2022.string.d.ts"],
         ["esnext.promise", "lib.es2021.promise.d.ts"],
-        ["esnext.weakref", "lib.es2021.weakref.d.ts"]
+        ["esnext.weakref", "lib.es2021.weakref.d.ts"],
+        ["decorators", "lib.decorators.d.ts"],
+        ["decorators.legacy", "lib.decorators.legacy.d.ts"],
+        ["decorators.parameters", "lib.decorators.parameters.d.ts"],
     ];
 
     /**
@@ -317,7 +320,7 @@ namespace ts {
             isCommandLineOnly: true,
             description: Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit,
             defaultValueDescription: Diagnostics.Platform_specific
-        },
+        }
     ];
 
     /* @internal */

src/compiler/core.ts

@@ -1400,6 +1400,20 @@ namespace ts {
         return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector);
     }
 
+    export function groupBy<T, U extends T>(values: readonly T[] | undefined, keySelector: (value: T) => value is U): { true?: U[], false?: Exclude<T, U>[] };
+    export function groupBy<T, K extends string | number | boolean | null | undefined>(values: readonly T[] | undefined, keySelector: (value: T) => K): { [P in K as `${P}`]?: T[]; };
+    export function groupBy<T, K extends string | number | boolean | null | undefined>(values: readonly T[] | undefined, keySelector: (value: T) => K): { [P in K as `${P}`]?: T[]; } {
+        const result: Record<string, T[]> = {};
+        if (values) {
+            for (const value of values) {
+                const key = `${keySelector(value)}`;
+                const array = result[key] ??= [];
+                array.push(value);
+            }
+        }
+        return result as { [P in K as `${P}`]?: T[]; };
+    }
+
     export function clone<T>(object: T): T {
         const result: any = {};
         for (const id in object) {
@@ -2492,13 +2506,29 @@ namespace ts {
     }
 
     export function takeWhile<T, U extends T>(array: readonly T[], predicate: (element: T) => element is U): U[];
-    export function takeWhile<T>(array: readonly T[], predicate: (element: T) => boolean): T[] {
-        const len = array.length;
-        let index = 0;
-        while (index < len && predicate(array[index])) {
-            index++;
+    export function takeWhile<T, U extends T>(array: readonly T[] | undefined, predicate: (element: T) => element is U): U[] | undefined;
+    export function takeWhile<T, U extends T>(array: readonly T[] | undefined, predicate: (element: T) => element is U): U[] | undefined {
+        if (array) {
+            const len = array.length;
+            let index = 0;
+            while (index < len && predicate(array[index])) {
+                index++;
+            }
+            return array.slice(0, index) as U[];
+        }
+    }
+
+    export function skipWhile<T, U extends T>(array: readonly T[], predicate: (element: T) => element is U): Exclude<T, U>[];
+    export function skipWhile<T, U extends T>(array: readonly T[] | undefined, predicate: (element: T) => element is U): Exclude<T, U>[] | undefined;
+    export function skipWhile<T, U extends T>(array: readonly T[] | undefined, predicate: (element: T) => element is U): Exclude<T, U>[] | undefined {
+        if (array) {
+            const len = array.length;
+            let index = 0;
+            while (index < len && predicate(array[index])) {
+                index++;
+            }
+            return array.slice(index) as Exclude<T, U>[];
         }
-        return array.slice(0, index);
     }
 
     /**

src/compiler/diagnosticMessages.json

@@ -907,6 +907,14 @@
         "category": "Error",
         "code": 1276
     },
+    "The runtime will invoke the decorator with {1} arguments, but the decorator expects {0}.": {
+        "category": "Error",
+        "code": 1277
+    },
+    "The runtime will invoke the decorator with {1} arguments, but the decorator expects at least {0}.": {
+        "category": "Error",
+        "code": 1278
+    },
 
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
@@ -1384,7 +1392,7 @@
         "category": "Error",
         "code": 1432
     },
-    "Decorators may not be applied to 'this' parameters.": {
+    "Neither decorators nor modifiers may be applied to 'this' parameters.": {
         "category": "Error",
         "code": 1433
     },

src/compiler/emitter.ts

@@ -397,7 +397,7 @@ namespace ts {
                 inlineSources: compilerOptions.inlineSources,
                 extendedDiagnostics: compilerOptions.extendedDiagnostics,
                 writeBundleFileInfo: !!bundleBuildInfo,
-                relativeToBuildInfo
+                relativeToBuildInfo,
             };
 
             // Create a printer to print the nodes
@@ -457,7 +457,7 @@ namespace ts {
                 onlyPrintJsDocStyle: true,
                 writeBundleFileInfo: !!bundleBuildInfo,
                 recordInternalSection: !!bundleBuildInfo,
-                relativeToBuildInfo
+                relativeToBuildInfo,
             };
 
             const declarationPrinter = createPrinter(printerOptions, {
@@ -901,6 +901,7 @@ namespace ts {
 
         let currentSourceFile: SourceFile | undefined;
         let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
+        let nodeIdToGeneratedPrivateName: string[]; // Map of generated names for specific nodes.
         let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
         let generatedNames: Set<string>; // Set of names generated by the NameGenerator.
         let formattedNameTempFlagsStack: (ESMap<string, TempFlags> | undefined)[];
@@ -1193,6 +1194,7 @@ namespace ts {
 
         function reset() {
             nodeIdToGeneratedName = [];
+            nodeIdToGeneratedPrivateName = [];
             autoGeneratedIdToGeneratedName = [];
             generatedNames = new Set();
             formattedNameTempFlagsStack = [];
@@ -1240,7 +1242,7 @@ namespace ts {
         }
 
         function beforeEmitNode(node: Node) {
-            if (preserveSourceNewlines && (getEmitFlags(node) & EmitFlags.IgnoreSourceNewlines)) {
+            if (preserveSourceNewlines && (getInternalEmitFlags(node) & InternalEmitFlags.IgnoreSourceNewlines)) {
                 preserveSourceNewlines = false;
             }
         }
@@ -1777,6 +1779,8 @@ namespace ts {
                         return emitMetaProperty(node as MetaProperty);
                     case SyntaxKind.SyntheticExpression:
                         return Debug.fail("SyntheticExpression should never be printed.");
+                    case SyntaxKind.MissingDeclaration:
+                        return;
 
                     // JSX
                     case SyntaxKind.JsxElement:
@@ -2143,8 +2147,9 @@ namespace ts {
         }
 
         function emitAccessorDeclaration(node: AccessorDeclaration) {
-            emitDecoratorsAndModifiers(node, node.modifiers);
-            writeKeyword(node.kind === SyntaxKind.GetAccessor ? "get" : "set");
+            const pos = emitDecoratorsAndModifiers(node, node.modifiers);
+            const token = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.GetKeyword : SyntaxKind.SetKeyword;
+            emitTokenWithComment(token, pos, writeKeyword, node);
             writeSpace();
             emit(node.name);
             emitSignatureAndBody(node, emitSignatureHead);
@@ -2559,7 +2564,7 @@ namespace ts {
         }
 
         function emitCallExpression(node: CallExpression) {
-            const indirectCall = getEmitFlags(node) & EmitFlags.IndirectCall;
+            const indirectCall = getInternalEmitFlags(node) & InternalEmitFlags.IndirectCall;
             if (indirectCall) {
                 writePunctuation("(");
                 writeLiteral("0");
@@ -2584,7 +2589,7 @@ namespace ts {
         }
 
         function emitTaggedTemplateExpression(node: TaggedTemplateExpression) {
-            const indirectCall = getEmitFlags(node) & EmitFlags.IndirectCall;
+            const indirectCall = getInternalEmitFlags(node) & InternalEmitFlags.IndirectCall;
             if (indirectCall) {
                 writePunctuation("(");
                 writeLiteral("0");
@@ -3308,7 +3313,7 @@ namespace ts {
             forEach(node.members, generateMemberNames);
 
             emitDecoratorsAndModifiers(node, node.modifiers);
-            writeKeyword("class");
+            emitTokenWithComment(SyntaxKind.ClassKeyword, moveRangePastModifiers(node).pos, writeKeyword, node);
             if (node.name) {
                 writeSpace();
                 emitIdentifierName(node.name);
@@ -4235,10 +4240,11 @@ namespace ts {
                 let mode: "modifiers" | "decorators" | undefined;
                 let start = 0;
                 let pos = 0;
+                let lastModifier: ModifierLike | undefined;
                 while (start < modifiers.length) {
                     while (pos < modifiers.length) {
-                        const modifier = modifiers[pos];
-                        mode = isDecorator(modifier) ? "decorators" : "modifiers";
+                        lastModifier = modifiers[pos];
+                        mode = isDecorator(lastModifier) ? "decorators" : "modifiers";
                         if (lastMode === undefined) {
                             lastMode = mode;
                         }
@@ -4268,11 +4274,19 @@ namespace ts {
                 }
 
                 onAfterEmitNodeArray?.(modifiers);
+
+                if (lastModifier && !positionIsSynthesized(lastModifier.end)) {
+                    return lastModifier.end;
+                }
             }
+
+            return node.pos;
         }
 
-        function emitModifiers(node: Node, modifiers: NodeArray<Modifier> | undefined): void {
+        function emitModifiers(node: Node, modifiers: NodeArray<Modifier> | undefined): number {
             emitList(node, modifiers, ListFormat.Modifiers);
+            const lastModifier = lastOrUndefined(modifiers);
+            return lastModifier && !positionIsSynthesized(lastModifier.end) ? lastModifier.end : node.pos;
         }
 
         function emitTypeAnnotation(node: TypeNode | undefined) {
@@ -4338,8 +4352,10 @@ namespace ts {
             }
         }
 
-        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator> | undefined): void {
+        function emitDecorators(parentNode: Node, decorators: NodeArray<Decorator> | undefined): number {
             emitList(parentNode, decorators, ListFormat.Decorators);
+            const lastDecorator = lastOrUndefined(decorators);
+            return lastDecorator && !positionIsSynthesized(lastDecorator.end) ? lastDecorator.end : parentNode.pos;
         }
 
         function emitTypeArguments(parentNode: Node, typeArguments: NodeArray<TypeNode> | undefined) {
@@ -4490,6 +4506,7 @@ namespace ts {
 
             // Emit each child.
             let previousSibling: Node | undefined;
+            let previousSiblingEmitFlags: EmitFlags | undefined;
             let previousSourceFileTextKind: ReturnType<typeof recordBundleFileInternalSectionStart>;
             let shouldDecreaseIndentAfterEmit = false;
             for (let i = 0; i < count; i++) {
@@ -4509,8 +4526,12 @@ namespace ts {
                     //          /* End of parameter a */ -> this comment isn't considered to be trailing comment of parameter "a" due to newline
                     //          ,
                     if (format & ListFormat.DelimitersMask && previousSibling.end !== (parentNode ? parentNode.end : -1)) {
-                        emitLeadingCommentsOfPosition(previousSibling.end);
+                        previousSiblingEmitFlags = getEmitFlags(previousSibling);
+                        if (!(previousSiblingEmitFlags & EmitFlags.NoTrailingComments)) {
+                            emitLeadingCommentsOfPosition(previousSibling.end);
+                        }
                     }
+
                     writeDelimiter(format);
                     recordBundleFileInternalSectionEnd(previousSourceFileTextKind);
 
@@ -4551,10 +4572,11 @@ namespace ts {
                 }
 
                 previousSibling = child;
+                previousSiblingEmitFlags = undefined;
             }
 
             // Write a trailing comma, if requested.
-            const emitFlags = previousSibling ? getEmitFlags(previousSibling) : 0;
+            const emitFlags = previousSibling ? previousSiblingEmitFlags ?? getEmitFlags(previousSibling) : 0;
             const skipTrailingComments = commentsDisabled || !!(emitFlags & EmitFlags.NoTrailingComments);
             const emitTrailingComma = hasTrailingComma && (format & ListFormat.AllowTrailingComma) && (format & ListFormat.CommaDelimited);
             if (emitTrailingComma) {
@@ -5173,7 +5195,8 @@ namespace ts {
 
         function generateNameCached(node: Node, privateName: boolean, flags?: GeneratedIdentifierFlags, prefix?: string | GeneratedNamePart, suffix?: string) {
             const nodeId = getNodeId(node);
-            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, privateName, flags ?? GeneratedIdentifierFlags.None, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
+            const cache = privateName ? nodeIdToGeneratedPrivateName : nodeIdToGeneratedName;
+            return cache[nodeId] || (cache[nodeId] = generateNameForNode(node, privateName, flags ?? GeneratedIdentifierFlags.None, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
         }
 
         /**
@@ -5397,7 +5420,14 @@ namespace ts {
                     Debug.assert(!prefix && !suffix && !privateName);
                     return generateNameForImportOrExportDeclaration(node as ImportDeclaration | ExportDeclaration);
                 case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.ClassDeclaration: {
+                    Debug.assert(!prefix && !suffix && !privateName);
+                    const name = (node as ClassDeclaration | FunctionDeclaration).name;
+                    if (name && !isGeneratedIdentifier(name)) {
+                        return generateNameForNode(name, /*privateName*/ false, flags, prefix, suffix);
+                    }
+                    return generateNameForExportDefault();
+                }
                 case SyntaxKind.ExportAssignment:
                     Debug.assert(!prefix && !suffix && !privateName);
                     return generateNameForExportDefault();