tsc-ts 0.0.10 → 0.1.1

package/src/compiler/parallel-emit.ts

@@ -15,12 +15,12 @@
  * thread's checker finds every diagnostic but those of declaration emit.
  */
 import type { Worker } from 'node:worker_threads';
-import { availableParallelism } from 'node:os';
 import { publish } from '@scriptc/threads';
 import { lastNodeIdValue, type SourceFile } from './ast.js';
 import { JavaScriptEmitter, type OutputWriter } from './compile-program.js';
 import type { Diagnostic, DiagnosticFile } from './diagnostics.js';
 import { EmitOnly, EmitResult, sourceFileMayBeEmitted } from './emitter.js';
+import { availableCpus } from './cgroup.js';
 import {
   CheckerResult,
   packResult,
@@ -78,7 +78,7 @@ export function emitThreads(
   emitKinds: readonly number[] | undefined = undefined,
 ): number {
   if (parallelEmit.spawn === undefined || singleThreaded === true) return 0;
-  const cpus = availableParallelism();
+  const cpus = availableCpus();
   if (cpus < 2) return 0;
   const files = program.getSourceFiles();
   let text = 0;
@@ -220,7 +220,7 @@ const maxDeclarationThreadCheckers = 8;
  * from 1 to 8 checkers, about even at 12, and 32-38% slower at 16. It also needs a CPU of its own.
  */
 export function declarationThreadPays(checkers: number): boolean {
-  return checkers <= maxDeclarationThreadCheckers && checkers < availableParallelism();
+  return checkers <= maxDeclarationThreadCheckers && checkers < availableCpus();
 }
 
 /**
@@ -247,7 +247,7 @@ export function startDeclarationThread(
     let declarations: boolean;
     if (emitKinds === undefined) declarations = sourceFileMayBeEmitted(files[i]!, options);
     else declarations = emitKinds[i] === EmitOnly.All || emitKinds[i] === EmitOnly.Dts;
-    kinds.push(declarations ? EmitOnly.Dts : -1);
+    kinds.push(declarations ? (emitsJavaScript(program, emitKinds, i) ? EmitOnly.DtsAfterJs : EmitOnly.Dts) : -1);
     results.push(undefined);
   }
   for (const i of metadata) kinds[i] = emitKinds === undefined ? EmitOnly.All : emitKinds[i]!;

package/src/compiler/parser.ts

@@ -1,4 +1,4 @@
-// The TypeScript/JavaScript/JSX/JSON parser, a port of TypeScript 7.0.2's (tsgo) parser with its
+// The TypeScript/JavaScript/JSX/JSON parser, a port of TypeScript 7.1's (tsgo) parser with its
 // error recovery, parse diagnostics and JavaScript-specific reparsing.
 //
 // ```ts
@@ -202,6 +202,7 @@ import {
   newCallExpression,
   newPropertyAssignment,
 } from './ast.js';
+import { IdentifierName } from './identifier-name.js';
 import {
   OperatorPrecedence,
   canHaveDecorators,
@@ -218,6 +219,7 @@ import {
   isFunctionLike,
   isImportCall,
   isImportMeta,
+  isImportPhaseMetaProperty,
   isInJSFile,
   isKeyword,
   isKeywordOrPunctuation,
@@ -293,7 +295,11 @@ const enum ListElement {
   ObjectBindingElement,
   ClassElement,
   HeritageClause,
+  /** A heritage clause of an interface declaration. */
+  InterfaceHeritageClause,
   ExpressionWithTypeArguments,
+  /** An element of a type heritage clause: `implements` of a class, `extends` of an interface. */
+  TypeHeritageClauseElement,
   EnumMember,
   ImportSpecifier,
   ExportSpecifier,
@@ -340,6 +346,18 @@ export const enum JSDocScannerInfo {
 
 const noArgs: readonly string[] = [];
 
+/** Whether `operator` binds before an operator of `currentPrecedence`: at equal precedence, only the right-associative `**`. */
+function shouldConsumeBinaryOperator(
+  operator: SyntaxKind,
+  operatorPrecedence: OperatorPrecedence,
+  currentPrecedence: OperatorPrecedence,
+): boolean {
+  return (
+    operatorPrecedence > currentPrecedence ||
+    (operatorPrecedence === currentPrecedence && operator === SyntaxKind.AsteriskAsteriskToken)
+  );
+}
+
 /** Parser state saved by `mark` for speculative parsing. */
 export class ParserState extends ScannerState {
   contextFlags: NodeFlags;
@@ -430,7 +448,7 @@ export function parseSourceFile(fileName: string, text: string, options?: ParseO
 export function parseIsolatedEntityName(text: string): EntityName | undefined {
   const p = new Parser('/', '/', text, ScriptKind.JS, new ExternalModuleIndicatorOptions(false, false));
   p.nextToken();
-  const entityName = p.parseEntityName(true, undefined);
+  const entityName = p.parseEntityName(true, false, undefined);
   return p.token() === SyntaxKind.EndOfFile && p.diagnostics.length === 0 ? entityName : undefined;
 }
 
@@ -981,9 +999,13 @@ export class Parser extends ScannerErrorReporter {
       case ListElement.ClassElement:
         return this.parseClassElement();
       case ListElement.HeritageClause:
-        return this.parseHeritageClause();
+        return this.parseHeritageClause(false);
+      case ListElement.InterfaceHeritageClause:
+        return this.parseHeritageClause(true);
       case ListElement.ExpressionWithTypeArguments:
         return this.parseExpressionWithTypeArguments();
+      case ListElement.TypeHeritageClauseElement:
+        return this.parseTypeHeritageClauseElement();
       case ListElement.EnumMember:
         return this.parseEnumMember();
       case ListElement.ImportSpecifier:
@@ -2204,9 +2226,18 @@ export class Parser extends ScannerErrorReporter {
     // The name isn't parsed in an await context; the checker reports `await` names.
     const name = this.parseNameOfClassDeclarationOrExpression();
     const typeParameters = this.parseTypeParameters();
-    if (modifiers !== undefined && hasModifierOfKind(modifiers, SyntaxKind.ExportKeyword))
+    // An exported class at the top level of a module, not one nested in a block or a namespace, has its
+    // heritage clauses and members parsed in an await context.
+    if (
+      modifiers !== undefined &&
+      (this.parsingContexts & (1 << ParsingContext.SourceElements)) !== 0 &&
+      (this.parsingContexts &
+        ((1 << ParsingContext.BlockStatements) | (1 << ParsingContext.SwitchClauseStatements))) ===
+        0 &&
+      hasModifierOfKind(modifiers, SyntaxKind.ExportKeyword)
+    )
       this.setContextFlags(NodeFlags.AwaitContext, true);
-    const heritageClauses = this.parseHeritageClauses();
+    const heritageClauses = this.parseHeritageClauses(false);
     let members: NodeList;
     if (this.parseExpected(SyntaxKind.OpenBraceToken)) {
       members = this.parseList(ParsingContext.ClassMembers, ListElement.ClassElement);
@@ -2248,23 +2279,47 @@ export class Parser extends ScannerErrorReporter {
     return this.token() === SyntaxKind.ImplementsKeyword && this.lookAhead(nextTokenIsIdentifierOrKeyword);
   }
 
-  parseHeritageClauses(): NodeList | undefined {
+  parseHeritageClauses(isInterface: boolean): NodeList | undefined {
     return this.isHeritageClause()
-      ? this.parseList(ParsingContext.HeritageClauses, ListElement.HeritageClause)
+      ? this.parseList(
+          ParsingContext.HeritageClauses,
+          isInterface ? ListElement.InterfaceHeritageClause : ListElement.HeritageClause,
+        )
       : undefined;
   }
 
-  parseHeritageClause(): Node {
+  parseHeritageClause(isInterface: boolean): Node {
     const pos = this.nodePos();
     const kind = this.token();
     this.nextToken();
+    // A class's `implements` and an interface's `extends` name types: their elements are type references.
+    const isTypeClause = isInterface ? kind === SyntaxKind.ExtendsKeyword : kind === SyntaxKind.ImplementsKeyword;
     const types = this.parseDelimitedList(
       ParsingContext.HeritageClauseElement,
-      ListElement.ExpressionWithTypeArguments,
+      isTypeClause ? ListElement.TypeHeritageClauseElement : ListElement.ExpressionWithTypeArguments,
     )!;
     return this.checkJSSyntax(this.finishNode(new HeritageClause(kind, types), pos));
   }
 
+  /** A type reference when the element is an entity name with optional type arguments, otherwise the
+   * `ExpressionWithTypeArguments`, which the checker reports. */
+  parseTypeHeritageClauseElement(): Node {
+    const pos = this.nodePos();
+    const element = this.parseExpressionWithTypeArguments() as ExpressionWithTypeArguments;
+    if (!isValidHeritageTypeReferenceExpression(element.expression)) return element;
+    const typeName = this.convertEntityNameExpressionToEntityName(element.expression);
+    return this.finishNode(new TypeReferenceNode(typeName, element.typeArguments), pos);
+  }
+
+  /** The `QualifiedName` chain for an identifier or a chain of property accesses, spanning the same text. */
+  convertEntityNameExpressionToEntityName(node: Node): Node {
+    if (node instanceof Identifier) return node;
+    const access = node as PropertyAccessExpression;
+    // The name can be a private name, as upstream's.
+    const result = new QualifiedName(this.convertEntityNameExpressionToEntityName(access.expression), access.name);
+    return this.finishNodeWithEnd(result, node.pos, node.end);
+  }
+
   parseExpressionWithTypeArguments(): Node {
     const pos = this.nodePos();
     const expression = this.parseLeftHandSideExpressionOrHigher();
@@ -2556,7 +2611,7 @@ export class Parser extends ScannerErrorReporter {
     this.parseExpected(SyntaxKind.InterfaceKeyword);
     const name = this.parseIdentifier(IdentifierUse.Name);
     const typeParameters = this.parseTypeParameters();
-    const heritageClauses = this.parseHeritageClauses();
+    const heritageClauses = this.parseHeritageClauses(true);
     const members = this.parseObjectTypeMembers();
     const result = this.finishWithJSDoc(
       new InterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members),
@@ -2650,10 +2705,15 @@ export class Parser extends ScannerErrorReporter {
     } else {
       name = this.parseLiteralExpression(true);
     }
+    // `declare module "*.ext" with { type: "..." }`: the import attributes the module matches.
+    const attributes =
+      keyword === SyntaxKind.ModuleKeyword && this.parseOptional(SyntaxKind.WithKeyword)
+        ? (this.parseTypeLiteral() as TypeLiteralNode)
+        : undefined;
     let body: Node | undefined;
     if (this.token() === SyntaxKind.OpenBraceToken) body = this.parseModuleBlock();
     else this.parseSemicolon();
-    const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, body), pos, jsdoc);
+    const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, attributes, body), pos, jsdoc);
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     return result;
   }
@@ -2696,7 +2756,7 @@ export class Parser extends ScannerErrorReporter {
     } else {
       body = this.parseModuleBlock();
     }
-    const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, body), pos, jsdoc);
+    const result = this.finishWithJSDoc(new ModuleDeclaration(modifiers, keyword, name, undefined, body), pos, jsdoc);
     this.checkJSSyntax(result);
     this.statementHasAwaitIdentifier = saveHasAwaitIdentifier;
     return result;
@@ -2711,6 +2771,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;
+    const phaseModifierCandidate = this.currentImportPhaseModifier();
     let identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
     let phaseModifier = SyntaxKind.Unknown;
     if (
@@ -2722,20 +2783,19 @@ export class Parser extends ScannerErrorReporter {
     ) {
       phaseModifier = SyntaxKind.TypeKeyword;
       identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
-    } else if (identifier !== undefined && identifier.text === 'defer') {
-      const shouldParseAsDeferModifier =
-        this.token() === SyntaxKind.FromKeyword
-          ? !this.lookAhead(nextTokenIsTokenStringLiteral)
-          : this.token() !== SyntaxKind.CommaToken && this.token() !== SyntaxKind.EqualsToken;
-      if (shouldParseAsDeferModifier) {
-        phaseModifier = SyntaxKind.DeferKeyword;
-        identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
-      }
+    } else if (
+      identifier !== undefined &&
+      phaseModifierCandidate !== SyntaxKind.Unknown &&
+      this.shouldParseImportPhaseModifier()
+    ) {
+      phaseModifier = phaseModifierCandidate;
+      identifier = this.isIdentifier() ? this.parseIdentifier(IdentifierUse.Name) : undefined;
     }
     if (
       identifier !== undefined &&
       !this.tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() &&
-      phaseModifier !== SyntaxKind.DeferKeyword
+      phaseModifier !== SyntaxKind.DeferKeyword &&
+      phaseModifier !== SyntaxKind.SourceKeyword
     ) {
       const importEquals = this.checkJSSyntax(
         this.parseImportEqualsDeclaration(pos, jsdoc, modifiers, identifier, phaseModifier === SyntaxKind.TypeKeyword),
@@ -2763,6 +2823,30 @@ export class Parser extends ScannerErrorReporter {
     return this.token() === SyntaxKind.AsteriskToken || this.token() === SyntaxKind.OpenBraceToken;
   }
 
+  /** In `import defer ___` or `import source ___`, whether `defer` or `source` is a phase modifier rather than the
+   * default import's name. */
+  shouldParseImportPhaseModifier(): boolean {
+    switch (this.token()) {
+      case SyntaxKind.CommaToken:
+      case SyntaxKind.EqualsToken:
+        return false;
+      case SyntaxKind.FromKeyword:
+        return !this.lookAhead(nextTokenIsTokenStringLiteral);
+    }
+    return true;
+  }
+
+  /** The phase modifier the current token's text spells, written without escapes, or `Unknown`. */
+  currentImportPhaseModifier(): SyntaxKind {
+    switch (this.scanner.getTokenText()) {
+      case 'defer':
+        return SyntaxKind.DeferKeyword;
+      case 'source':
+        return SyntaxKind.SourceKeyword;
+    }
+    return SyntaxKind.Unknown;
+  }
+
   /** In `import id ___`, whether the token makes this an ImportDeclaration rather than ImportEqualsDeclaration. */
   tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration(): boolean {
     return this.token() === SyntaxKind.CommaToken || this.token() === SyntaxKind.FromKeyword;
@@ -2788,7 +2872,7 @@ export class Parser extends ScannerErrorReporter {
   parseModuleReference(): Node {
     if (this.token() === SyntaxKind.RequireKeyword && this.lookAhead(nextTokenIsOpenParen))
       return this.parseExternalModuleReference();
-    return this.parseEntityName(false, undefined);
+    return this.parseEntityName(false, false, undefined);
   }
 
   parseExternalModuleReference(): Node {
@@ -2826,6 +2910,9 @@ export class Parser extends ScannerErrorReporter {
       this.parseExpected(SyntaxKind.FromKeyword);
       return importClause;
     }
+    // A phase modifier without bindings still makes an import clause; the checker reports it.
+    if (phaseModifier === SyntaxKind.DeferKeyword || phaseModifier === SyntaxKind.SourceKeyword)
+      return this.finishNode(new ImportClause(phaseModifier, undefined, undefined), pos) as ImportClause;
     return undefined;
   }
 
@@ -2952,7 +3039,7 @@ export class Parser extends ScannerErrorReporter {
       identifierName = name;
     } else {
       this.parseErrorAt(skipTrivia(this.sourceText, name.pos), name.end, Diagnostics.Identifier_expected);
-      identifierName = this.newIdentifier('');
+      identifierName = this.newIdentifier(new IdentifierName(''));
       this.finishNode(identifierName, name.pos);
     }
     return this.checkJSSyntax(this.finishNode(new ImportSpecifier(isTypeOnly, propertyName, identifierName), pos));
@@ -3391,12 +3478,16 @@ export class Parser extends ScannerErrorReporter {
   }
 
   parseEntityNameOfTypeReference(): EntityName {
-    return this.parseEntityName(true, Diagnostics.Type_expected);
+    return this.parseEntityName(true, false, Diagnostics.Type_expected);
   }
 
-  /** An entity name; `use` is for its first identifier, the qualified names' right sides are names. */
+  /**
+   * An entity name; `use` is for its first identifier, the qualified names' right sides are names.
+   * Only a type query allows private names on the right (`typeof this.#x`).
+   */
   parseEntityName(
     allowReservedWords: boolean,
+    allowPrivateName: boolean,
     diagnosticMessage: DiagnosticMessage | undefined,
     use: IdentifierUse = IdentifierUse.Name,
   ): EntityName {
@@ -3408,7 +3499,7 @@ export class Parser extends ScannerErrorReporter {
       // A JSDoc-style generic; the checker reports the gap between the name and the type arguments.
       if (this.token() === SyntaxKind.LessThanToken) break;
       entity = this.finishNode(
-        new QualifiedName(entity, this.parseRightSideOfDotIdentifier(allowReservedWords, true)),
+        new QualifiedName(entity, this.parseRightSideOfDot(allowReservedWords, allowPrivateName, true)),
         pos,
       );
     }
@@ -3469,12 +3560,12 @@ export class Parser extends ScannerErrorReporter {
    * 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 {
+  newIdentifier(name: IdentifierName, use: IdentifierUse = IdentifierUse.Reference): Identifier {
     this.identifierCount++;
-    if (text === 'await') this.statementHasAwaitIdentifier = true;
+    if (name.text === 'await') this.statementHasAwaitIdentifier = true;
     if (use === IdentifierUse.Name || (use === IdentifierUse.ElementName && this.isElementNameEnd()))
-      return new Identifier(text);
-    return new ReferenceIdentifier(text);
+      return new Identifier(name);
+    return new ReferenceIdentifier(name);
   }
 
   /** Whether the current token ends an object literal element name that is not a shorthand property. */
@@ -3484,7 +3575,7 @@ export class Parser extends ScannerErrorReporter {
   }
 
   createMissingIdentifier(use: IdentifierUse = IdentifierUse.Reference): Identifier {
-    const result = this.newIdentifier('', use);
+    const result = this.newIdentifier(new IdentifierName(''), use);
     this.finishNode(result, this.nodePos());
     return result;
   }
@@ -3614,7 +3705,7 @@ export class Parser extends ScannerErrorReporter {
   parseTypeQuery(): TypeNode {
     const pos = this.nodePos();
     this.parseExpected(SyntaxKind.TypeOfKeyword);
-    const entityName = this.parseEntityName(true, undefined, IdentifierUse.Reference);
+    const entityName = this.parseEntityName(true, 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);
@@ -4736,15 +4827,13 @@ export class Parser extends ScannerErrorReporter {
       // Take a left-associative operator when its precedence is higher than the current one (so
       // `a - b - c` returns `b` as the right operand of the first `-`), and `**` (right
       // associative) when it is at least as high.
-      const consumeCurrentOperator =
-        operator === SyntaxKind.AsteriskAsteriskToken ? newPrecedence >= precedence : newPrecedence > precedence;
-      if (!consumeCurrentOperator) break;
+      if (!shouldConsumeBinaryOperator(operator, newPrecedence, precedence)) break;
       if (operator === SyntaxKind.InKeyword && this.inDisallowInContext()) break;
       if (operator === SyntaxKind.AsKeyword || operator === SyntaxKind.SatisfiesKeyword) {
         // ASI applies before `as`: `var x = foo \n as (Bar)` is a declaration and a call to `as`.
         if (this.hasPrecedingLineBreak()) break;
         this.nextToken();
-        // In `a ## b as T`, stop at a following operator with a higher precedence than `##`: the
+        // In `a ## b as T $$ c`, stop when `$$` would bind before `##` once the `as` is erased: the
         // `as` couldn't be erased without changing the meaning (TypeScript#63527).
         const lastPrecedence =
           lastOperand instanceof BinaryExpression
@@ -4754,7 +4843,8 @@ export class Parser extends ScannerErrorReporter {
           operator === SyntaxKind.SatisfiesKeyword
             ? this.makeSatisfiesExpression(leftOperand, this.parseType())
             : this.makeAsExpression(leftOperand, this.parseType());
-        if (getBinaryOperatorPrecedence(this.reScanGreaterThanToken()) > lastPrecedence) break;
+        const nextOperator = this.reScanGreaterThanToken();
+        if (shouldConsumeBinaryOperator(nextOperator, getBinaryOperatorPrecedence(nextOperator), lastPrecedence)) break;
       } else {
         leftOperand = this.makeBinaryExpression(
           leftOperand,
@@ -4882,7 +4972,7 @@ export class Parser extends ScannerErrorReporter {
         // An unclosed opening element took its parent's closing element: restructure
         // (<div>(...<span>...</div>)) into (<div>(...<span>...</>)</div>). The parent reports it.
         const end = (lastChild as JsxElement).children.end;
-        const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(''), end, end);
+        const missingIdentifier = this.finishNodeWithEnd(this.newIdentifier(new IdentifierName('')), end, end);
         const newClosingElement = new JsxClosingElement(missingIdentifier);
         this.finishNodeWithEnd(newClosingElement, end, end);
         const newLast = new JsxElement(
@@ -5170,8 +5260,9 @@ export class Parser extends ScannerErrorReporter {
     if (this.token() === SyntaxKind.EqualsToken) {
       if (this.scanJsxAttributeValue() === SyntaxKind.StringLiteral) return this.parseLiteralExpression(false);
       if (this.token() === SyntaxKind.OpenBraceToken) return this.parseJsxExpression(true);
+      // An attribute value is a single element: sibling-element recovery must not wrap it in a binary expression.
       if (this.token() === SyntaxKind.LessThanToken)
-        return this.parseJsxElementOrSelfClosingElementOrFragment(true, -1, undefined, false);
+        return this.parseJsxElementOrSelfClosingElementOrFragment(true, -1, undefined, true);
       this.parseErrorAtCurrentToken(Diagnostics.X_or_JSX_element_expected);
     }
     return undefined;
@@ -5290,9 +5381,9 @@ export class Parser extends ScannerErrorReporter {
         // An `import.*` meta property, such as `import.meta`.
         this.nextToken();
         this.nextToken();
-        const name = this.parseIdentifierName(IdentifierUse.Name);
+        const name = this.parseImportMetaPropertyName();
         expression = this.finishNode(new MetaProperty(SyntaxKind.ImportKeyword, name), pos);
-        if (name.text === 'defer') {
+        if (isImportPhaseMetaProperty(expression)) {
           if (this.token() === SyntaxKind.OpenParenToken || this.token() === SyntaxKind.LessThanToken)
             this.sourceFlags |= NodeFlags.PossiblyContainsDynamicImport;
         } else {
@@ -5310,6 +5401,16 @@ export class Parser extends ScannerErrorReporter {
     return this.parseCallExpressionRest(pos, expression);
   }
 
+  /** The name after `import.`; `defer` and `source` written with escapes are reported. */
+  parseImportMetaPropertyName(): Identifier {
+    if (
+      (this.token() === SyntaxKind.DeferKeyword || this.token() === SyntaxKind.SourceKeyword) &&
+      this.currentImportPhaseModifier() === SyntaxKind.Unknown
+    )
+      this.parseErrorAtCurrentToken(Diagnostics.Keywords_cannot_contain_escape_characters);
+    return this.parseIdentifierName(IdentifierUse.Name);
+  }
+
   parseSuperExpression(): Expression {
     const pos = this.nodePos();
     let expression = this.parseKeywordExpression();
@@ -5504,13 +5605,18 @@ export class Parser extends ScannerErrorReporter {
   ): Expression {
     let argumentExpression: Expression;
     if (this.token() === SyntaxKind.CloseBracketToken) {
+      // The missing argument is created before the error, so the error marks the element access.
+      argumentExpression = this.createMissingIdentifier();
       this.parseErrorAt(
         this.nodePos(),
         this.nodePos(),
         Diagnostics.An_element_access_expression_should_take_an_argument,
       );
-      argumentExpression = this.createMissingIdentifier();
     } else {
+      // tsgo creates the missing argument first and drops it when there is one. Finishing that node takes the
+      // error flag of an error before the argument (`i[01]`), so the argument doesn't get it.
+      this.identifierCount++;
+      this.hasParseError = false;
       const argument = this.parseExpressionAllowIn();
       if (
         argument.kind === SyntaxKind.StringLiteral ||
@@ -5986,10 +6092,11 @@ export class Parser extends ScannerErrorReporter {
     if (isIdentifier) {
       const pos = this.scanner.hasPrecedingJSDocLeadingAsterisks() ? this.scanner.getTokenStart() : this.nodePos();
       const text = this.scanner.getIdentifierValue();
+      const name = this.scanner.getIdentifierName();
       const record = this.scanner.recordIdentifierValue(text);
       this.nextTokenWithoutCheck();
       if (record) this.identifierTexts.push(text);
-      const result = this.newIdentifier(text, use);
+      const result = this.newIdentifier(name, use);
       this.finishNode(result, pos);
       return result;
     }
@@ -6794,7 +6901,9 @@ export class Parser extends ScannerErrorReporter {
   }
 
   jsonError(node: Node, message: DiagnosticMessage): void {
-    this.diagnostics.push(new Diagnostic(undefined, skipTrivia(this.sourceText, node.pos), node.end, message, noArgs));
+    // A missing node (a property without a value) keeps its position: trivia after it isn't its own.
+    const pos = nodeIsMissing(node) ? node.pos : skipTrivia(this.sourceText, node.pos);
+    this.diagnostics.push(new Diagnostic(undefined, pos, node.end, message, noArgs));
   }
 
   validateJsonValue(sourceFile: SourceFile, value: Node): void {
@@ -7168,6 +7277,16 @@ function nextTokenIsOpenParen(p: Parser): boolean {
   return p.nextToken() === SyntaxKind.OpenParenToken;
 }
 
+/** An identifier or a chain of property accesses without optional chaining, each name present. */
+function isValidHeritageTypeReferenceExpression(node: Node): boolean {
+  if (node instanceof Identifier) return nodeIsPresent(node);
+  if (!(node instanceof PropertyAccessExpression) || (node.flags & NodeFlags.OptionalChain) !== 0) return false;
+  return (
+    nodeIsPresent((node as PropertyAccessExpression).name) &&
+    isValidHeritageTypeReferenceExpression((node as PropertyAccessExpression).expression)
+  );
+}
+
 function nextTokenIsOpenBrace(p: Parser): boolean {
   return p.nextToken() === SyntaxKind.OpenBraceToken;
 }
@@ -7753,7 +7872,7 @@ export function isNodeCoreModule(moduleName: string): boolean {
 }
 
 // `require('module').builtinModules`, without and with only the `node:` prefix.
-const unprefixedNodeCoreModules = new Set<string>([
+export const unprefixedNodeCoreModules = new Set<string>([
   'assert',
   'assert/strict',
   'async_hooks',
@@ -7810,7 +7929,7 @@ const unprefixedNodeCoreModules = new Set<string>([
   'zlib',
 ]);
 
-const exclusivelyPrefixedNodeCoreModules = new Set<string>([
+export const exclusivelyPrefixedNodeCoreModules = new Set<string>([
   'node:quic',
   'node:sea',
   'node:sqlite',

package/src/compiler/path.ts

@@ -139,6 +139,28 @@ export function isRootedDiskPath(path: string): boolean {
   return getEncodedRootLength(path) > 0;
 }
 
+/**
+ * Whether Windows may resolve `path` over the network: a UNC path (`//server/share`), a Win32 device path
+ * (`//?/…`, `//./…`) or an NT object path (`/??/…`), with either separator. Device and object paths count even
+ * for local volumes, since their `UNC` and `GLOBALROOT` forms reach the network redirector. Accessing one can
+ * make Windows authenticate to an arbitrary host, so such paths are never accessed on any platform.
+ */
+export function isNetworkPath(path: string): boolean {
+  if (path.length < 2 || !isAnyDirectorySeparator(path.charCodeAt(0))) return false;
+  if (isAnyDirectorySeparator(path.charCodeAt(1))) return true;
+  return (
+    path.length >= 3 &&
+    path.charCodeAt(1) === 0x3f &&
+    path.charCodeAt(2) === 0x3f &&
+    (path.length === 3 || isAnyDirectorySeparator(path.charCodeAt(3)))
+  );
+}
+
+/** Whether a path written in a config or on the command line names a network location once resolved. */
+export function isNetworkPathValue(value: string, basePath: string): boolean {
+  return isNetworkPath(getNormalizedAbsolutePath(value, basePath));
+}
+
 export function pathIsAbsolute(path: string): boolean {
   return getEncodedRootLength(path) !== 0;
 }
@@ -370,8 +392,6 @@ function isNonDotDotPrefix(normalized: string, rootLength: number): boolean {
 /** Removes `.`, `..` and duplicate separators, keeping a trailing separator. */
 export function normalizePath(path: string): string {
   path = normalizeSlashes(path);
-  const simple = simpleNormalizePath(path);
-  if (simple !== undefined) return simple;
   const normalized = getNormalizedAbsolutePath(path, '');
   return normalized !== '' && hasTrailingDirectorySeparator(path)
     ? ensureTrailingDirectorySeparator(normalized)

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

@@ -1,6 +1,7 @@
 // Side tables that transforms fill in and the printer reads: original nodes, emit flags,
 // comment and source map ranges, synthesized comments, generated names and emit helpers.
 import {
+  Block,
   ExpressionStatement,
   FunctionDeclaration,
   Identifier,
@@ -599,6 +600,21 @@ export class EmitContext extends NodeFactory {
     return node;
   }
 
+  /** `node` as a function body: a block as it is, an expression as `{ return node; }` with the expression's range. */
+  convertToFunctionBlock(node: Node, multiLine: boolean): Block {
+    if (node instanceof Block) return node as Block;
+    const factory = this.factory;
+    const statement = factory.createReturnStatement(node);
+    statement.pos = node.pos;
+    statement.end = node.end;
+    const block = factory.createBlock([statement], multiLine);
+    block.statements.pos = node.pos;
+    block.statements.end = node.end;
+    block.pos = node.pos;
+    block.end = node.end;
+    return block;
+  }
+
   /** Marks the current variable scope as visiting parameters; returns the previous flags. */
   enterParameters(): number {
     const scope = this.varScopes[this.varScopes.length - 1]!;

package/src/compiler/printer/factory-base.ts

@@ -1831,10 +1831,17 @@ export abstract class NodeFactoryBase {
     modifiers: ModifierList | undefined,
     keyword: SyntaxKind,
     name: ModuleName,
+    attributes: TypeLiteralNode | undefined,
     body: ModuleBody | undefined,
   ): ModuleDeclaration {
-    if (modifiers !== node.modifiers || keyword !== node.keyword || name !== node.name || body !== node.body) {
-      const updated = new ModuleDeclaration(modifiers, keyword, name, body);
+    if (
+      modifiers !== node.modifiers ||
+      keyword !== node.keyword ||
+      name !== node.name ||
+      attributes !== node.attributes ||
+      body !== node.body
+    ) {
+      const updated = new ModuleDeclaration(modifiers, keyword, name, attributes, body);
       this.finishUpdate(updated, node);
       return updated;
     }
@@ -2121,7 +2128,7 @@ export abstract class NodeFactoryBase {
     return node;
   }
 
-  updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName {
+  updateQualifiedName(node: QualifiedName, left: EntityName, right: MemberName): QualifiedName {
     if (left !== node.left || right !== node.right) {
       const updated = new QualifiedName(left, right);
       this.finishUpdate(updated, node);

package/src/compiler/printer/factory.ts

@@ -70,6 +70,7 @@ import {
 } from './helpers.js';
 import { formatGeneratedName, isMemberName, nodeIsSynthesized } from './utilities.js';
 import { OuterExpressionKinds, isOuterExpression, outerExpressionOperand } from '../transformers/utilities.js';
+import { IdentifierName } from '../identifier-name.js';
 
 /**
  * The node factory of an emit context. The context is the factory (`EmitContext` extends it), so the two are one
@@ -108,7 +109,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   }
 
   cloneIdentifier(node: Identifier): Identifier {
-    return this.cloneNode(node, new Identifier(node.text));
+    return this.cloneNode(node, new Identifier(node.identifierName));
   }
 
   createNodeList(nodes: Node[]): NodeList {
@@ -132,7 +133,7 @@ export abstract class NodeFactory extends NodeFactoryBase {
   }
 
   createIdentifier(text: string): Identifier {
-    return this.created(new Identifier(text));
+    return this.created(new Identifier(new IdentifierName(text)));
   }
 
   createKeywordExpression(kind: SyntaxKind): KeywordExpression {
@@ -318,7 +319,10 @@ export abstract class NodeFactory extends NodeFactoryBase {
   createExpressionFromEntityName(node: Node): Node {
     if (node instanceof QualifiedName) {
       const left = this.createExpressionFromEntityName(node.left);
-      const right = this.cloneIdentifier(node.right);
+      const right =
+        node.right instanceof PrivateIdentifier
+          ? this.cloneNode(node.right, new PrivateIdentifier(node.right.text))
+          : this.cloneIdentifier(node.right as Identifier);
       right.pos = node.right.pos;
       right.end = node.right.end;
       right.parent = node.right.parent;