tsc-ts 0.0.5 → 0.0.7

package/dist/api/compiler/parser.js

@@ -5,7 +5,7 @@
 // const file = parseSourceFile('/src/main.ts', text);
 // for (const statement of file.statements.nodes) console.log(statement.kind);
 // ```
-import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, } from './ast.js';
+import { appendToList, ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, CheckJsDirective, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, emptyCommentDirectives, emptyDiagnostics, emptyFileReferences, emptyNodes, emptyPragmas, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleIndicatorOptions, ExternalModuleReference, FileReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocAllType, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxClosingFragment, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxOpeningFragment, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, KeywordExpression, KeywordTypeNode, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, MissingNodeList, ModifierList, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NoSubstitutionTemplateLiteral, NodeList, NodeVisitor, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OmittedExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PostfixUnaryExpression, Pragma, PragmaArgument, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReferenceIdentifier, RegularExpressionLiteral, RestTypeNode, ReturnStatement, SatisfiesExpression, SemicolonClassElement, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateMiddle, TemplateSpan, TemplateTail, ThisTypeNode, ThrowStatement, Token, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, getBody, getIsTypeOnly, getModifiers, getName, getPostfixToken, getQuestionToken, getStatements, getText, getType, getTypeArguments, getTypeParameters, newCallExpression, newPropertyAssignment, } from './ast.js';
 import { canHaveDecorators, canHaveIllegalDecorators, compareNodePositions, getBinaryOperatorPrecedence, getExternalModuleName, getImportTypeNodeLiteral, getTextOfNodeFromSourceText, isAmbientModule, isAnyImportOrReExport, isAssignmentOperator, isClassMemberModifier, isFunctionLike, isImportCall, isImportMeta, isInJSFile, isKeyword, isKeywordOrPunctuation, isLeftHandSideExpression, isModifierKind, isRequireCall, isReservedWord, isStringLiteralLike, modifierToFlag, modifiersToFlags, nodeIsMissing, nodeIsPresent, tagNamesAreEquivalent, tokenIsIdentifierOrKeyword, tokenIsIdentifierOrKeywordOrGreaterThan, } from './ast-utilities.js';
 import { isLineBreak } from './character-codes.js';
 import { Diagnostic, messageCode } from './diagnostics.js';
@@ -52,6 +52,10 @@ function appendRange(to, from, start, end) {
     for (let i = start; i < end; i += 1)
         to.push(from[i]);
 }
