tsc-ts 0.0.9 → 0.1.0

package/src/compiler/thread-entry.ts

@@ -6,7 +6,7 @@ import { parentPort } from 'node:worker_threads';
 import { publish, sharesPublishedGraphs } from '@scriptc/threads';
 import { reserveNodeIds, shareNodeIds } from './ast.js';
 import type { OutputWriter } from './compile-program.js';
-import { useThreadTextCaches } from './diagnostics.js';
+import { type DiagnosticFormatOptions, formattedReports, useThreadTextCaches } from './diagnostics.js';
 import { compareReferencesOfThread, type ReferenceJob, referenceThreads } from './incremental.js';
 import {
   CheckerResult,
@@ -16,6 +16,7 @@ import {
   parallelCheck,
   recycleFiles,
 } from './parallel-check.js';
+import { emitFromQueue, parallelEmit, postedEmitResult } from './parallel-emit.js';
 import { type LoadMessage, parallelParse } from './parallel-parse.js';
 import type { ParseThread } from './parse-thread.js';
 import { useLazyJSDocTable } from './parser.js';
@@ -23,6 +24,7 @@ import { CheckedProgram } from './program-checker.js';
 import type { Program } from './program.js';
 import { assignSymbolIdsAtCreation, reserveSymbolIds, shareSymbolIds } from './symbol.js';
 import { mark, setTimelineThread } from './timeline.js';
+import { setThreadSharingData, type ThreadSharingData } from './shared-results.js';
 
 /** What threads need from the command line that starts them. */
 export interface ThreadDrivers {
@@ -38,7 +40,7 @@ export interface ThreadDrivers {
 export type ThreadSpawn = (data: ThreadData) => Worker;
 
 /** The `workerData` of a thread of tsc-ts. */
-export type ThreadData = CheckerThreadData | ParseThreadData | ReferenceThreadData;
+export type ThreadData = CheckerThreadData | EmitThreadData | ParseThreadData | ReferenceThreadData;
 
 export interface CheckerThreadData {
   readonly kind: 'check';
@@ -55,6 +57,24 @@ export interface CheckerThreadData {
   readonly emitKinds: number[] | undefined;
   readonly checking: boolean;
   readonly units: number[];
+  /** See `CheckedProgram.globalsInFileDiagnostics`. */
+  readonly globalsInFileDiagnostics: boolean;
+  /** The main thread's report format (`formattedReports`), which the thread formats its diagnostics in. */
+  readonly reportFormat: DiagnosticFormatOptions | undefined;
+  /** TSC_TS_SHARE: what the thread shares results with the other checker threads through. */
+  readonly sharing: ThreadSharingData | undefined;
+}
+
+export interface EmitThreadData {
+  readonly kind: 'emit';
+  /** The shared, published program. */
+  readonly program: Program;
+  readonly index: number;
+  readonly counter: SharedArrayBuffer;
+  readonly files: number[];
+  readonly kinds: number[];
+  readonly nodeIds: number;
+  readonly symbolIds: number;
 }
 
 export interface ParseThreadData {
@@ -88,6 +108,8 @@ export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: r
     emitKinds,
     checking,
     units,
+    globalsInFileDiagnostics,
+    sharing,
   ) =>
     spawn({
       kind: 'check',
@@ -103,8 +125,13 @@ export function startThreads(spawn: ThreadSpawn, drivers: ThreadDrivers, args: r
       emitKinds,
       checking,
       units,
+      globalsInFileDiagnostics,
+      reportFormat: formattedReports.format,
+      sharing,
     });
   if (sharesPublishedGraphs) {
+    parallelEmit.spawn = (program, index, counter, files, kinds, nodeIds, symbolIds) =>
+      spawn({ kind: 'emit', program, index, counter, files, kinds, nodeIds, symbolIds });
     parallelParse.spawn = (configFileName, counter, index) =>
       spawn({ kind: 'parse', configFileName, args, counter, index });
     // The main thread compares the files a reference thread that failed did not.
@@ -123,6 +150,7 @@ export function runThread(data: unknown, drivers: ThreadDrivers): void {
   const kind = (data as { kind: string }).kind;
   if (kind === 'parse') runParseThread(data as ParseThreadData, drivers);
   else if (kind === 'references') runReferenceThread(data as ReferenceThreadData);
+  else if (kind === 'emit') runEmitThread(data as EmitThreadData, drivers);
   else runCheckerThread(data as CheckerThreadData, drivers);
 }
 
@@ -141,12 +169,36 @@ function runReferenceThread(data: ReferenceThreadData): void {
   mark('references compared');
 }
 
+/** An emit thread (parallel-emit.ts): emits JavaScript, without a checker. */
+function runEmitThread(job: EmitThreadData, drivers: ThreadDrivers): void {
+  setTimelineThread('e' + String(job.index));
+  mark('thread start');
+  // As on a checker thread, the shared program is never written.
+  reserveNodeIds(job.nodeIds);
+  reserveSymbolIds(job.symbolIds);
+  assignSymbolIdsAtCreation();
+  useLazyJSDocTable();
+  useThreadTextCaches();
+  const program = publish(job.program);
+  const result = emitFromQueue(
+    program,
+    job.index,
+    new Int32Array(job.counter),
+    job.files,
+    job.kinds,
+    drivers.outputWriter(),
+  );
+  parentPort!.postMessage(postedEmitResult(result, program));
+  mark('result posted');
+}
+
 /** A checker thread (parallel-check.ts). */
 function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void {
   const startedAt = Date.now();
   setTimelineThread('c' + String(job.index));
   mark('thread start');
   parallelCheck.writer = drivers.outputWriter();
+  formattedReports.format = job.reportFormat;
   let program: Program | undefined = undefined;
   if (job.program !== undefined) {
     // The shared program is never written: new ids continue above its own, and lazily parsed JSDoc
@@ -160,11 +212,18 @@ function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void
     mark('program received');
   } else program = drivers.programOfCommandLine(job.args);
   // Without a program this thread checks nothing; the main thread checks the files it would have.
+  let checked: CheckedProgram | undefined = undefined;
+  if (program !== undefined) {
+    // The checker the program creates shares results with the other checker threads.
+    setThreadSharingData(job.sharing);
+    checked = new CheckedProgram(program);
+    checked.globalsInFileDiagnostics = job.globalsInFileDiagnostics;
+  }
   const result =
-    program === undefined
+    checked === undefined
       ? new CheckerResult(job.index, [], [], [], [], 0, [])
       : checkFromQueue(
-          new CheckedProgram(program),
+          checked,
           job.index,
           new Int32Array(job.counter),
           job.order,
@@ -176,6 +235,7 @@ function runCheckerThread(job: CheckerThreadData, drivers: ThreadDrivers): void
           job.emitKinds,
           job.checking,
           job.units,
+          job.sharing,
         );
   // Packed results are copied: nothing this thread allocated stays reachable after it ends.
   if (packsResults) parentPort!.postMessage(packResult(result, program!));

package/src/compiler/transformers/alias-references.ts

@@ -5,6 +5,7 @@
 // namespace, enum or module counts as a use.
 import {
   BinaryExpression,
+  ComputedPropertyName,
   ConditionalTypeNode,
   ExportAssignment,
   ExportDeclaration,
@@ -32,13 +33,16 @@ import {
   UnionTypeNode,
   getDotDotDotToken,
   getExpression,
+  getHeritageClauses,
   getInitializer,
+  getName,
   getParameters,
   getTagName,
   getType,
   getTypeArguments,
 } from '../ast.js';
 import { canHaveDecorators, isImportCall } from '../ast-utilities.js';
+import { isAssignmentTarget, isClassLike } from '../binder-utilities.js';
 import {
   type CompilerOptions,
   JsxEmit,
@@ -52,6 +56,7 @@ import {
   getFirstConstructorWithBody,
   getRestParameterElementType,
   getSetAccessorValueParameter,
+  isAccessor,
   nodeCanBeDecorated,
 } from './decorator-utilities.js';
 import { hasDecorators, hasSyntacticModifier } from './utilities.js';
@@ -105,10 +110,16 @@ export class AliasReferences extends NodeVisitor {
       node.kind !== SyntaxKind.PropertyDeclaration
     )
       return false;
+    // tsgo doesn't answer semantic questions inside a `with` statement.
+    if ((node.flags & NodeFlags.InWithStatement) !== 0) return false;
     if (node instanceof Identifier) {
       const parent = node.parent;
       if (
         parent === undefined ||
+        isUnresolvedIdentifier(node as Identifier, this.options.experimentalDecorators === true)
+      )
+        return false;
+      if (
         !(
           isExpressionNode(node) ||
           parent instanceof ShorthandPropertyAssignment ||
@@ -120,7 +131,6 @@ export class AliasReferences extends NodeVisitor {
       // Only the left of a property access or qualified name; the right is a property lookup.
       if (parent instanceof PropertyAccessExpression && parent.expression !== node) return false;
       if (parent instanceof QualifiedName && parent.left !== node) return false;
-      if (isInsideMetaProperty(node)) return false;
       return this.markIdentifier(node as Identifier);
     }
     if (node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.QualifiedName) {
@@ -129,7 +139,9 @@ export class AliasReferences extends NodeVisitor {
         top !== undefined && isPropertyAccessOrQualifiedName(top);
         top = top.parent
       )
-        if (isPartOfTypeNode(top)) return false;
+        // Names in an import type's qualifier, `ns.y` in `typeof import("./b").ns.y`, are exports of the
+        // imported module, not references to this file's imports.
+        if (isPartOfTypeNode(top) || isImportTypeQualifierPart(top)) return false;
       return this.markProperty(node);
     }
     if (node instanceof ExportAssignment) {
@@ -411,6 +423,17 @@ export class AliasReferences extends NodeVisitor {
   }
 }
 
+/** Whether `node` is the qualifier of an import type, or a part of one. */
+function isImportTypeQualifierPart(node: Node): boolean {
+  let current = node;
+  let parent = current.parent;
+  while (parent !== undefined && parent.kind === SyntaxKind.QualifiedName) {
+    current = parent;
+    parent = parent.parent;
+  }
+  return parent instanceof ImportTypeNode && parent.qualifier === current;
+}
+
 function isPropertyAccessOrQualifiedName(node: Node): boolean {
   return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.QualifiedName;
 }
@@ -446,9 +469,101 @@ function shouldMarkIdentifier(node: Identifier): boolean {
   return !(exportDeclaration instanceof ExportDeclaration && exportDeclaration.isTypeOnly);
 }
 
-function isInsideMetaProperty(node: Node): boolean {
-  for (let current: Node | undefined = node; current !== undefined; current = current.parent)
+/**
+ * Whether checking never resolves identifier `node`, so tsgo doesn't mark it: in a meta property, the name of a
+ * shorthand property with an initializer outside a destructuring assignment, in a decorator of a node that can't be
+ * decorated, in the expression of `for (var of x)`, in an invalid computed property name, in an interface's heritage
+ * clause, or in a class's `extends` types after the first.
+ */
+function isUnresolvedIdentifier(node: Identifier, legacyDecorators: boolean): boolean {
+  const parent = node.parent!;
+  if (
+    parent instanceof ShorthandPropertyAssignment &&
+    parent.name === node &&
+    parent.objectAssignmentInitializer !== undefined &&
+    !isAssignmentTarget(parent.parent!)
+  )
+    return true;
+  let decorator: Node | undefined = undefined;
+  let forNode: Node | undefined = undefined;
+  let computedName: Node | undefined = undefined;
+  let heritageClause: Node | undefined = undefined;
+  for (let current: Node | undefined = node; current !== undefined; current = current.parent) {
     if (current instanceof MetaProperty) return true;
+    if (current.kind === SyntaxKind.Decorator) {
+      if (decorator === undefined) decorator = current;
+    } else if (current instanceof ForInOrOfStatement) {
+      if (forNode === undefined) forNode = current;
+    } else if (current instanceof ComputedPropertyName) {
+      if (computedName === undefined) computedName = current;
+    } else if (current instanceof HeritageClause) {
+      if (heritageClause === undefined) heritageClause = current;
+    }
+  }
+  if (decorator !== undefined) {
+    const decorated = decorator.parent;
+    if (
+      decorated !== undefined &&
+      !nodeCanBeDecorated(
+        legacyDecorators,
+        decorated,
+        decorated.parent,
+        decorated.parent === undefined ? undefined : decorated.parent.parent,
+      )
+    )
+      return true;
+  }
+  if (forNode !== undefined) {
+    const statement = forNode as ForInOrOfStatement;
+    if (
+      statement.initializer instanceof VariableDeclarationList &&
+      statement.initializer.declarations.nodes.length === 0 &&
+      (node === statement.expression || isNodeDescendantOf(node, statement.expression))
+    )
+      return true;
+  }
+  if (computedName !== undefined) {
+    const grandparent = computedName.parent!.parent!;
+    if (
+      (grandparent.kind === SyntaxKind.TypeLiteral ||
+        isClassLike(grandparent) ||
+        grandparent.kind === SyntaxKind.InterfaceDeclaration) &&
+      (computedName as ComputedPropertyName).expression instanceof BinaryExpression &&
+      ((computedName as ComputedPropertyName).expression as BinaryExpression).operatorToken.kind ===
+        SyntaxKind.InKeyword &&
+      !isAccessor(computedName.parent!)
+    )
+      return true;
+  }
+  if (heritageClause !== undefined) {
+    const declaration = heritageClause.parent!;
+    // An interface's heritage clauses are types.
+    if (declaration.kind === SyntaxKind.InterfaceDeclaration) return true;
+    // Only a class's first `extends` type is its base class; checking never resolves the others.
+    if (isClassLike(declaration) && (heritageClause as HeritageClause).token === SyntaxKind.ExtendsKeyword) {
+      const first = getClassExtendsHeritageElement(declaration);
+      if (first !== undefined && node !== first && !isNodeDescendantOf(node, first)) return true;
+    }
+  }
+  return false;
+}
+
+/** The first type of a class's first `extends` clause. */
+function getClassExtendsHeritageElement(node: Node): Node | undefined {
+  const clauses = getHeritageClauses(node);
+  if (clauses === undefined) return undefined;
+  for (const clause of clauses.nodes)
+    if ((clause as HeritageClause).token === SyntaxKind.ExtendsKeyword) {
+      const types = (clause as HeritageClause).types.nodes;
+      return types.length > 0 ? types[0] : undefined;
+    }
+  return undefined;
+}
+
+/** Whether `node` is inside `ancestor`. */
+function isNodeDescendantOf(node: Node, ancestor: Node): boolean {
+  for (let current = node.parent; current !== undefined; current = current.parent)
+    if (current === ancestor) return true;
   return false;
 }
 
@@ -631,6 +746,10 @@ function isInExpressionContext(node: Node): boolean {
       return getExpression(parent) === node && !isPartOfTypeNode(parent);
     case SyntaxKind.ShorthandPropertyAssignment:
       return parent instanceof ShorthandPropertyAssignment && parent.objectAssignmentInitializer === node;
+    case SyntaxKind.FunctionExpression:
+    case SyntaxKind.ClassExpression:
+      // The name of a function or class expression is a declaration name, not an expression.
+      return getName(parent) !== node;
   }
   return isExpressionNode(parent);
 }

package/src/compiler/transformers/async.ts

@@ -28,7 +28,6 @@ import {
   getParameters,
   ArrayLiteralExpression,
   SpreadElement,
-  ReturnStatement,
   AwaitExpression,
   QualifiedName,
   Token,
@@ -721,7 +720,8 @@ export class AsyncFunctions extends Transformer {
     } else {
       result = createAwaiterHelper(factory, hasLexicalThis, argumentsExpression, innerParameters, asyncBody);
       if (captureLexicalArguments && this.argumentsUsed) {
-        const block = this.convertToFunctionBlock(result);
+        const block = context.convertToFunctionBlock(result, true);
+        if (!(result instanceof Block)) context.setOriginal(block.statements.nodes[0]!, result);
         result = factory.updateBlock(
           block,
           context.mergeEnvironmentList(block.statements, [this.createCaptureArgumentsStatement()]),
@@ -762,21 +762,6 @@ export class AsyncFunctions extends Transformer {
     return block;
   }
 
-  private convertToFunctionBlock(node: Node): Block {
-    if (node instanceof Block) return node as Block;
-    const factory = this.factory;
-    const statement = factory.created(new ReturnStatement(node));
-    statement.pos = node.pos;
-    statement.end = node.end;
-    this.context.setOriginal(statement, node);
-    const block = factory.createBlock([statement], true);
-    block.statements.pos = node.pos;
-    block.statements.end = node.end;
-    block.pos = node.pos;
-    block.end = node.end;
-    return block;
-  }
-
   private getOriginalIfFunctionLike(node: Node): Node {
     const original = this.context.mostOriginal(node);
     return isFunctionLikeDeclaration(original) ? original : node;

package/src/compiler/transformers/class-fields.ts

@@ -418,7 +418,7 @@ export class ClassFieldsTransformer extends Transformer {
   private visitForSubstitution(node: Node): Node | undefined {
     if (node instanceof Identifier) return this.visitIdentifier(node as Identifier);
     if (node instanceof PropertyAccessExpression && node.name instanceof Identifier)
-      return this.visitPropertyAccessExpressionForSubstitution(node);
+      return this.visitPropertyAccessExpressionForSubstitution(node, this.substitutionMode);
     return this.substitutionMode.visitEachChild(node);
   }
 
@@ -763,9 +763,10 @@ export class ClassFieldsTransformer extends Transformer {
   private visitMethodOrAccessorDeclaration(node: Node): Node | undefined {
     if (!isPrivateIdentifierClassElementDeclaration(node) || !this.shouldTransformClassElementToWeakMap(node))
       return this.classElementMode.visitEachChild(node);
-    const info = this.accessPrivateIdentifier(getName(node)!);
+    // The member's own class declares it; an untransformed or duplicate name leaves the member as written.
+    const info = this.getPrivateIdentifier(this.getPrivateEnvironment(), getName(node)!);
     if (info === undefined) throw new Error('Undeclared private name for property declaration.');
-    if (!info.isValid) return node;
+    if (info.kind === PrivateKind.Untransformed || !info.isValid) return node;
     const functionName = this.getHoistedFunctionName(node, info);
     if (functionName !== undefined) {
       const factory = this.factory;
@@ -878,9 +879,9 @@ export class ClassFieldsTransformer extends Transformer {
     const factory = this.factory;
     if (this.shouldTransformClassElementToWeakMap(node)) {
       // Fields become WeakMaps: the declaration goes.
-      const info = this.accessPrivateIdentifier(node.name);
+      const info = this.getPrivateIdentifier(this.getPrivateEnvironment(), node.name);
       if (info === undefined) throw new Error('Undeclared private name for property declaration.');
-      if (!info.isValid) return node;
+      if (info.kind === PrivateKind.Untransformed || !info.isValid) return node;
       // A static field of a class whose static blocks stay becomes a static block.
       if (info.isStatic && !this.shouldTransformPrivateElementsOrClassStaticBlocks) {
         const statement = this.transformPropertyOrClassStaticBlock(node, factory.createThisExpression());
@@ -1039,12 +1040,13 @@ export class ClassFieldsTransformer extends Transformer {
       }
     }
     // Property names are not references and are never substituted.
-    if (node.name instanceof Identifier) return this.visitPropertyAccessExpressionForSubstitution(node);
+    if (node.name instanceof Identifier) return this.visitPropertyAccessExpressionForSubstitution(node, this);
     return this.visitEachChild(node);
   }
 
-  private visitPropertyAccessExpressionForSubstitution(node: PropertyAccessExpression): Node {
-    const expression = this.visitNode(node.expression)!;
+  /** Visits only the expression of a property access, with `visitor`, so that its name is never substituted. */
+  private visitPropertyAccessExpressionForSubstitution(node: PropertyAccessExpression, visitor: VisitorBase): Node {
+    const expression = visitor.visitNode(node.expression)!;
     if (expression === node.expression) return node;
     return this.factory.updatePropertyAccessExpression(node, expression, node.questionDotToken, node.name, node.flags);
   }
@@ -1745,12 +1747,11 @@ export class ClassFieldsTransformer extends Transformer {
     }
     const statics = staticPropertiesAndClassStaticBlocks(node);
     // Aliases must be known before visiting members, so predict whether a temporary will wrap the class.
+    const hasTransformableStatics = this.hasTransformableStatics(node, statics);
     let isClassWithConstructorReference = false;
-    let hasTransformableStatics = false;
     let deferTempDeclaration = false;
     if (!isDecoratedClassDeclaration) {
       isClassWithConstructorReference = this.classContainsConstructorReference(node);
-      hasTransformableStatics = this.hasTransformableStatics(node, statics);
       let willHavePrivatePendingExpressions = false;
       if (this.shouldTransformPrivateElementsOrClassStaticBlocks) {
         const members = node.members.nodes;
@@ -1810,7 +1811,7 @@ export class ClassFieldsTransformer extends Transformer {
         for (let i = 0; i < initializers.length; i++) expressions.push(initializers[i]);
         expressions.push(factory.cloneIdentifier(temp));
       } else expressions.push(classExpression as Node);
-    } else {
+    } else if (hasTransformableStatics || this.pendingExpressions.length > 0) {
       for (let i = 0; i < this.pendingExpressions.length; i++)
         this.pendingStatements.push(factory.createExpressionStatement(this.pendingExpressions[i]));
       if (statics.length > 0) {
@@ -1821,7 +1822,7 @@ export class ClassFieldsTransformer extends Transformer {
       else if (this.shouldTransformPrivateElementsOrClassStaticBlocks && classThis !== undefined)
         expressions.push(factory.createAssignment(classThis, classExpression));
       else expressions.push(classExpression as Node);
-    }
+    } else expressions.push(classExpression as Node);
     if (expressions.length > 1) {
       context.addEmitFlags(classExpression, EmitFlags.Indented);
       for (let i = 0; i < expressions.length; i++) context.addEmitFlags(expressions[i], EmitFlags.StartOnNewLine);

package/src/compiler/transformers/commonjs-module.ts

@@ -259,12 +259,14 @@ export class CommonJSModuleTransformer extends Transformer {
         statement !== undefined ? statement : factory.created(new EmptyStatement()),
       );
     }
-    if (node instanceof WithStatement)
+    if (node instanceof WithStatement) {
+      const statement = nested.visitStatement(node.statement);
       return factory.updateWithStatement(
         node as WithStatement,
         this.visitNode(node.expression)!,
-        nested.visitStatement(node.statement)!,
+        statement !== undefined ? statement : factory.created(new EmptyStatement()),
       );
+    }
     if (node instanceof IfStatement) {
       const thenStatement = nested.visitStatement(node.thenStatement);
       return factory.updateIfStatement(
@@ -310,7 +312,7 @@ export class CommonJSModuleTransformer extends Transformer {
         this.discarded.visitNode(node.initializer),
         this.visitNode(node.condition),
         this.discarded.visitNode(node.incrementor),
-        this.topLevelNested.visitIterationBody(node.statement)!,
+        this.visitIterationBody(node.statement)!,
       );
     if (node instanceof ForInOrOfStatement)
       return this.factory.updateForInOrOfStatement(
@@ -318,7 +320,7 @@ export class CommonJSModuleTransformer extends Transformer {
         node.awaitModifier,
         this.discarded.visitNode(node.initializer)!,
         this.visitNode(node.expression)!,
-        this.topLevelNested.visitIterationBody(node.statement)!,
+        this.visitIterationBody(node.statement)!,
       );
     if (node instanceof ExpressionStatement || node instanceof VoidExpression)
       return this.discarded.visitEachChild(node);
@@ -1241,7 +1243,9 @@ export class CommonJSModuleTransformer extends Transformer {
     const rewrite =
       this.options.rewriteRelativeImportExtensions === true &&
       ((isImportCall(node) && node.arguments.nodes.length > 0) || (isInJSFile(node) && isRequireCall(node, false)));
-    if (isImportCall(node) && this.shouldTransformImportCall()) return this.visitImportCallExpression(node, rewrite);
+    // `import.source()` and the other phase imports stay as written.
+    if (node.expression.kind === SyntaxKind.ImportKeyword && this.shouldTransformImportCall())
+      return this.visitImportCallExpression(node, rewrite);
     if (rewrite) return this.rewriteImportOrRequireCall(node);
     const callee = node.expression;
     if (callee instanceof Identifier) {
@@ -1331,14 +1335,14 @@ export class CommonJSModuleTransformer extends Transformer {
     let args = node.arguments;
     const nodes = args.nodes;
     if (nodes.length > 0) {
-      const first = nodes[0];
+      const first = this.visitNode(nodes[0])!;
       const rewritten =
         first instanceof StringLiteral || first.kind === SyntaxKind.NoSubstitutionTemplateLiteral
           ? rewriteModuleSpecifier(this.context, first, this.options)
           : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
       const rest = nodes.slice(1);
       const visitedRest = this.visitArray(rest);
-      if (rewritten !== first || visitedRest !== rest)
+      if (rewritten !== nodes[0] || visitedRest !== rest)
         args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
     }
     return factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, args, node.flags);

package/src/compiler/transformers/declarations-diagnostics.ts

@@ -21,13 +21,13 @@ import {
   hasSyntacticModifier,
   isEntityNameExpression,
   isStatic,
-  isTypeNodeKind,
 } from '../binder-utilities.js';
 import { isFunctionLikeDeclarationKind } from '../ast-utilities.js';
 import { Diagnostic, type DiagnosticMessage, Diagnostics } from '../diagnostics.js';
 import { ModifierFlags } from '../ast.js';
 import { isStatement } from '../printer/utilities.js';
 import { SyntaxKind } from '../syntax-kind.js';
+import { isPartOfTypeNode } from './alias-references.js';
 import { isParameterPropertyDeclaration } from './utilities.js';
 import { SymbolAccessibility, type SymbolAccessibilityResult } from './declarations-resolver.js';
 import { getDeclarations } from '../symbol.js';
@@ -482,6 +482,8 @@ function parameterTypeMessage(node: Node, result: SymbolAccessibilityResult): Di
       );
     case SyntaxKind.FunctionDeclaration:
     case SyntaxKind.FunctionType:
+    case SyntaxKind.ArrowFunction:
+    case SyntaxKind.FunctionExpression:
       return byModuleName(
         result,
         Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named,
@@ -713,7 +715,7 @@ export function createIsolatedDeclarationError(node: Node, requiresAddingUndefin
         Diagnostics.Extends_clause_can_t_contain_an_expression_with_isolatedDeclarations,
         [],
       );
-  if (isTypeNodeKind(node.kind) || node.kind === SyntaxKind.TypeQuery || isEntityNameExpression(node, false))
+  if (isPartOfTypeNode(node) || node.kind === SyntaxKind.TypeQuery || isEntityNameExpression(node, false))
     return addParentDeclarationRelatedInfo(
       node,
       createDiagnosticForNode(
@@ -758,7 +760,7 @@ export function createIsolatedDeclarationError(node: Node, requiresAddingUndefin
     case SyntaxKind.BindingElement:
       return createDiagnosticForNode(
         node,
-        Diagnostics.Binding_elements_can_t_be_exported_directly_with_isolatedDeclarations,
+        Diagnostics.Binding_elements_with_initializers_can_t_be_exported_directly_with_isolatedDeclarations,
         [],
       );
     case SyntaxKind.PropertyDeclaration:

package/src/compiler/transformers/declarations-pseudo.ts

@@ -389,10 +389,8 @@ export class PseudoChecker {
     const initializer = declaration.initializer;
     // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
     const symbol = declaration.symbol;
-    if (
-      initializer !== undefined &&
-      (symbol === undefined || countVariableDeclarations(getDeclarations(symbol)) === 1)
-    ) {
+    // A binding pattern has no symbol, and its initializer's type isn't the variable's.
+    if (initializer !== undefined && symbol !== undefined && countVariableDeclarations(getDeclarations(symbol)) === 1) {
       if (!isContextuallyTyped(declaration)) {
         // Const template literals may become literal types, so they aren't inferred.
         if (

package/src/compiler/transformers/declarations-resolver.ts

@@ -3,7 +3,6 @@
 // binder, and the checker answers them with types.
 import type { ImportDeclaration, ModifierFlags, Node, SourceFile, FileReference } from '../ast.js';
 import type { EmitContext } from '../printer/emit-context.js';
-import type { ModuleKind } from '../options.js';
 import type { Symbol, SymbolFlags } from '../symbol.js';
 import { EmitResolver } from './emit-resolver.js';
 
@@ -180,8 +179,6 @@ export abstract class DeclarationEmitResolver extends EmitResolver {
   abstract isExpandoFunctionDeclaration(node: Node): boolean;
   /** Types: the declarations of properties assigned to a function. */
   abstract getExpandoPropertyDeclarations(node: Node): Node[];
-  /** The `resolution-mode` of import attributes, or undefined. */
-  abstract getResolutionModeOverride(node: Node): ModuleKind | undefined;
   /** The program file a `/// <reference path>` names. */
   abstract getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined;
 

package/src/compiler/transformers/declarations-syntactic.ts

@@ -16,8 +16,6 @@ import {
   FileReference,
   FunctionTypeNode,
   Identifier,
-  ImportAttribute,
-  ImportAttributes,
   type ImportDeclaration,
   ImportEqualsDeclaration,
   KeywordTypeNode,
@@ -59,7 +57,6 @@ import {
   getInitializer,
   getMembers,
   getName,
-  getText,
   getParameters,
   getSymbol,
   getType,
@@ -83,8 +80,7 @@ import {
   skipParentheses,
 } from '../binder-utilities.js';
 import { NameResolver } from '../name-resolver.js';
-import type { CompilerOptions, ModuleKind } from '../options.js';
-import { ModuleKind as ModuleKinds } from '../options.js';
+import type { CompilerOptions } from '../options.js';
 import { combinePaths, getDirectoryPath, getNormalizedAbsolutePath, normalizePath } from '../path.js';
 import type { EmitContext } from '../printer/emit-context.js';
 import { EmitFlags } from '../printer/emit-flags.js';
@@ -737,22 +733,6 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     return this.emitResolver.getTypeReferenceSerializationKind(typeName, location);
   }
 
-  getResolutionModeOverride(node: Node): ModuleKind | undefined {
-    if (!(node instanceof ImportAttributes)) return undefined;
-    for (const element of node.attributes.nodes) {
-      if (!(element instanceof ImportAttribute)) continue;
-      const name = element.name;
-      if (name === undefined || (name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.Identifier))
-        continue;
-      if (getText(name) !== 'resolution-mode') continue;
-      const value = element.value;
-      if (!(value instanceof StringLiteral)) return undefined;
-      if (value.text === 'import') return ModuleKinds.ESNext;
-      if (value.text === 'require') return ModuleKinds.CommonJS;
-    }
-    return undefined;
-  }
-
   getSourceFileFromReference(file: SourceFile, reference: FileReference): SourceFile | undefined {
     const path = normalizePath(combinePaths(getDirectoryPath(file.fileName), reference.fileName));
     for (const candidate of [path, path + '.ts', path + '.tsx', path + '.d.ts']) {