tsc-ts 0.0.5 → 0.0.6

package/src/compiler/parser.ts

@@ -133,6 +133,7 @@ import {
   PropertyDeclaration,
   PropertySignatureDeclaration,
   QualifiedName,
+  ReferenceIdentifier,
   RegularExpressionLiteral,
   RestTypeNode,
   ReturnStatement,
@@ -311,6 +312,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,
@@ -491,7 +502,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 +565,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 {
@@ -806,14 +820,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;
   }
 
@@ -1789,7 +1799,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 +2196,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 +2513,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 +2529,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 +2562,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 +2604,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 +2637,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 +2670,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 +2680,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 +2688,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 +2819,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 +2860,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 +2931,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 +2976,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 +3146,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 +3352,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 +3397,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 +3423,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);
   }
 
-  createMissingIdentifier(): Identifier {
-    const result = this.newIdentifier('');
+  /** 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(use: IdentifierUse = IdentifierUse.Reference): Identifier {
+    const result = this.newIdentifier('', use);
     this.finishNode(result, this.nodePos());
     return result;
   }
@@ -3516,7 +3543,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 +3572,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 +3615,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 +3668,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 +3727,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 +3807,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 +3846,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 +3971,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 +4007,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 +5119,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 +5254,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)
@@ -5705,7 +5732,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);
@@ -5788,7 +5815,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 +5874,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 +5890,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 +5945,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 +5955,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 +5983,7 @@ export class Parser extends ScannerErrorReporter {
     } else {
       this.parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
     }
-    return this.createMissingIdentifier();
+    return this.createMissingIdentifier(use);
   }
 
   internIdentifier(text: string): string {
@@ -6934,6 +6973,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))

package/src/compiler/printer/emit-context.ts

@@ -12,6 +12,7 @@ import {
   VariableDeclaration,
   VariableStatement,
 } from '../ast.js';
+import { ClusteredLinkTable } from '../link-tables.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { EmitFlags, GeneratedIdentifierFlags } from './emit-flags.js';
 import { AutoGenerateInfo } from './auto-generate.js';
@@ -135,8 +136,10 @@ export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
 export class EmitContext extends NodeFactory {
   readonly autoGenerate: Map<Node, AutoGenerateInfo>;
   readonly textSource: Map<Node, Node>;
-  readonly original: Map<Node, Node>;
-  readonly emitNodes: Map<Node, EmitNode>;
+  /** The node each node was made from, by node id. */
+  readonly original: ClusteredLinkTable<Node>;
+  /** The emit data of nodes, by node id. */
+  readonly emitNodes: ClusteredLinkTable<EmitNode>;
   private lastLookup: Node | undefined;
   private lastEmitNode: EmitNode | undefined;
   readonly assignedNames: Map<Node, Node>;
@@ -150,8 +153,8 @@ export class EmitContext extends NodeFactory {
     super();
     this.autoGenerate = new Map<Node, AutoGenerateInfo>();
     this.textSource = new Map<Node, Node>();
-    this.original = new Map<Node, Node>();
-    this.emitNodes = new Map<Node, EmitNode>();
+    this.original = new ClusteredLinkTable<Node>();
+    this.emitNodes = new ClusteredLinkTable<EmitNode>();
     this.lastLookup = undefined;
     this.lastEmitNode = undefined;
     this.assignedNames = new Map<Node, Node>();
@@ -187,7 +190,7 @@ export class EmitContext extends NodeFactory {
     let emitNode = this.lookup(node);
     if (emitNode === undefined) {
       emitNode = new EmitNode();
-      this.emitNodes.set(node, emitNode);
+      this.emitNodes.set(node.id, emitNode);
       this.lastLookup = node;
       this.lastEmitNode = emitNode;
     }
@@ -197,7 +200,7 @@ export class EmitContext extends NodeFactory {
   /** The emit data of `node`. The printer asks for several of a node's in a row, so the last answer is kept. */
   private lookup(node: Node): EmitNode | undefined {
     if (node === this.lastLookup) return this.lastEmitNode;
-    const emitNode = this.emitNodes.get(node);
+    const emitNode = this.emitNodes.get(node.id);
     this.lastLookup = node;
     this.lastEmitNode = emitNode;
     return emitNode;
@@ -210,29 +213,31 @@ export class EmitContext extends NodeFactory {
   }
 
   setOriginalEx(node: Node, original: Node, allowOverwrite: boolean): void {
-    const existing = this.original.get(node);
+    const existing = this.original.get(node.id);
     if (existing === undefined) {
-      this.original.set(node, original);
+      this.original.set(node.id, original);
       const emitNode = this.lookup(original);
       if (emitNode !== undefined) this.emitNode(node).copyFrom(emitNode);
-    } else if (allowOverwrite) this.original.set(node, original);
+    } else if (allowOverwrite) this.original.set(node.id, original);
     else if (existing !== original) throw new Error('Original node already set.');
   }
 
   unsetOriginal(node: Node): boolean {
-    return this.original.delete(node);
+    if (this.original.get(node.id) === undefined) return false;
+    this.original.set(node.id, undefined);
+    return true;
   }
 
   getOriginal(node: Node): Node | undefined {
-    return this.original.get(node);
+    return this.original.get(node.id);
   }
 
   /** The node at the end of the chain of original nodes. */
   mostOriginal(node: Node): Node {
-    let original = this.original.get(node);
+    let original = this.original.get(node.id);
     while (original !== undefined) {
       node = original;
-      original = this.original.get(node);
+      original = this.original.get(node.id);
     }
     return node;
   }
@@ -260,7 +265,7 @@ export class EmitContext extends NodeFactory {
       return name;
     let node = info.node!;
     const id = info.id;
-    let original = this.original.get(node);
+    let original = this.original.get(node.id);
     while (original !== undefined) {
       node = original;
       if (node instanceof Identifier || node instanceof PrivateIdentifier) {
@@ -275,7 +280,7 @@ export class EmitContext extends NodeFactory {
           continue;
         }
       }
-      original = this.original.get(node);
+      original = this.original.get(node.id);
     }
     return node;
   }

package/src/compiler/program-checker.ts

@@ -425,6 +425,8 @@ class Directives {
   private readonly byLine = new Map<number, { pos: number; end: number; kind: CommentDirectiveKind }>();
 
   constructor(readonly file: SourceFile) {
+    // Most files have no directives, and need no line starts.
+    if (file.commentDirectives.length === 0) return;
     const lineStarts = file.diagnosticFile().getLineStarts();
     for (const directive of file.commentDirectives) {
       const line = computeLineOfPosition(lineStarts, directive.pos);

package/src/compiler/program.ts

@@ -152,12 +152,19 @@ export class Program implements OutputPathsHost {
       this.includeProcessor = processed.includeProcessor;
       for (const diagnostic of previous.programDiagnosticsList) this.programDiagnosticsList.push(diagnostic);
       for (const path of previous.emitBlockingPaths) this.emitBlockingPaths.add(path);
-      this.symlinks = previous.symlinks;
+      // The files and include reasons it takes from a program shared with checker threads are immutable, and
+      // so is that program's symlink cache: this one computes its own then (`getSymlinkCache`).
+      this.shared = previous.shared;
+      if (!previous.shared) this.symlinks = previous.symlinks;
+      // The same files are emitted, so the common source directory is the same. Its diagnostics are those
+      // `previous` was created with (`IncludeProcessor.copy`).
+      this.commonSourceDirectoryValue = previous.commonSourceDirectoryValue;
     } else {
       this.processed = (loader ?? new FileLoader(host, commandLine)).load();
       this.includeProcessor = this.processed.includeProcessor;
       this.verifyCompilerOptions();
     }
+    this.includeProcessor.noteProgramCreated();
   }
 
   /**