+// The nodes of every empty parsed list. A list's nodes are pushed into a new `[]`, which natively
+// reserves room for its first elements (112 bytes); a parsed list never changes, so an empty one
+// keeps this shared array instead and its builder is freed.
+const emptyListNodes = [];
 /** Parses `text` as the file `fileName`. The script kind defaults to the one implied by the extension. */
 export function parseSourceFile(fileName, text, options) {
     const path = options === undefined ? fileName : options.path;
@@ -211,12 +215,15 @@ export class Parser extends ScannerErrorReporter {
         this.scanner.setLanguageVariant(this.languageVariant);
     }
     /**
-     * Frees the scanner's copy of the text once the parser is done. The parser and its scanner and
-     * JSDoc parser refer to each other, so natively they're freed only by a cycle collection, which may
-     * come much later.
+     * Frees the scanner's copy of the text once the parser is done, and drops the references back to
+     * this parser from its scanner and JSDoc parser. Natively, the parser is then freed as soon as its
+     * caller lets go of it, instead of at a cycle collection, which may come much later (on a parse
+     * thread, not before the thread exits).
      */
     release() {
         this.scanner.setText('');
+        this.scanner.setOnError(undefined);
+        this.jsdoc = releasedParser().jsdoc;
     }
     token() {
         return this.currentToken;
@@ -365,10 +372,10 @@ export class Parser extends ScannerErrorReporter {
     }
     // Nodes
     newNodeList(pos, end, nodes) {
-        return new NodeList(pos, end, nodes);
+        return new NodeList(pos, end, nodes.length === 0 ? emptyListNodes : nodes);
     }
     newModifierList(pos, end, nodes) {
-        return new ModifierList(pos, end, nodes, modifiersToFlags(nodes));
+        return new ModifierList(pos, end, nodes.length === 0 ? emptyListNodes : nodes, modifiersToFlags(nodes));
     }
     finishNode(node, pos) {
         return this.finishNodeWithEnd(node, pos, this.nodePos());
@@ -421,23 +428,18 @@ export class Parser extends ScannerErrorReporter {
         collectExternalModuleReferences(result);
         if (result.isJS())
             result.jsDiagnostics = attachFileToDiagnostics(this.jsDiagnostics, result);
-        // Declaration files get their caches on first use (in a thread's copy once they may be shared,
-        // `useThreadTextCaches`); the file's DiagnosticFile exists from here on, so reading it never
-        // writes to the file. The scanner holds the text's code units unless a nested parse cut its text short.
-        const scanner = this.scanner;
-        if (result.isDeclarationFile)
-            result.diagnosticFile();
-        else if (scanner.text === result.text && scanner.end === result.text.length)
-            result.computeCachesFromUnits(scanner.chars);
-        else
-            result.computeCaches();
+        // Files get their line starts on first use (in a thread's copy once they may be shared,
+        // `useThreadTextCaches`): most files are never pointed into by a diagnostic. The file's
+        // DiagnosticFile exists from here on, so reading it never writes to the file.
+        result.diagnosticFile();
         return result;
     }
     newSourceFile(statements, eof) {
         return new SourceFile(this.fileName, this.path, this.sourceText, this.externalModuleIndicatorOptions, statements, eof);
     }
     finishSourceFile(result, isDeclarationFile) {
-        result.commentDirectives = this.scanner.getCommentDirectives();
+        const commentDirectives = this.scanner.getCommentDirectives();
+        result.commentDirectives = commentDirectives.length === 0 ? emptyCommentDirectives : commentDirectives;
         result.pragmas = getCommentPragmas(this.sourceText);
         this.processPragmasIntoFields(result);
         result.diagnostics = attachFileToDiagnostics(this.diagnostics, result);
@@ -455,9 +457,13 @@ export class Parser extends ScannerErrorReporter {
         // The table stays with the parser: when top-level await reparsing produces a second source
         // file, it finishes with the same table, which still holds the JSDoc of retained statements.
         result.jsDocs = this.jsDocTable;
-        const clones = this.reparsedClones.slice();
-        clones.sort(compareNodePositions);
-        result.reparsedClones = clones;
+        if (this.reparsedClones.length === 0)
+            result.reparsedClones = emptyNodes;
+        else {
+            const clones = this.reparsedClones.slice();
+            clones.sort(compareNodePositions);
+            result.reparsedClones = clones;
+        }
         setExternalModuleIndicator(result);
     }
     parseToplevelStatement(index) {
@@ -1315,7 +1321,7 @@ export class Parser extends ScannerErrorReporter {
         return this.finishWithJSDoc(new ContinueStatement(label), pos, jsdoc);
     }
     parseIdentifierUnlessAtSemicolon() {
-        return this.canParseSemicolon() ? undefined : this.parseIdentifier();
+        return this.canParseSemicolon() ? undefined : this.parseIdentifier(1 /* IdentifierUse.Name */);
     }
     parseReturnStatement() {
         const pos = this.nodePos();
@@ -1660,7 +1666,7 @@ export class Parser extends ScannerErrorReporter {
         // named `implements`.
         if (this.isBindingIdentifier() && !this.isImplementsClause()) {
             const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-            const id = this.createIdentifier(this.isBindingIdentifier());
+            const id = this.createIdentifier(this.isBindingIdentifier(), 1 /* IdentifierUse.Name */);
             this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
             return id;
         }
@@ -1888,7 +1894,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseInterfaceDeclaration(pos, jsdoc, modifiers) {
         this.parseExpected(119 /* SyntaxKind.InterfaceKeyword */);
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         const typeParameters = this.parseTypeParameters();
         const heritageClauses = this.parseHeritageClauses();
         const members = this.parseObjectTypeMembers();
@@ -1900,7 +1906,7 @@ export class Parser extends ScannerErrorReporter {
         this.parseExpected(156 /* SyntaxKind.TypeKeyword */);
         if (this.hasPrecedingLineBreak())
             this.parseErrorAtCurrentToken(108 /* Diagnostics.Line_break_not_permitted_here */);
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         const typeParameters = this.parseTypeParameters();
         this.parseExpected(63 /* SyntaxKind.EqualsToken */);
         const type = this.token() === 141 /* SyntaxKind.IntrinsicKeyword */ && this.lookAhead(nextIsNotDot)
@@ -1926,7 +1932,7 @@ export class Parser extends ScannerErrorReporter {
     parseEnumDeclaration(pos, jsdoc, modifiers) {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
         this.parseExpected(93 /* SyntaxKind.EnumKeyword */);
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         let members;
         if (this.parseExpected(18 /* SyntaxKind.OpenBraceToken */)) {
             const saveContextFlags = this.contextFlags;
@@ -1965,7 +1971,7 @@ export class Parser extends ScannerErrorReporter {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
         if (this.token() === 162 /* SyntaxKind.GlobalKeyword */) {
             // `global` names the global scope augmentation.
-            name = this.parseIdentifier();
+            name = this.parseIdentifier(1 /* IdentifierUse.Name */);
             keyword = 162 /* SyntaxKind.GlobalKeyword */;
         }
         else {
@@ -1994,7 +2000,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseModuleOrNamespaceDeclaration(pos, jsdoc, modifiers, nested, keyword) {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        const name = nested ? this.parseIdentifierName() : this.parseIdentifier();
+        const name = nested ? this.parseIdentifierName(1 /* IdentifierUse.Name */) : this.parseIdentifier(1 /* IdentifierUse.Name */);
         let body;
         if (this.parseOptional(24 /* SyntaxKind.DotToken */)) {
             const implicitExport = new Token(94 /* SyntaxKind.ExportKeyword */);
@@ -2017,7 +2023,7 @@ export class Parser extends ScannerErrorReporter {
         const afterImportPos = this.nodePos();
         // The identifier isn't parsed in an await context; the checker reports `await`.
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        let identifier = this.isIdentifier() ? this.parseIdentifier() : undefined;
+        let identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
         let phaseModifier = 0 /* SyntaxKind.Unknown */;
         if (identifier !== undefined &&
             identifier.text === 'type' &&
@@ -2025,7 +2031,7 @@ export class Parser extends ScannerErrorReporter {
                 (this.isIdentifier() && this.lookAhead(nextTokenIsFromKeywordOrEqualsToken))) &&
             (this.isIdentifier() || this.tokenAfterImportDefinitelyProducesImportDeclaration())) {
             phaseModifier = 156 /* SyntaxKind.TypeKeyword */;
-            identifier = this.isIdentifier() ? this.parseIdentifier() : undefined;
+            identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
         }
         else if (identifier !== undefined && identifier.text === 'defer') {
             const shouldParseAsDeferModifier = this.token() === 161 /* SyntaxKind.FromKeyword */
@@ -2033,7 +2039,7 @@ export class Parser extends ScannerErrorReporter {
                 : this.token() !== 27 /* SyntaxKind.CommaToken */ && this.token() !== 63 /* SyntaxKind.EqualsToken */;
             if (shouldParseAsDeferModifier) {
                 phaseModifier = 166 /* SyntaxKind.DeferKeyword */;
-                identifier = this.isIdentifier() ? this.parseIdentifier() : undefined;
+                identifier = this.isIdentifier() ? this.parseIdentifier(1 /* IdentifierUse.Name */) : undefined;
             }
         }
         if (identifier !== undefined &&
@@ -2124,7 +2130,7 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         this.parseExpected(41 /* SyntaxKind.AsteriskToken */);
         this.parseExpected(129 /* SyntaxKind.AsKeyword */);
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         return this.finishNode(new NamespaceImport(name), pos);
     }
     parseNamedImports() {
@@ -2156,9 +2162,9 @@ export class Parser extends ScannerErrorReporter {
             //   import { type as as } from "mod";    - isTypeOnly: false, name: as, propertyName: type
             //   import { type as as as } from "mod"; - isTypeOnly: true,  name: as, propertyName: as
             if (this.token() === 129 /* SyntaxKind.AsKeyword */) {
-                const firstAs = this.parseIdentifierName();
+                const firstAs = this.parseIdentifierName(1 /* IdentifierUse.Name */);
                 if (this.token() === 129 /* SyntaxKind.AsKeyword */) {
-                    const secondAs = this.parseIdentifierName();
+                    const secondAs = this.parseIdentifierName(1 /* IdentifierUse.Name */);
                     if (this.canParseModuleExportName()) {
                         // { type as as something }
                         isTypeOnly = true;
@@ -2229,7 +2235,7 @@ export class Parser extends ScannerErrorReporter {
     parseModuleExportName() {
         if (this.token() === 10 /* SyntaxKind.StringLiteral */)
             return this.parseLiteralExpression(false);
-        return this.parseIdentifierName();
+        return this.parseIdentifierName(1 /* IdentifierUse.Name */);
     }
     tryParseImportAttributes() {
         if (this.token() === 117 /* SyntaxKind.WithKeyword */ ||
@@ -2261,7 +2267,7 @@ export class Parser extends ScannerErrorReporter {
         this.parseExpected(129 /* SyntaxKind.AsKeyword */);
         this.parseExpected(145 /* SyntaxKind.NamespaceKeyword */);
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         this.parseSemicolon();
         // Modifiers are kept so the grammar checker can report them.
@@ -2404,7 +2410,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseTypeParameterOfInferType() {
         const pos = this.nodePos();
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         const constraint = this.tryParseConstraintOfInferType();
         const result = new TypeParameterDeclaration(undefined, name, constraint, undefined, undefined);
         this.finishNode(result, pos);
@@ -2602,11 +2608,12 @@ export class Parser extends ScannerErrorReporter {
     parseEntityNameOfTypeReference() {
         return this.parseEntityName(true, 79 /* Diagnostics.Type_expected */);
     }
-    parseEntityName(allowReservedWords, diagnosticMessage) {
+    /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
+    parseEntityName(allowReservedWords, diagnosticMessage, use = 1 /* IdentifierUse.Name */) {
         const pos = this.nodePos();
         let entity = allowReservedWords
-            ? this.parseIdentifierNameWithDiagnostic(diagnosticMessage)
-            : this.parseIdentifierWithDiagnostic(diagnosticMessage, undefined);
+            ? this.parseIdentifierNameWithDiagnostic(diagnosticMessage, use)
+            : this.parseIdentifierWithDiagnostic(diagnosticMessage, undefined, use);
         while (this.parseOptional(24 /* SyntaxKind.DotToken */)) {
             // A JSDoc-style generic; the checker reports the gap between the name and the type arguments.
             if (this.token() === 29 /* SyntaxKind.LessThanToken */)
@@ -2631,20 +2638,20 @@ export class Parser extends ScannerErrorReporter {
         // after it). Report a missing identifier right after the dot rather than on the next token.
         if (this.isKeywordStartingNextLine()) {
             this.parseErrorAt(this.nodePos(), this.nodePos(), 1 /* Diagnostics.Identifier_expected */);
-            return this.createMissingIdentifier();
+            return this.createMissingIdentifier(1 /* IdentifierUse.Name */);
         }
         if (this.token() === 80 /* SyntaxKind.PrivateIdentifier */) {
             this.parsePrivateIdentifier();
             this.parseErrorAt(this.nodePos(), this.nodePos(), 1 /* Diagnostics.Identifier_expected */);
-            return this.createMissingIdentifier();
+            return this.createMissingIdentifier(1 /* IdentifierUse.Name */);
         }
         if (allowIdentifierNames) {
             if (allowUnicodeEscapeSequenceInIdentifierName)
-                return this.parseIdentifierName();
-            return this.parseIdentifierNameErrorOnUnicodeEscapeSequence();
+                return this.parseIdentifierName(1 /* IdentifierUse.Name */);
+            return this.parseIdentifierNameErrorOnUnicodeEscapeSequence(1 /* IdentifierUse.Name */);
         }
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        const id = this.parseIdentifier();
+        const id = this.parseIdentifier(1 /* IdentifierUse.Name */);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         return id;
     }
@@ -2654,14 +2661,25 @@ export class Parser extends ScannerErrorReporter {
             tokenIsIdentifierOrKeyword(this.token()) &&
             this.lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine));
     }
-    newIdentifier(text) {
+    /**
+     * A new identifier of the class `use` calls for. Callers create it after the identifier's token, so
+     * for an element name the current token tells a shorthand property from an assignment or a method.
+     */
+    newIdentifier(text, use = 0 /* IdentifierUse.Reference */) {
         this.identifierCount++;
         if (text === 'await')
             this.statementHasAwaitIdentifier = true;
-        return new Identifier(text);
+        if (use === 1 /* IdentifierUse.Name */ || (use === 2 /* IdentifierUse.ElementName */ && this.isElementNameEnd()))
+            return new Identifier(text);
+        return new ReferenceIdentifier(text);
     }
-    createMissingIdentifier() {
-        const result = this.newIdentifier('');
+    /** Whether the current token ends an object literal element name that is not a shorthand property. */
+    isElementNameEnd() {
+        const token = this.token();
+        return token === 58 /* SyntaxKind.ColonToken */ || token === 20 /* SyntaxKind.OpenParenToken */ || token === 29 /* SyntaxKind.LessThanToken */;
+    }
+    createMissingIdentifier(use = 0 /* IdentifierUse.Reference */) {
+        const result = this.newIdentifier('', use);
         this.finishNode(result, this.nodePos());
         return result;
     }
@@ -2741,7 +2759,7 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         let name;
         if (tokenIsIdentifierOrKeyword(this.token()))
-            name = this.parseIdentifierName();
+            name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
         else if (this.token() === 10 /* SyntaxKind.StringLiteral */)
             name = this.parseLiteralExpression(false);
         if (name !== undefined)
@@ -2774,7 +2792,7 @@ export class Parser extends ScannerErrorReporter {
     parseTypeQuery() {
         const pos = this.nodePos();
         this.parseExpected(113 /* SyntaxKind.TypeOfKeyword */);
-        const entityName = this.parseEntityName(true, undefined);
+        const entityName = this.parseEntityName(true, undefined, 0 /* IdentifierUse.Reference */);
         // ASI: don't parse the next line's type arguments as part of an instantiation expression.
         const typeArguments = this.hasPrecedingLineBreak() ? undefined : this.parseTypeArguments();
         return this.finishNode(new TypeQueryNode(entityName, typeArguments), pos);
@@ -2810,7 +2828,7 @@ export class Parser extends ScannerErrorReporter {
     }
     parseMappedTypeParameter() {
         const pos = this.nodePos();
-        const name = this.parseIdentifierName();
+        const name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
         this.parseExpected(102 /* SyntaxKind.InKeyword */);
         const type = this.parseType();
         const result = new TypeParameterDeclaration(undefined, name, type, undefined, undefined);
@@ -2855,7 +2873,7 @@ export class Parser extends ScannerErrorReporter {
     parseTypeParameter() {
         const pos = this.nodePos();
         const modifiers = this.parseModifiersEx(false, true, false);
-        const name = this.parseIdentifier();
+        const name = this.parseIdentifier(1 /* IdentifierUse.Name */);
         let constraint;
         let expression;
         if (this.parseOptional(95 /* SyntaxKind.ExtendsKeyword */)) {
@@ -2909,7 +2927,7 @@ export class Parser extends ScannerErrorReporter {
         const modifiers = this.parseModifiersEx(true, false, false);
         this.contextFlags = saveContextFlags;
         if (this.token() === 109 /* SyntaxKind.ThisKeyword */) {
-            const result = new ParameterDeclaration(modifiers, undefined, this.createIdentifier(true), undefined, this.parseTypeAnnotation(), undefined);
+            const result = new ParameterDeclaration(modifiers, undefined, this.createIdentifier(true, 1 /* IdentifierUse.Name */), undefined, this.parseTypeAnnotation(), undefined);
             if (modifiers !== undefined) {
                 const first = modifiers.nodes[0];
                 this.parseErrorAt(first.pos, first.end, 359 /* Diagnostics.Neither_decorators_nor_modifiers_may_be_applied_to_this_parameters */);
@@ -2970,7 +2988,7 @@ export class Parser extends ScannerErrorReporter {
         if (this.isIdentifier()) {
             const state = this.beginSpeculation();
             const pos = this.nodePos();
-            const id = this.parseIdentifier();
+            const id = this.parseIdentifier(1 /* IdentifierUse.Name */);
             if (this.token() === 142 /* SyntaxKind.IsKeyword */ && !this.hasPrecedingLineBreak()) {
                 this.endSpeculation(state);
                 this.nextToken();
@@ -3000,13 +3018,13 @@ export class Parser extends ScannerErrorReporter {
             this.checkJSSyntax(result);
         return result;
     }
-    parsePropertyName() {
+    parsePropertyName(use = 1 /* IdentifierUse.Name */) {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        const prop = this.parsePropertyNameWorker(true);
+        const prop = this.parsePropertyNameWorker(true, use);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         return prop;
     }
-    parsePropertyNameWorker(allowComputedPropertyNames) {
+    parsePropertyNameWorker(allowComputedPropertyNames, use = 1 /* IdentifierUse.Name */) {
         const token = this.token();
         if (token === 10 /* SyntaxKind.StringLiteral */ || token === 8 /* SyntaxKind.NumericLiteral */ || token === 9 /* SyntaxKind.BigIntLiteral */)
             return this.parseLiteralExpression(true);
@@ -3014,7 +3032,7 @@ export class Parser extends ScannerErrorReporter {
             return this.parseComputedPropertyName();
         if (token === 80 /* SyntaxKind.PrivateIdentifier */)
             return this.parsePrivateIdentifier();
-        return this.parseIdentifierName();
+        return this.parseIdentifierName(use);
     }
     parseComputedPropertyName() {
         const pos = this.nodePos();
@@ -3099,7 +3117,7 @@ export class Parser extends ScannerErrorReporter {
             const pos = this.nodePos();
             const jsdoc = this.jsdocScannerInfo();
             const dotDotDotToken = this.parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */);
-            const name = this.parseIdentifierName();
+            const name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
             const questionToken = this.parseOptionalToken(57 /* SyntaxKind.QuestionToken */);
             this.parseExpected(58 /* SyntaxKind.ColonToken */);
             const type = this.parseTupleElementType();
@@ -3132,7 +3150,7 @@ export class Parser extends ScannerErrorReporter {
     parseAssertsTypePredicate() {
         const pos = this.nodePos();
         const assertsModifier = this.parseExpectedToken(130 /* SyntaxKind.AssertsKeyword */);
-        const parameterName = this.token() === 109 /* SyntaxKind.ThisKeyword */ ? this.parseThisTypeNode() : this.parseIdentifier();
+        const parameterName = this.token() === 109 /* SyntaxKind.ThisKeyword */ ? this.parseThisTypeNode() : this.parseIdentifier(1 /* IdentifierUse.Name */);
         const type = this.parseOptional(142 /* SyntaxKind.IsKeyword */) ? this.parseType() : undefined;
         return this.finishNode(new TypePredicateNode(assertsModifier, parameterName, type), pos);
     }
@@ -4101,10 +4119,10 @@ export class Parser extends ScannerErrorReporter {
     parseJsxAttributeName() {
         const pos = this.nodePos();
         this.scanJsxIdentifier();
-        const attrName = this.parseIdentifierNameErrorOnUnicodeEscapeSequence();
+        const attrName = this.parseIdentifierNameErrorOnUnicodeEscapeSequence(1 /* IdentifierUse.Name */);
         if (this.parseOptional(58 /* SyntaxKind.ColonToken */)) {
             this.scanJsxIdentifier();
-            return this.finishNode(new JsxNamespacedName(attrName, this.parseIdentifierNameErrorOnUnicodeEscapeSequence()), pos);
+            return this.finishNode(new JsxNamespacedName(attrName, this.parseIdentifierNameErrorOnUnicodeEscapeSequence(1 /* IdentifierUse.Name */)), pos);
         }
         return attrName;
     }
@@ -4222,7 +4240,7 @@ export class Parser extends ScannerErrorReporter {
                 // An `import.*` meta property, such as `import.meta`.
                 this.nextToken();
                 this.nextToken();
-                const name = this.parseIdentifierName();
+                const name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
                 expression = this.finishNode(new MetaProperty(101 /* SyntaxKind.ImportKeyword */, name), pos);
                 if (name.text === 'defer') {
                     if (this.token() === 20 /* SyntaxKind.OpenParenToken */ || this.token() === 29 /* SyntaxKind.LessThanToken */)
@@ -4440,7 +4458,7 @@ export class Parser extends ScannerErrorReporter {
                 const inner = expression;
                 const argumentList = this.parseArgumentList();
                 const isOptionalChain = questionDotToken !== undefined || this.tryReparseOptionalChain(expression);
-                expression = this.checkJSSyntax(this.finishNode(new CallExpression(expression, questionDotToken, typeArguments, argumentList, isOptionalChain ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */), pos));
+                expression = this.checkJSSyntax(this.finishNode(newCallExpression(expression, questionDotToken, typeArguments, argumentList, isOptionalChain ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */, (this.contextFlags & 65536 /* NodeFlags.JavaScriptFile */) !== 0), pos));
                 this.unparseExpressionWithTypeArguments(inner, typeArguments, expression);
                 continue;
             }
@@ -4606,7 +4624,7 @@ export class Parser extends ScannerErrorReporter {
             return this.parseAccessorDeclaration(pos, jsdoc, modifiers, 179 /* SyntaxKind.SetAccessor */, 0 /* ParseFlags.None */);
         const asteriskToken = this.parseOptionalToken(41 /* SyntaxKind.AsteriskToken */);
         const tokenIsIdentifier = this.isIdentifier();
-        const name = this.parsePropertyName();
+        const name = this.parsePropertyName(2 /* IdentifierUse.ElementName */);
         // The grammar checker reports optional property assignments, definite assignment assertions,
         // decorators and modifiers.
         let postfixToken = this.parseOptionalToken(57 /* SyntaxKind.QuestionToken */);
@@ -4627,7 +4645,7 @@ export class Parser extends ScannerErrorReporter {
         else {
             this.parseExpected(58 /* SyntaxKind.ColonToken */);
             const initializer = this.parseAssignmentExpressionOrHigherAllowIn();
-            node = new PropertyAssignment(modifiers, name, postfixToken, undefined, initializer);
+            node = newPropertyAssignment(modifiers, name, postfixToken, undefined, initializer, (this.contextFlags & 65536 /* NodeFlags.JavaScriptFile */) !== 0);
         }
         return this.finishWithJSDoc(node, pos, jsdoc);
     }
@@ -4683,7 +4701,7 @@ export class Parser extends ScannerErrorReporter {
         const pos = this.nodePos();
         this.parseExpected(104 /* SyntaxKind.NewKeyword */);
         if (this.parseOptional(24 /* SyntaxKind.DotToken */)) {
-            const name = this.parseIdentifierName();
+            const name = this.parseIdentifierName(1 /* IdentifierUse.Name */);
             return this.finishNode(new MetaProperty(104 /* SyntaxKind.NewKeyword */, name), pos);
         }
         const expressionPos = this.nodePos();
@@ -4739,36 +4757,36 @@ export class Parser extends ScannerErrorReporter {
         return this.finishNode(result, pos);
     }
     // Identifiers
-    parseIdentifierNameErrorOnUnicodeEscapeSequence() {
+    parseIdentifierNameErrorOnUnicodeEscapeSequence(use = 0 /* IdentifierUse.Reference */) {
         if (this.scanner.hasUnicodeEscape() || this.scanner.hasExtendedUnicodeEscape())
             this.parseErrorAtCurrentToken(1824 /* Diagnostics.Unicode_escape_sequence_cannot_appear_here */);
-        return this.createIdentifier(tokenIsIdentifierOrKeyword(this.token()));
+        return this.createIdentifier(tokenIsIdentifierOrKeyword(this.token()), use);
     }
     parseBindingIdentifier() {
         return this.parseBindingIdentifierWithDiagnostic(undefined);
     }
     parseBindingIdentifierWithDiagnostic(privateIdentifierDiagnosticMessage) {
         const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-        const id = this.createIdentifierWithDiagnostic(this.isBindingIdentifier(), undefined, privateIdentifierDiagnosticMessage);
+        const id = this.createIdentifierWithDiagnostic(this.isBindingIdentifier(), undefined, privateIdentifierDiagnosticMessage, 1 /* IdentifierUse.Name */);
         this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
         return id;
     }
-    parseIdentifierName() {
-        return this.parseIdentifierNameWithDiagnostic(undefined);
+    parseIdentifierName(use = 0 /* IdentifierUse.Reference */) {
+        return this.parseIdentifierNameWithDiagnostic(undefined, use);
     }
-    parseIdentifierNameWithDiagnostic(diagnosticMessage) {
-        return this.createIdentifierWithDiagnostic(tokenIsIdentifierOrKeyword(this.token()), diagnosticMessage, undefined);
+    parseIdentifierNameWithDiagnostic(diagnosticMessage, use = 0 /* IdentifierUse.Reference */) {
+        return this.createIdentifierWithDiagnostic(tokenIsIdentifierOrKeyword(this.token()), diagnosticMessage, undefined, use);
     }
-    parseIdentifier() {
-        return this.parseIdentifierWithDiagnostic(undefined, undefined);
+    parseIdentifier(use = 0 /* IdentifierUse.Reference */) {
+        return this.parseIdentifierWithDiagnostic(undefined, undefined, use);
     }
-    parseIdentifierWithDiagnostic(diagnosticMessage, privateIdentifierDiagnosticMessage) {
-        return this.createIdentifierWithDiagnostic(this.isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage);
+    parseIdentifierWithDiagnostic(diagnosticMessage, privateIdentifierDiagnosticMessage, use = 0 /* IdentifierUse.Reference */) {
+        return this.createIdentifierWithDiagnostic(this.isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage, use);
     }
-    createIdentifier(isIdentifier) {
-        return this.createIdentifierWithDiagnostic(isIdentifier, undefined, undefined);
+    createIdentifier(isIdentifier, use = 0 /* IdentifierUse.Reference */) {
+        return this.createIdentifierWithDiagnostic(isIdentifier, undefined, undefined, use);
     }
-    createIdentifierWithDiagnostic(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) {
+    createIdentifierWithDiagnostic(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage, use = 0 /* IdentifierUse.Reference */) {
         if (isIdentifier) {
             const pos = this.scanner.hasPrecedingJSDocLeadingAsterisks() ? this.scanner.getTokenStart() : this.nodePos();
             const text = this.scanner.getIdentifierValue();
@@ -4776,7 +4794,7 @@ export class Parser extends ScannerErrorReporter {
             this.nextTokenWithoutCheck();
             if (record)
                 this.identifierTexts.push(text);
-            const result = this.newIdentifier(text);
+            const result = this.newIdentifier(text, use);
             this.finishNode(result, pos);
             return result;
         }
@@ -4784,7 +4802,7 @@ export class Parser extends ScannerErrorReporter {
             this.parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage !== undefined
                 ? privateIdentifierDiagnosticMessage
                 : 1838 /* Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies */);
-            return this.createIdentifier(true);
+            return this.createIdentifier(true, use);
         }
         // Report at the current position only at the end of the file: elsewhere the error would land
         // incorrectly on embedded script tags.
@@ -4809,7 +4827,7 @@ export class Parser extends ScannerErrorReporter {
         else {
             this.parseErrorAtCurrentToken(1 /* Diagnostics.Identifier_expected */);
         }
-        return this.createMissingIdentifier();
+        return this.createMissingIdentifier(use);
     }
     internIdentifier(text) {
         this.identifierTexts.push(text);
@@ -5531,9 +5549,9 @@ export class Parser extends ScannerErrorReporter {
     // Pragmas
     processPragmasIntoFields(file) {
         file.checkJsDirective = undefined;
-        file.referencedFiles = [];
-        file.typeReferenceDirectives = [];
-        file.libReferenceDirectives = [];
+        file.referencedFiles = emptyFileReferences;
+        file.typeReferenceDirectives = emptyFileReferences;
+        file.libReferenceDirectives = emptyFileReferences;
         for (const pragma of file.pragmas) {
             switch (pragma.name) {
                 case 'reference': {
@@ -5552,13 +5570,13 @@ export class Parser extends ScannerErrorReporter {
                         const parsed = resolutionMode !== undefined
                             ? this.parseResolutionMode(resolutionMode.value, resolutionMode.pos, resolutionMode.end)
                             : ModuleKind.None;
-                        file.typeReferenceDirectives.push(new FileReference(types.pos, types.end, types.value, parsed, isPreserved));
+                        file.typeReferenceDirectives = appendToList(file.typeReferenceDirectives, new FileReference(types.pos, types.end, types.value, parsed, isPreserved));
                     }
                     else if (lib !== undefined) {
-                        file.libReferenceDirectives.push(new FileReference(lib.pos, lib.end, lib.value, ModuleKind.None, isPreserved));
+                        file.libReferenceDirectives = appendToList(file.libReferenceDirectives, new FileReference(lib.pos, lib.end, lib.value, ModuleKind.None, isPreserved));
                     }
                     else if (path !== undefined) {
-                        file.referencedFiles.push(new FileReference(path.pos, path.end, path.value, ModuleKind.None, isPreserved));
+                        file.referencedFiles = appendToList(file.referencedFiles, new FileReference(path.pos, path.end, path.value, ModuleKind.None, isPreserved));
                     }
                     else {
                         this.parseErrorAt(pragma.range.pos, pragma.range.end, 57 /* Diagnostics.Invalid_reference_directive_syntax */);
@@ -5698,6 +5716,16 @@ export function forgetLazyJSDocFile() {
     lazyJSDocFile = undefined;
 }
 const viableKeywordSuggestions = getViableKeywordSuggestions();
+// A parser whose JSDoc parser released parsers keep (`Parser.release`), created on first use.
+let releasedParserValue;
+function releasedParser() {
+    let parser = releasedParserValue;
+    if (parser === undefined) {
+        parser = new Parser('/', '/', '', 3 /* ScriptKind.TS */, new ExternalModuleIndicatorOptions(false, false));
+        releasedParserValue = parser;
+    }
+    return parser;
+}
 function getSpaceSuggestion(expressionText) {
     for (const keyword of viableKeywordSuggestions)
         if (expressionText.length > keyword.length + 2 && expressionText.startsWith(keyword))
@@ -5757,7 +5785,7 @@ function typeHasBlockingError(node) {
 }
 function attachFileToDiagnostics(diagnostics, file) {
     if (diagnostics.length === 0)
-        return diagnostics;
+        return emptyDiagnostics;
     const diagnosticFile = file.diagnosticFile();
     for (const d of diagnostics) {
         d.file = diagnosticFile;
@@ -6015,12 +6043,13 @@ function nextTokenIsNotColon(p) {
 }
 // Pragmas
 function getCommentPragmas(sourceText) {
-    const pragmas = [];
     const ranges = getLeadingCommentRanges(sourceText, 0);
-    if (ranges !== undefined)
-        for (const range of ranges)
-            extractPragmas(range, sourceText.substring(range.pos, range.end), pragmas);
-    return pragmas;
+    if (ranges === undefined)
+        return emptyPragmas;
+    const pragmas = [];
+    for (const range of ranges)
+        extractPragmas(range, sourceText.substring(range.pos, range.end), pragmas);
+    return pragmas.length === 0 ? emptyPragmas : pragmas;
 }
 function extractPragmas(range, text, pragmas) {
     if (range.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) {
@@ -6181,10 +6210,10 @@ function collectModuleReferences(file, node, inAmbientModule) {
         (inAmbientModule || hasModifierFlag(node, 128 /* ModifierFlags.Ambient */) || file.isDeclarationFile)) {
         const nameText = getText(node.name);
         if (file.externalModuleIndicator !== undefined || (inAmbientModule && !isExternalModuleNameRelative(nameText))) {
-            file.moduleAugmentations.push(node.name);
+            file.moduleAugmentations = appendToList(file.moduleAugmentations, node.name);
         }
         else if (!inAmbientModule) {
-            file.ambientModuleNames.push(nameText);
+            file.ambientModuleNames = appendToList(file.ambientModuleNames, nameText);
             const body = node.body;
             if (body !== undefined) {
                 const statements = getStatements(body);