tsc-ts 0.0.5 → 0.0.7

package/src/compiler/parser.ts

@@ -6,6 +6,7 @@
 // for (const statement of file.statements.nodes) console.log(statement.kind);
 // ```
 import {
+  appendToList,
   ArrayLiteralExpression,
   ArrayTypeNode,
   ArrowFunction,
@@ -38,6 +39,11 @@ import {
   DeleteExpression,
   DoStatement,
   ElementAccessExpression,
+  emptyCommentDirectives,
+  emptyDiagnostics,
+  emptyFileReferences,
+  emptyNodes,
+  emptyPragmas,
   EmptyStatement,
   EnumDeclaration,
   EnumMember,
@@ -133,6 +139,7 @@ import {
   PropertyDeclaration,
   PropertySignatureDeclaration,
   QualifiedName,
+  ReferenceIdentifier,
   RegularExpressionLiteral,
   RestTypeNode,
   ReturnStatement,
@@ -192,6 +199,8 @@ import {
   type Expression,
   type Statement,
   type TypeNode,
+  newCallExpression,
+  newPropertyAssignment,
 } from './ast.js';
 import {
   OperatorPrecedence,
@@ -311,6 +320,16 @@ export const enum ParseFlags {
   JSDoc = 1 << 5,
 }
 
+/** How an identifier is used, which decides whether it holds a flow node. */
+export const enum IdentifierUse {
+  /** An expression or another reference: a `ReferenceIdentifier`. */
+  Reference,
+  /** A declaration, property, property access or type name, whose flow node nothing reads: an `Identifier`. */
+  Name,
+  /** An object literal element's name: a name before `:`, `(` or `<`, a reference in a shorthand property. */
+  ElementName,
+}
+
 /** What the scanner saw of the JSDoc comments preceding a token. */
 export const enum JSDocScannerInfo {
   None = 0,
@@ -381,6 +400,11 @@ function appendRange(to: Node[], from: readonly Node[], start: number, end: numb
   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: Node[] = [];
+
 /** Parses `text` as the file `fileName`. The script kind defaults to the one implied by the extension. */
 export function parseSourceFile(fileName: string, text: string, options?: ParseOptions): SourceFile {
   const path = options === undefined ? fileName : options.path;
@@ -491,7 +515,7 @@ export class Parser extends ScannerErrorReporter {
   signatureParameterFlags: ParseFlags;
 
   /** Parses JSDoc comments and, in JavaScript files, reparses their tags. */
-  readonly jsdoc: JSDocParser;
+  jsdoc: JSDocParser;
   /**
    * Returned instead of `undefined` by hot element parsers: a `Node | undefined` result is boxed natively
    * for every node returned.
@@ -554,12 +578,15 @@ export class Parser extends ScannerErrorReporter {
   }
 
   /**
-   * 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(): void {
     this.scanner.setText('');
+    this.scanner.setOnError(undefined);
+    this.jsdoc = releasedParser().jsdoc;
   }
 
   token(): SyntaxKind {
@@ -745,11 +772,11 @@ export class Parser extends ScannerErrorReporter {
   // Nodes
 
   newNodeList(pos: number, end: number, nodes: Node[]): NodeList {
-    return new NodeList(pos, end, nodes);
+    return new NodeList(pos, end, nodes.length === 0 ? emptyListNodes : nodes);
   }
 
   newModifierList(pos: number, end: number, nodes: Node[]): ModifierList {
-    return new ModifierList(pos, end, nodes, modifiersToFlags(nodes));
+    return new ModifierList(pos, end, nodes.length === 0 ? emptyListNodes : nodes, modifiersToFlags(nodes));
   }
 
   finishNode(node: Node, pos: number): Node {
@@ -806,14 +833,10 @@ 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;
   }
 
@@ -829,7 +852,8 @@ export class Parser extends ScannerErrorReporter {
   }
 
   finishSourceFile(result: SourceFile, isDeclarationFile: boolean): void {
-    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);
@@ -847,9 +871,12 @@ 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);
   }
 
@@ -1789,7 +1816,7 @@ export class Parser extends ScannerErrorReporter {
   }
 
   parseIdentifierUnlessAtSemicolon(): Identifier | undefined {
-    return this.canParseSemicolon() ? undefined : this.parseIdentifier();
+    return this.canParseSemicolon() ? undefined : this.parseIdentifier(IdentifierUse.Name);
   }
 
   parseReturnStatement(): Statement {
@@ -2186,7 +2213,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(), IdentifierUse.Name);
       this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
       return id;
     }
@@ -2503,7 +2530,7 @@ export class Parser extends ScannerErrorReporter {
 
   parseInterfaceDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement {
     this.parseExpected(SyntaxKind.InterfaceKeyword);
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     const typeParameters = this.parseTypeParameters();
     const heritageClauses = this.parseHeritageClauses();
     const members = this.parseObjectTypeMembers();
@@ -2519,7 +2546,7 @@ export class Parser extends ScannerErrorReporter {
   parseTypeAliasDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement {
     this.parseExpected(SyntaxKind.TypeKeyword);
     if (this.hasPrecedingLineBreak()) this.parseErrorAtCurrentToken(Diagnostics.Line_break_not_permitted_here);
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     const typeParameters = this.parseTypeParameters();
     this.parseExpected(SyntaxKind.EqualsToken);
     const type =
@@ -2552,7 +2579,7 @@ export class Parser extends ScannerErrorReporter {
   parseEnumDeclaration(pos: number, jsdoc: JSDocScannerInfo, modifiers: ModifierList | undefined): Statement {
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
     this.parseExpected(SyntaxKind.EnumKeyword);
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     let members: NodeList;
     if (this.parseExpected(SyntaxKind.OpenBraceToken)) {
       const saveContextFlags = this.contextFlags;
@@ -2594,7 +2621,7 @@ export class Parser extends ScannerErrorReporter {
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
     if (this.token() === SyntaxKind.GlobalKeyword) {
       // `global` names the global scope augmentation.
-      name = this.parseIdentifier();
+      name = this.parseIdentifier(IdentifierUse.Name);
       keyword = SyntaxKind.GlobalKeyword;
     } else {
       name = this.parseLiteralExpression(true);
@@ -2627,7 +2654,7 @@ export class Parser extends ScannerErrorReporter {
     keyword: SyntaxKind,
   ): Node {
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-    const name = nested ? this.parseIdentifierName() : this.parseIdentifier();
+    const name = nested ? this.parseIdentifierName(IdentifierUse.Name) : this.parseIdentifier(IdentifierUse.Name);
     let body: Node;
     if (this.parseOptional(SyntaxKind.DotToken)) {
       const implicitExport = new Token(SyntaxKind.ExportKeyword);
@@ -2660,7 +2687,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(IdentifierUse.Name) : undefined;
     let phaseModifier = SyntaxKind.Unknown;
     if (
       identifier !== undefined &&
@@ -2670,7 +2697,7 @@ export class Parser extends ScannerErrorReporter {
       (this.isIdentifier() || this.tokenAfterImportDefinitelyProducesImportDeclaration())
     ) {
       phaseModifier = SyntaxKind.TypeKeyword;
-      identifier = this.isIdentifier() ? this.parseIdentifier() : undefined;
+      identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
     } else if (identifier !== undefined && identifier.text === 'defer') {
       const shouldParseAsDeferModifier =
         this.token() === SyntaxKind.FromKeyword
@@ -2678,7 +2705,7 @@ export class Parser extends ScannerErrorReporter {
           : this.token() !== SyntaxKind.CommaToken && this.token() !== SyntaxKind.EqualsToken;
       if (shouldParseAsDeferModifier) {
         phaseModifier = SyntaxKind.DeferKeyword;
-        identifier = this.isIdentifier() ? this.parseIdentifier() : undefined;
+        identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
       }
     }
     if (
@@ -2809,7 +2836,7 @@ export class Parser extends ScannerErrorReporter {
     const pos = this.nodePos();
     this.parseExpected(SyntaxKind.AsteriskToken);
     this.parseExpected(SyntaxKind.AsKeyword);
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     return this.finishNode(new NamespaceImport(name), pos);
   }
 
@@ -2850,9 +2877,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() === SyntaxKind.AsKeyword) {
-        const firstAs = this.parseIdentifierName();
+        const firstAs = this.parseIdentifierName(IdentifierUse.Name);
         if (this.token() === SyntaxKind.AsKeyword) {
-          const secondAs = this.parseIdentifierName();
+          const secondAs = this.parseIdentifierName(IdentifierUse.Name);
           if (this.canParseModuleExportName()) {
             // { type as as something }
             isTypeOnly = true;
@@ -2921,7 +2948,7 @@ export class Parser extends ScannerErrorReporter {
 
   parseModuleExportName(): Node {
     if (this.token() === SyntaxKind.StringLiteral) return this.parseLiteralExpression(false);
-    return this.parseIdentifierName();
+    return this.parseIdentifierName(IdentifierUse.Name);
   }
 
   tryParseImportAttributes(): ImportAttributes | undefined {
@@ -2966,7 +2993,7 @@ export class Parser extends ScannerErrorReporter {
     this.parseExpected(SyntaxKind.AsKeyword);
     this.parseExpected(SyntaxKind.NamespaceKeyword);
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     this.parseSemicolon();
     // Modifiers are kept so the grammar checker can report them.
@@ -3136,7 +3163,7 @@ export class Parser extends ScannerErrorReporter {
 
   parseTypeParameterOfInferType(): TypeParameterDeclaration {
     const pos = this.nodePos();
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     const constraint = this.tryParseConstraintOfInferType();
     const result = new TypeParameterDeclaration(undefined, name, constraint, undefined, undefined);
     this.finishNode(result, pos);
@@ -3342,11 +3369,16 @@ export class Parser extends ScannerErrorReporter {
     return this.parseEntityName(true, Diagnostics.Type_expected);
   }
 
-  parseEntityName(allowReservedWords: boolean, diagnosticMessage: DiagnosticMessage | undefined): EntityName {
+  /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
+  parseEntityName(
+    allowReservedWords: boolean,
+    diagnosticMessage: DiagnosticMessage | undefined,
+    use: IdentifierUse = IdentifierUse.Name,
+  ): EntityName {
     const pos = this.nodePos();
     let entity: Node = allowReservedWords
-      ? this.parseIdentifierNameWithDiagnostic(diagnosticMessage)
-      : this.parseIdentifierWithDiagnostic(diagnosticMessage, undefined);
+      ? this.parseIdentifierNameWithDiagnostic(diagnosticMessage, use)
+      : this.parseIdentifierWithDiagnostic(diagnosticMessage, undefined, use);
     while (this.parseOptional(SyntaxKind.DotToken)) {
       // A JSDoc-style generic; the checker reports the gap between the name and the type arguments.
       if (this.token() === SyntaxKind.LessThanToken) break;
@@ -3382,19 +3414,19 @@ 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(), Diagnostics.Identifier_expected);
-      return this.createMissingIdentifier();
+      return this.createMissingIdentifier(IdentifierUse.Name);
     }
     if (this.token() === SyntaxKind.PrivateIdentifier) {
       this.parsePrivateIdentifier();
       this.parseErrorAt(this.nodePos(), this.nodePos(), Diagnostics.Identifier_expected);
-      return this.createMissingIdentifier();
+      return this.createMissingIdentifier(IdentifierUse.Name);
     }
     if (allowIdentifierNames) {
-      if (allowUnicodeEscapeSequenceInIdentifierName) return this.parseIdentifierName();
-      return this.parseIdentifierNameErrorOnUnicodeEscapeSequence();
+      if (allowUnicodeEscapeSequenceInIdentifierName) return this.parseIdentifierName(IdentifierUse.Name);
+      return this.parseIdentifierNameErrorOnUnicodeEscapeSequence(IdentifierUse.Name);
     }
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-    const id = this.parseIdentifier();
+    const id = this.parseIdentifier(IdentifierUse.Name);
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     return id;
   }
@@ -3408,14 +3440,26 @@ export class Parser extends ScannerErrorReporter {
     );
   }
 
-  newIdentifier(text: string): Identifier {
+  /**
+   * 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: string, use: IdentifierUse = IdentifierUse.Reference): Identifier {
     this.identifierCount++;
     if (text === 'await') this.statementHasAwaitIdentifier = true;
-    return new Identifier(text);
+    if (use === IdentifierUse.Name || (use === IdentifierUse.ElementName && this.isElementNameEnd()))
+      return new Identifier(text);
+    return new ReferenceIdentifier(text);
+  }
+
+  /** Whether the current token ends an object literal element name that is not a shorthand property. */
+  isElementNameEnd(): boolean {
+    const token = this.token();
+    return token === SyntaxKind.ColonToken || token === SyntaxKind.OpenParenToken || token === SyntaxKind.LessThanToken;
   }
 
-  createMissingIdentifier(): Identifier {
-    const result = this.newIdentifier('');
+  createMissingIdentifier(use: IdentifierUse = IdentifierUse.Reference): Identifier {
+    const result = this.newIdentifier('', use);
     this.finishNode(result, this.nodePos());
     return result;
   }
@@ -3516,7 +3560,7 @@ export class Parser extends ScannerErrorReporter {
   parseImportAttribute(): Node {
     const pos = this.nodePos();
     let name: Node | undefined;
-    if (tokenIsIdentifierOrKeyword(this.token())) name = this.parseIdentifierName();
+    if (tokenIsIdentifierOrKeyword(this.token())) name = this.parseIdentifierName(IdentifierUse.Name);
     else if (this.token() === SyntaxKind.StringLiteral) name = this.parseLiteralExpression(false);
     if (name !== undefined) this.parseExpected(SyntaxKind.ColonToken);
     else this.parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
@@ -3545,7 +3589,7 @@ export class Parser extends ScannerErrorReporter {
   parseTypeQuery(): TypeNode {
     const pos = this.nodePos();
     this.parseExpected(SyntaxKind.TypeOfKeyword);
-    const entityName = this.parseEntityName(true, undefined);
+    const entityName = this.parseEntityName(true, undefined, 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);
@@ -3588,7 +3632,7 @@ export class Parser extends ScannerErrorReporter {
 
   parseMappedTypeParameter(): TypeParameterDeclaration {
     const pos = this.nodePos();
-    const name = this.parseIdentifierName();
+    const name = this.parseIdentifierName(IdentifierUse.Name);
     this.parseExpected(SyntaxKind.InKeyword);
     const type = this.parseType();
     const result = new TypeParameterDeclaration(undefined, name, type, undefined, undefined);
@@ -3641,7 +3685,7 @@ export class Parser extends ScannerErrorReporter {
   parseTypeParameter(): Node {
     const pos = this.nodePos();
     const modifiers = this.parseModifiersEx(false, true, false);
-    const name = this.parseIdentifier();
+    const name = this.parseIdentifier(IdentifierUse.Name);
     let constraint: TypeNode | undefined;
     let expression: Expression | undefined;
     if (this.parseOptional(SyntaxKind.ExtendsKeyword)) {
@@ -3700,7 +3744,7 @@ export class Parser extends ScannerErrorReporter {
       const result = new ParameterDeclaration(
         modifiers,
         undefined,
-        this.createIdentifier(true),
+        this.createIdentifier(true, IdentifierUse.Name),
         undefined,
         this.parseTypeAnnotation(),
         undefined,
@@ -3780,7 +3824,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(IdentifierUse.Name);
       if (this.token() === SyntaxKind.IsKeyword && !this.hasPrecedingLineBreak()) {
         this.endSpeculation(state);
         this.nextToken();
@@ -3819,20 +3863,20 @@ export class Parser extends ScannerErrorReporter {
     return result;
   }
 
-  parsePropertyName(): Node {
+  parsePropertyName(use: IdentifierUse = IdentifierUse.Name): Node {
     const saveHasAwaitIdentifier = this.statementHasAwaitIdentifier;
-    const prop = this.parsePropertyNameWorker(true);
+    const prop = this.parsePropertyNameWorker(true, use);
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     return prop;
   }
 
-  parsePropertyNameWorker(allowComputedPropertyNames: boolean): Node {
+  parsePropertyNameWorker(allowComputedPropertyNames: boolean, use: IdentifierUse = IdentifierUse.Name): Node {
     const token = this.token();
     if (token === SyntaxKind.StringLiteral || token === SyntaxKind.NumericLiteral || token === SyntaxKind.BigIntLiteral)
       return this.parseLiteralExpression(true);
     if (allowComputedPropertyNames && token === SyntaxKind.OpenBracketToken) return this.parseComputedPropertyName();
     if (token === SyntaxKind.PrivateIdentifier) return this.parsePrivateIdentifier();
-    return this.parseIdentifierName();
+    return this.parseIdentifierName(use);
   }
 
   parseComputedPropertyName(): Node {
@@ -3944,7 +3988,7 @@ export class Parser extends ScannerErrorReporter {
       const pos = this.nodePos();
       const jsdoc = this.jsdocScannerInfo();
       const dotDotDotToken = this.parseOptionalToken(SyntaxKind.DotDotDotToken);
-      const name = this.parseIdentifierName();
+      const name = this.parseIdentifierName(IdentifierUse.Name);
       const questionToken = this.parseOptionalToken(SyntaxKind.QuestionToken);
       this.parseExpected(SyntaxKind.ColonToken);
       const type = this.parseTupleElementType();
@@ -3980,7 +4024,7 @@ export class Parser extends ScannerErrorReporter {
     const pos = this.nodePos();
     const assertsModifier = this.parseExpectedToken(SyntaxKind.AssertsKeyword);
     const parameterName: Node =
-      this.token() === SyntaxKind.ThisKeyword ? this.parseThisTypeNode() : this.parseIdentifier();
+      this.token() === SyntaxKind.ThisKeyword ? this.parseThisTypeNode() : this.parseIdentifier(IdentifierUse.Name);
     const type = this.parseOptional(SyntaxKind.IsKeyword) ? this.parseType() : undefined;
     return this.finishNode(new TypePredicateNode(assertsModifier, parameterName, type), pos);
   }
@@ -5092,11 +5136,11 @@ export class Parser extends ScannerErrorReporter {
   parseJsxAttributeName(): Node {
     const pos = this.nodePos();
     this.scanJsxIdentifier();
-    const attrName = this.parseIdentifierNameErrorOnUnicodeEscapeSequence();
+    const attrName = this.parseIdentifierNameErrorOnUnicodeEscapeSequence(IdentifierUse.Name);
     if (this.parseOptional(SyntaxKind.ColonToken)) {
       this.scanJsxIdentifier();
       return this.finishNode(
-        new JsxNamespacedName(attrName, this.parseIdentifierNameErrorOnUnicodeEscapeSequence()),
+        new JsxNamespacedName(attrName, this.parseIdentifierNameErrorOnUnicodeEscapeSequence(IdentifierUse.Name)),
         pos,
       );
     }
@@ -5227,7 +5271,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(IdentifierUse.Name);
         expression = this.finishNode(new MetaProperty(SyntaxKind.ImportKeyword, name), pos);
         if (name.text === 'defer') {
           if (this.token() === SyntaxKind.OpenParenToken || this.token() === SyntaxKind.LessThanToken)
@@ -5493,12 +5537,13 @@ export class Parser extends ScannerErrorReporter {
         const isOptionalChain = questionDotToken !== undefined || this.tryReparseOptionalChain(expression);
         expression = this.checkJSSyntax(
           this.finishNode(
-            new CallExpression(
+            newCallExpression(
               expression,
               questionDotToken,
               typeArguments,
               argumentList,
               isOptionalChain ? NodeFlags.OptionalChain : NodeFlags.None,
+              (this.contextFlags & NodeFlags.JavaScriptFile) !== 0,
             ),
             pos,
           ),
@@ -5705,7 +5750,7 @@ export class Parser extends ScannerErrorReporter {
       return this.parseAccessorDeclaration(pos, jsdoc, modifiers, SyntaxKind.SetAccessor, ParseFlags.None);
     const asteriskToken = this.parseOptionalToken(SyntaxKind.AsteriskToken);
     const tokenIsIdentifier = this.isIdentifier();
-    const name = this.parsePropertyName();
+    const name = this.parsePropertyName(IdentifierUse.ElementName);
     // The grammar checker reports optional property assignments, definite assignment assertions,
     // decorators and modifiers.
     let postfixToken = this.parseOptionalToken(SyntaxKind.QuestionToken);
@@ -5726,7 +5771,14 @@ export class Parser extends ScannerErrorReporter {
     } else {
       this.parseExpected(SyntaxKind.ColonToken);
       const initializer = this.parseAssignmentExpressionOrHigherAllowIn();
-      node = new PropertyAssignment(modifiers, name, postfixToken, undefined, initializer);
+      node = newPropertyAssignment(
+        modifiers,
+        name,
+        postfixToken,
+        undefined,
+        initializer,
+        (this.contextFlags & NodeFlags.JavaScriptFile) !== 0,
+      );
     }
     return this.finishWithJSDoc(node, pos, jsdoc);
   }
@@ -5788,7 +5840,7 @@ export class Parser extends ScannerErrorReporter {
     const pos = this.nodePos();
     this.parseExpected(SyntaxKind.NewKeyword);
     if (this.parseOptional(SyntaxKind.DotToken)) {
-      const name = this.parseIdentifierName();
+      const name = this.parseIdentifierName(IdentifierUse.Name);
       return this.finishNode(new MetaProperty(SyntaxKind.NewKeyword, name), pos);
     }
     const expressionPos = this.nodePos();
@@ -5847,10 +5899,10 @@ export class Parser extends ScannerErrorReporter {
 
   // Identifiers
 
-  parseIdentifierNameErrorOnUnicodeEscapeSequence(): Identifier {
+  parseIdentifierNameErrorOnUnicodeEscapeSequence(use: IdentifierUse = IdentifierUse.Reference): Identifier {
     if (this.scanner.hasUnicodeEscape() || this.scanner.hasExtendedUnicodeEscape())
       this.parseErrorAtCurrentToken(Diagnostics.Unicode_escape_sequence_cannot_appear_here);
-    return this.createIdentifier(tokenIsIdentifierOrKeyword(this.token()));
+    return this.createIdentifier(tokenIsIdentifierOrKeyword(this.token()), use);
   }
 
   parseBindingIdentifier(): Identifier {
@@ -5863,42 +5915,54 @@ export class Parser extends ScannerErrorReporter {
       this.isBindingIdentifier(),
       undefined,
       privateIdentifierDiagnosticMessage,
+      IdentifierUse.Name,
     );
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     return id;
   }
 
-  parseIdentifierName(): Identifier {
-    return this.parseIdentifierNameWithDiagnostic(undefined);
+  parseIdentifierName(use: IdentifierUse = IdentifierUse.Reference): Identifier {
+    return this.parseIdentifierNameWithDiagnostic(undefined, use);
   }
 
-  parseIdentifierNameWithDiagnostic(diagnosticMessage: DiagnosticMessage | undefined): Identifier {
-    return this.createIdentifierWithDiagnostic(tokenIsIdentifierOrKeyword(this.token()), diagnosticMessage, undefined);
+  parseIdentifierNameWithDiagnostic(
+    diagnosticMessage: DiagnosticMessage | undefined,
+    use: IdentifierUse = IdentifierUse.Reference,
+  ): Identifier {
+    return this.createIdentifierWithDiagnostic(
+      tokenIsIdentifierOrKeyword(this.token()),
+      diagnosticMessage,
+      undefined,
+      use,
+    );
   }
 
-  parseIdentifier(): Identifier {
-    return this.parseIdentifierWithDiagnostic(undefined, undefined);
+  parseIdentifier(use: IdentifierUse = IdentifierUse.Reference): Identifier {
+    return this.parseIdentifierWithDiagnostic(undefined, undefined, use);
   }
 
   parseIdentifierWithDiagnostic(
     diagnosticMessage: DiagnosticMessage | undefined,
     privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined,
+    use: IdentifierUse = IdentifierUse.Reference,
   ): Identifier {
     return this.createIdentifierWithDiagnostic(
       this.isIdentifier(),
       diagnosticMessage,
       privateIdentifierDiagnosticMessage,
+      use,
     );
   }
 
-  createIdentifier(isIdentifier: boolean): Identifier {
-    return this.createIdentifierWithDiagnostic(isIdentifier, undefined, undefined);
+  createIdentifier(isIdentifier: boolean, use: IdentifierUse = IdentifierUse.Reference): Identifier {
+    return this.createIdentifierWithDiagnostic(isIdentifier, undefined, undefined, use);
   }
 
   createIdentifierWithDiagnostic(
     isIdentifier: boolean,
     diagnosticMessage: DiagnosticMessage | undefined,
     privateIdentifierDiagnosticMessage: DiagnosticMessage | undefined,
+    use: IdentifierUse = IdentifierUse.Reference,
   ): Identifier {
     if (isIdentifier) {
       const pos = this.scanner.hasPrecedingJSDocLeadingAsterisks() ? this.scanner.getTokenStart() : this.nodePos();
@@ -5906,7 +5970,7 @@ export class Parser extends ScannerErrorReporter {
       const record = this.scanner.recordIdentifierValue(text);
       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;
     }
@@ -5916,7 +5980,7 @@ export class Parser extends ScannerErrorReporter {
           ? privateIdentifierDiagnosticMessage
           : 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.
@@ -5944,7 +6008,7 @@ export class Parser extends ScannerErrorReporter {
     } else {
       this.parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
     }
-    return this.createMissingIdentifier();
+    return this.createMissingIdentifier(use);
   }
 
   internIdentifier(text: string): string {
@@ -6763,9 +6827,9 @@ export class Parser extends ScannerErrorReporter {
 
   processPragmasIntoFields(file: SourceFile): void {
     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': {
@@ -6784,15 +6848,20 @@ export class Parser extends ScannerErrorReporter {
               resolutionMode !== undefined
                 ? this.parseResolutionMode(resolutionMode.value, resolutionMode.pos, resolutionMode.end)
                 : ModuleKind.None;
-            file.typeReferenceDirectives.push(
+            file.typeReferenceDirectives = appendToList(
+              file.typeReferenceDirectives,
               new FileReference(types.pos, types.end, types.value, parsed, isPreserved),
             );
           } else if (lib !== undefined) {
-            file.libReferenceDirectives.push(
+            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, Diagnostics.Invalid_reference_directive_syntax);
           }
@@ -6934,6 +7003,17 @@ export function forgetLazyJSDocFile(): void {
 
 const viableKeywordSuggestions = getViableKeywordSuggestions();
 
+// A parser whose JSDoc parser released parsers keep (`Parser.release`), created on first use.
+let releasedParserValue: Parser | undefined;
+function releasedParser(): Parser {
+  let parser = releasedParserValue;
+  if (parser === undefined) {
+    parser = new Parser('/', '/', '', ScriptKind.TS, new ExternalModuleIndicatorOptions(false, false));
+    releasedParserValue = parser;
+  }
+  return parser;
+}
+
 function getSpaceSuggestion(expressionText: string): string {
   for (const keyword of viableKeywordSuggestions)
     if (expressionText.length > keyword.length + 2 && expressionText.startsWith(keyword))
@@ -6992,8 +7072,8 @@ function typeHasBlockingError(node: TypeNode | undefined): boolean {
   return node !== undefined && typeHasArrowFunctionBlockingParseError(node);
 }
 
-function attachFileToDiagnostics(diagnostics: Diagnostic[], file: SourceFile): Diagnostic[] {
-  if (diagnostics.length === 0) return diagnostics;
+function attachFileToDiagnostics(diagnostics: Diagnostic[], file: SourceFile): readonly Diagnostic[] {
+  if (diagnostics.length === 0) return emptyDiagnostics;
   const diagnosticFile = file.diagnosticFile();
   for (const d of diagnostics) {
     d.file = diagnosticFile;
@@ -7304,12 +7384,12 @@ function nextTokenIsNotColon(p: Parser): boolean {
 
 // Pragmas
 
-function getCommentPragmas(sourceText: string): Pragma[] {
-  const pragmas: Pragma[] = [];
+function getCommentPragmas(sourceText: string): readonly Pragma[] {
   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: Pragma[] = [];
+  for (const range of ranges) extractPragmas(range, sourceText.substring(range.pos, range.end), pragmas);
+  return pragmas.length === 0 ? emptyPragmas : pragmas;
 }
 
 function extractPragmas(range: CommentRange, text: string, pragmas: Pragma[]): void {
@@ -7478,9 +7558,9 @@ function collectModuleReferences(file: SourceFile, node: Statement, inAmbientMod
   ) {
     const nameText = getText((node as ModuleDeclaration).name);
     if (file.externalModuleIndicator !== undefined || (inAmbientModule && !isExternalModuleNameRelative(nameText))) {
-      file.moduleAugmentations.push((node as ModuleDeclaration).name);
+      file.moduleAugmentations = appendToList(file.moduleAugmentations, (node as ModuleDeclaration).name);
     } else if (!inAmbientModule) {
-      file.ambientModuleNames.push(nameText);
+      file.ambientModuleNames = appendToList(file.ambientModuleNames, nameText);
       const body = (node as ModuleDeclaration).body;
       if (body !== undefined) {
         const statements = getStatements(body);