tsc-ts 0.0.9 → 0.1.0

package/src/compiler/incremental.ts

@@ -41,6 +41,7 @@ import {
   modeMismatchDetails,
   moduleNotFoundDetails,
   resolveExternalModuleName,
+  getImportAttributesTypeForModuleSpecifier,
 } from './checker-modules.js';
 import { getSymbolAtLocation } from './checker-services.js';
 import { resolveAlias } from './checker-symbols.js';
@@ -1231,7 +1232,17 @@ function addOwnReferencedFiles(checked: CheckedProgram, file: SourceFile, refere
   // call that does not initialize a variable (`exports.a = require("./a").a`), so its build info leaves out that
   // module and its incremental builds keep outputs that depend on it.
   for (const importName of file.imports) {
-    addReferencedFilesFromSymbol(file, referenced, resolveExternalModuleName(checker, importName, importName, true));
+    addReferencedFilesFromSymbol(
+      file,
+      referenced,
+      resolveExternalModuleName(
+        checker,
+        importName,
+        importName,
+        true,
+        getImportAttributesTypeForModuleSpecifier(checker, importName),
+      ),
+    );
   }
   const sourceFileDirectory = getDirectoryPath(file.fileName);
   for (const reference of file.referencedFiles) {
@@ -1275,9 +1286,16 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   // Reuse from the old state.
   if (oldSnapshot !== undefined) {
     if (options.composite === true) snapshot.latestChangedDtsFile = oldSnapshot.latestChangedDtsFile;
-    for (const path of oldSnapshot.changedFilesSet) snapshot.changedFilesSet.add(path);
-    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) snapshot.affectedFilesPendingEmit.set(path, kind);
     snapshot.buildInfoEmitPending = oldSnapshot.buildInfoEmitPending;
+    // Changes and pending emit of files no longer in the program are dropped, which changes the build info.
+    for (const path of oldSnapshot.changedFilesSet) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.changedFilesSet.add(path);
+      else snapshot.buildInfoEmitPending = true;
+    }
+    for (const [path, kind] of oldSnapshot.affectedFilesPendingEmit) {
+      if (program.getSourceFileByPath(path) !== undefined) snapshot.affectedFilesPendingEmit.set(path, kind);
+      else snapshot.buildInfoEmitPending = true;
+    }
     snapshot.hasErrorsFromOldState = oldSnapshot.hasErrors;
     snapshot.hasSemanticErrorsFromOldState = oldSnapshot.hasSemanticErrors;
     const oldPackageJsons = oldSnapshot.packageJsons;
@@ -1425,13 +1443,23 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   if (oldSnapshot !== undefined) {
     for (const [path, oldInfo] of oldSnapshot.fileInfos) {
       if (snapshot.fileInfos.has(path)) continue;
-      if (oldInfo.affectsGlobalScope) {
-        for (const file of snapshot.getAllFilesExcludingDefaultLibraryFile(program, undefined)) {
-          snapshot.addFileToChangeSet(file.path);
-        }
-        globalFileRemoved = true;
-      } else snapshot.buildInfoEmitPending = true;
-      break;
+      snapshot.buildInfoEmitPending = true;
+      snapshot.changedFilesSet.delete(path);
+      snapshot.affectedFilesPendingEmit.delete(path);
+      if (oldInfo.affectsGlobalScope) globalFileRemoved = true;
+    }
+    if (globalFileRemoved) invalidateGlobalScope(checked, snapshot);
+  }
+
+  // A file that no longer affects the global scope changes it as its removal would.
+  if (oldSnapshot !== undefined && !globalFileRemoved) {
+    for (const [path, oldInfo] of oldSnapshot.fileInfos) {
+      if (!oldInfo.affectsGlobalScope) continue;
+      const info = snapshot.fileInfos.get(path);
+      if (info !== undefined && !info.affectsGlobalScope) {
+        invalidateGlobalScope(checked, snapshot);
+        break;
+      }
     }
   }
 
@@ -1460,6 +1488,19 @@ function programToSnapshot(checked: CheckedProgram, oldSnapshot: Snapshot | unde
   return snapshot;
 }
 
+/**
+ * After a change to the global scope, every file but the default libraries is changed, and the default
+ * libraries that are checked are checked again.
+ */
+function invalidateGlobalScope(checked: CheckedProgram, snapshot: Snapshot): void {
+  const program = checked.program;
+  snapshot.buildInfoEmitPending = true;
+  for (const file of program.getSourceFiles()) {
+    if (!program.isSourceFileDefaultLibrary(file.path)) snapshot.addFileToChangeSet(file.path);
+    else if (!checked.skipTypeChecking(file, true)) snapshot.semanticDiagnosticsPerFile.delete(file.path);
+  }
+}
+
 // ---- Affected files
 
 class AffectedFilesHandler {
@@ -1510,7 +1551,12 @@ class AffectedFilesHandler {
   private computeDtsSignature(file: SourceFile): string {
     const known = this.incremental.signatures.get(file.path);
     if (known !== undefined) return known;
-    return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    const done = this.incremental.beginNestedEmit();
+    try {
+      return declarationSignature(this.incremental.emitter, file, this.snapshot.options);
+    } finally {
+      done();
+    }
   }
 
   updateShapeSignature(file: SourceFile, useFileVersionAsSignature: boolean): boolean {
@@ -1519,7 +1565,10 @@ class AffectedFilesHandler {
     if (info === undefined) return false;
     const previous = info.signature;
     let signature = '';
-    if (!file.isDeclarationFile && !useFileVersionAsSignature) signature = this.computeDtsSignature(file);
+    // A JSON file has no declaration output, so its version is its signature, which invalidates its importers.
+    if (!file.isDeclarationFile && !isJsonSourceFile(file) && !useFileVersionAsSignature) {
+      signature = this.computeDtsSignature(file);
+    }
     if (signature === '') signature = info.version;
     this.updatedSignatures.set(file.path, signature);
     return signature !== previous;
@@ -1549,7 +1598,7 @@ class AffectedFilesHandler {
     const info = this.snapshot.fileInfos.get(file.path);
     if (info !== undefined && info.affectsGlobalScope) {
       this.hasAllFilesExcludingDefaultLibraryFile = true;
-      this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
+      return this.snapshot.getAllFilesExcludingDefaultLibraryFile(this.program, file);
     }
     if (this.snapshot.options.isolatedModules === true) return [file];
     const seen = this.forEachFileReferencedBy(file, (currentFile) => {
@@ -1864,8 +1913,21 @@ class EmitFilesHandler {
       const files = program.program.getSourceFiles();
       const emittedOnCheckers = this.emittedOnCheckers();
       const wrapped = this.wrap(writer);
-      const result =
-        emittedOnCheckers.size === 0
+      const ahead = this.declarationsEmittedAhead();
+      const result = program.checked.javaScriptEmittedOnThreads
+        ? combineEmitResults(
+            files.map((file) =>
+              this.emitAfterEmitThreads(
+                file,
+                EmitOnly.All,
+                emittedOnCheckers.get(file),
+                ahead.get(file),
+                writer,
+                wrapped,
+              ),
+            ),
+          )
+        : emittedOnCheckers.size === 0
           ? program.emitter.emit(files, EmitOnly.All, wrapped)
           : combineEmitResults(
               files.map((file) => {
@@ -1901,20 +1963,76 @@ class EmitFilesHandler {
   /**
    * The emit results of the files checker threads emitted right after checking them (parallel-check.ts),
    * which are not emitted again here. Checker threads emit every file of a program without old build
-   * info, with the outputs its options select, as its pending emit asks.
+   * info, with the outputs its options select, as its pending emit asks. Emit threads emit only the
+   * JavaScript of the files (`javaScriptEmittedOnThreads`, `emitAfterEmitThreads`).
    */
   private emittedOnCheckers(): Map<SourceFile, EmitResult> {
+    return this.byFile(this.program.checked.emittedInParallel);
+  }
+
+  /** The declaration emit of the files the declaration thread emitted (parallel-emit.ts). */
+  private declarationsEmittedAhead(): Map<SourceFile, EmitResult> {
+    return this.byFile(this.program.checked.declarationsEmittedAhead);
+  }
+
+  /** The results of `results`, by file index, by file. */
+  private byFile(results: readonly (EmitResult | undefined)[] | undefined): Map<SourceFile, EmitResult> {
     const result = new Map<SourceFile, EmitResult>();
-    const emitted = this.program.checked.emittedInParallel;
-    if (emitted === undefined) return result;
+    if (results === undefined) return result;
     const files = this.program.program.getSourceFiles();
     for (let i = 0; i < files.length; i++) {
-      const fileResult = emitted[i];
+      const fileResult = results[i];
       if (fileResult !== undefined) result.set(files[i]!, fileResult);
     }
     return result;
   }
 
+  /**
+   * The emit of `file` with `emitOnly` where emit threads emitted the JavaScript of the program's files
+   * while this thread checked it (`javaScriptEmittedOnThreads`, parallel-emit.ts): the outputs an emit thread
+   * emitted of its JavaScript (`javaScript`) and the declaration thread of its declarations (`declarations`),
+   * and the rest emitted here. A file no thread emitted is emitted here as without the threads.
+   */
+  private emitAfterEmitThreads(
+    file: SourceFile,
+    emitOnly: EmitOnly,
+    javaScript: EmitResult | undefined,
+    declarations: EmitResult | undefined,
+    writer: OutputWriter,
+    wrapped: OutputWriter,
+  ): EmitResult {
+    const program = this.program;
+    if (wrapped instanceof SignatureRecordingWriter) wrapped.file = file;
+    if (javaScript === undefined && declarations === undefined) return program.emitter.emit([file], emitOnly, wrapped);
+    const results: EmitResult[] = [];
+    if (emitOnly !== EmitOnly.Dts)
+      results.push(
+        javaScript !== undefined
+          ? this.writeThreadOutputs(file, javaScript, writer)
+          : program.emitter.emit([file], EmitOnly.Js, writer),
+      );
+    if (emitOnly !== EmitOnly.Js && getEmitDeclarations(program.snapshot.options))
+      results.push(
+        declarations !== undefined
+          ? this.writeThreadOutputs(file, declarations, writer)
+          : program.emitter.emit([file], emitOnly === EmitOnly.Dts ? EmitOnly.Dts : EmitOnly.DtsAfterJs, wrapped),
+      );
+    return combineEmitResults(results);
+  }
+
+  /**
+   * Writes the outputs a thread emitted for `file` with `writer`, as this thread would have written them:
+   * its declaration signatures are recorded (`recordDeclarationSignatures`), and the unchanged declaration
+   * files of a composite program are left unwritten.
+   */
+  private writeThreadOutputs(file: SourceFile, emitted: EmitResult, writer: OutputWriter): EmitResult {
+    const skips = this.recordDeclarationSignatures(file, emitted.declarationSignatures);
+    return writeHeldOutputs(
+      emitted,
+      skips === undefined ? writer : new HeldDeclarationWriter(writer, skips, this.program.host),
+    );
+  }
+
   /** Records declaration signatures when declarations are emitted. */
   private wrap(writer: OutputWriter): OutputWriter {
     return getEmitDeclarations(this.program.snapshot.options) ? new SignatureRecordingWriter(this, writer) : writer;
@@ -1926,6 +2044,7 @@ class EmitFilesHandler {
     collectAllAffectedFiles(program);
     const wrapped = this.wrap(writer);
     const emittedOnCheckers = this.emittedOnCheckers();
+    const ahead = this.declarationsEmittedAhead();
     for (const [path, emitKind] of snapshot.affectedFilesPendingEmit) {
       const affectedFile = program.program.getSourceFileByPath(path);
       if (affectedFile === undefined || !program.program.sourceFileMayBeEmitted(affectedFile, false)) {
@@ -1939,13 +2058,10 @@ class EmitFilesHandler {
       if (!this.isForDtsErrors) {
         const emitOnly = emitOnlyOfPendingKind(pendingKind);
         const emitted = emittedOnCheckers.get(affectedFile);
-        if (emitted !== undefined) {
-          const skips = this.recordDeclarationSignatures(affectedFile, emitted.declarationSignatures);
-          result = writeHeldOutputs(
-            emitted,
-            skips === undefined ? writer : new HeldDeclarationWriter(writer, skips, program.host),
-          );
-        } else {
+        if (program.checked.javaScriptEmittedOnThreads)
+          result = this.emitAfterEmitThreads(affectedFile, emitOnly, emitted, ahead.get(affectedFile), writer, wrapped);
+        else if (emitted !== undefined) result = this.writeThreadOutputs(affectedFile, emitted, writer);
+        else {
           if (wrapped instanceof SignatureRecordingWriter) wrapped.file = affectedFile;
           result = program.emitter.emit([affectedFile], emitOnly, wrapped);
         }
@@ -2491,6 +2607,7 @@ export class IncrementalProgram extends CompilerProgram {
     readonly signatures: ReadonlyMap<string, string> = new Map(),
   ) {
     super(checked, times);
+    checked.globalsInFileDiagnostics = true;
     this.snapshot = programToSnapshot(checked, oldSnapshot);
   }
 
@@ -2498,6 +2615,25 @@ export class IncrementalProgram extends CompilerProgram {
     return this.snapshot.hasChangedDtsFile;
   }
 
+  /** Time spent in declaration emit for signatures while checking (`computeDtsSignature`), not yet taken. */
+  private nestedEmitTime = 0;
+  private nestedEmitDepth = 0;
+  private nestedEmitStart = 0;
+
+  /** Starts timing a nested declaration emit; returns the function that ends it. */
+  beginNestedEmit(): () => void {
+    if (this.nestedEmitDepth++ === 0) this.nestedEmitStart = performance.now();
+    return () => {
+      if (--this.nestedEmitDepth === 0) this.nestedEmitTime += performance.now() - this.nestedEmitStart;
+    };
+  }
+
+  override takeNestedEmitTime(): number {
+    const time = this.nestedEmitTime;
+    this.nestedEmitTime = 0;
+    return time;
+  }
+
   /**
    * The global diagnostics found before `filesToCheck` computed the affected files, which the program
    * reports before its semantic diagnostics (`getGlobalDiagnostics(false)`), as when they are computed
@@ -2630,10 +2766,9 @@ export class IncrementalProgram extends CompilerProgram {
   emit(writer: OutputWriter): EmitResult {
     const options = this.snapshot.options;
     let result: EmitResult | undefined;
-    if (options.noEmit === true) {
-      result = new EmitResult();
-      result.emitSkipped = true;
-    } else result = handleNoEmitOnError(this);
+    // A `noEmit` program emits only its build info, and its emit is not skipped (tsgo's `HandleNoEmitOptions`).
+    if (options.noEmit === true) result = new EmitResult();
+    else result = handleNoEmitOnError(this);
     if (result !== undefined) {
       const buildInfoResult = this.emitBuildInfo(writer);
       if (buildInfoResult !== undefined) {

package/src/compiler/init.ts

@@ -2,12 +2,7 @@
  * The tsconfig.json written by `tsc --init`.
  */
 import { Diagnostics, localizeMessage, type DiagnosticMessage, type Locale } from './diagnostics.js';
-import {
-  compilerOptionsByName,
-  sameEnumValue,
-  watchOptionsByName,
-  type OptionDeclaration,
-} from './option-declarations.js';
+import { compilerOptionsByName, sameEnumValue, type OptionDeclaration } from './option-declarations.js';
 import { JsxEmit, ModuleDetectionKind, ModuleKind, ScriptTarget, type OptionValue } from './options.js';
 
 const enum Commented {
@@ -124,7 +119,7 @@ class ConfigWriter {
 }
 
 function formatValue(name: string, value: OptionValue): string {
-  const option = compilerOptionsByName.get(name) ?? watchOptionsByName.get(name);
+  const option = compilerOptionsByName.get(name);
   if (value === null) return 'null';
   if (typeof value === 'boolean') return value ? 'true' : 'false';
   if (typeof value === 'number' || typeof value === 'string') return formatScalar(value, option);

package/src/compiler/instantiation.ts

@@ -43,6 +43,7 @@ import {
   newTypeMapper,
   SimpleTypeMapper,
   TypeListCache,
+  getMappedType,
 } from './checker-types.js';
 import {
   IntersectionFlags,
@@ -87,6 +88,7 @@ import {
   type Symbol,
   SymbolFlags,
 } from './symbol.js';
+import { symbolToString } from './type-printer.js';
 
 // ---- Mappers that need the checker
 
@@ -104,8 +106,8 @@ export class CompositeTypeMapper extends TypeMapper {
   }
 
   map(type: Type): Type {
-    const t1 = this.m1.map(type);
-    return t1 !== type ? instantiateType(this.c, t1, this.m2) : this.m2.map(type);
+    const t1 = getMappedType(type, this.m1);
+    return t1 !== type ? instantiateType(this.c, t1, this.m2) : getMappedType(type, this.m2);
   }
 }
 
@@ -202,23 +204,37 @@ export function instantiateTypeWithAlias(
   }
   if (!could && (type.alias === undefined || !aliasCouldContainTypeVariables(c, type))) return type;
   if (c.instantiationDepth === 100 || c.instantiationCount >= 5000000) {
-    // Probably infinitely expanding generic types; stop with the error type.
-    c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+    // Probably infinitely expanding generic types; stop with the error type, naming the types whose
+    // instantiations nest three or more times.
+    const circularTypeNames = getCircularTypeNames(c);
+    if (circularTypeNames.length === 1)
+      c.error(c.currentNode, Diagnostics.Instantiations_of_type_0_appear_infinitely_circular, circularTypeNames[0]!);
+    else if (circularTypeNames.length > 1)
+      c.error(
+        c.currentNode,
+        Diagnostics.Instantiations_of_the_following_types_appear_infinitely_circular_Colon_0,
+        quotedAndCommaSeparated(circularTypeNames),
+      );
+    else c.error(c.currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
     return c.errorType;
   }
-  const depth = c.activeMapperDepth;
-  const activeMappers = c.activeMappers;
-  let index = depth - 1;
-  while (index >= 0 && activeMappers[index]! !== mapper) index--;
+  const depth = c.activeMapperDepth | 0;
+  const mapperId = mapper.id | 0;
+  let index = (depth - 1) | 0;
+  while (index >= 0 && c.activeMapperIds[index]! !== mapperId) index = (index - 1) | 0;
   if (index === -1) {
     // A newly active mapper has no cached instantiations; its cache is created when a nested
     // instantiation with the same mapper stores one.
-    if (depth < activeMappers.length) {
-      activeMappers[depth] = mapper;
+    if (depth === c.activeMapperIds.length) {
+      const grown = new Int32Array(depth * 2);
+      grown.set(c.activeMapperIds);
+      c.activeMapperIds = grown;
+    }
+    c.activeMapperIds[depth] = mapperId;
+    if (depth < c.activeMapperCaches.length) {
       c.activeMapperCaches[depth] = undefined;
       c.activeMapperAliasCaches[depth] = undefined;
     } else {
-      activeMappers.push(mapper);
       c.activeMapperCaches.push(undefined);
       c.activeMapperAliasCaches.push(undefined);
     }
@@ -236,7 +252,11 @@ export function instantiateTypeWithAlias(
   }
   c.instantiationCount++;
   c.totalInstantiations++;
-  c.instantiationDepth++;
+  const instantiationDepth = c.instantiationDepth;
+  const instantiationStack = c.instantiationStack;
+  if (instantiationDepth < instantiationStack.length) instantiationStack[instantiationDepth] = type;
+  else instantiationStack.push(type);
+  c.instantiationDepth = instantiationDepth + 1;
   const result = instantiateTypeWorker(c, type, mapper, alias);
   if (index === -1) {
     // The mapper's slot stays until it is reused; its caches are released now.
@@ -274,6 +294,32 @@ export function instantiateTypeWithAlias(
   return result;
 }
 
+/**
+ * The names of the types that are instantiated three or more times on the current instantiation stack, by
+ * their alias where they have one, in the order they reach the third, each once.
+ */
+function getCircularTypeNames(c: Checker): string[] {
+  const counts = new Map<Type, number>();
+  const names: string[] = [];
+  const stack = c.instantiationStack;
+  for (let i = 0; i < c.instantiationDepth; i++) {
+    const t = stack[i]!;
+    const count = (counts.get(t) ?? 0) + 1;
+    counts.set(t, count);
+    if (count !== 3) continue;
+    const symbol = t.alias !== undefined ? t.alias.symbol : t.symbol;
+    if (symbol === undefined || symbol.name.length === 0 || symbol.name.charCodeAt(0) === 0xfffe) continue;
+    const name = symbolToString(c, symbol);
+    if (!names.includes(name)) names.push(name);
+  }
+  return names;
+}
+
+/** `'a', 'b', 'c'`. */
+export function quotedAndCommaSeparated(items: readonly string[]): string {
+  return items.map((item) => "'" + item + "'").join(', ');
+}
+
 function aliasCouldContainTypeVariables(c: Checker, type: Type): boolean {
   const alias = type.alias;
   if (alias === undefined || alias.typeArguments.length === 0) return false;
@@ -358,7 +404,7 @@ function isNonGenericTopLevelType(type: Type): boolean {
 
 function instantiateTypeWorker(c: Checker, type: Type, mapper: TypeMapper, alias: TypeAlias | undefined): Type {
   const flags = type.flags;
-  if ((flags & TypeFlags.TypeParameter) !== 0) return mapper.map(type);
+  if ((flags & TypeFlags.TypeParameter) !== 0) return getMappedType(type, mapper);
   if ((flags & TypeFlags.Object) !== 0) {
     const objectFlags = type.objectFlags;
     if ((objectFlags & (ObjectFlags.Reference | ObjectFlags.Anonymous | ObjectFlags.Mapped)) === 0) return type;
@@ -447,7 +493,7 @@ function getObjectTypeInstantiation(
   mapper: TypeMapper,
   alias: TypeAlias | undefined,
 ): Type {
-  if ((type.objectFlags & ObjectFlags.Reference) === 0 && c.withoutOuterTypeParameters.get(type.id) !== 0) return type;
+  if ((type.objectFlags & ObjectFlags.Reference) === 0 && c.withoutOuterTypeParameters.has(type.id)) return type;
   let declaration: Node;
   if ((type.objectFlags & ObjectFlags.Reference) !== 0) declaration = (type as TypeReference).node!;
   else if ((type.objectFlags & ObjectFlags.InstantiationExpressionType) !== 0)
@@ -483,7 +529,7 @@ function getObjectTypeInstantiation(
     links.outerTypeParameters = typeParameters;
   }
   if (typeParameters.length === 0) {
-    if ((type.objectFlags & ObjectFlags.Reference) === 0) c.withoutOuterTypeParameters.set(type.id, 1);
+    if ((type.objectFlags & ObjectFlags.Reference) === 0) c.withoutOuterTypeParameters.add(type.id);
     return type;
   }
   // The type arguments, mapped as `combineTypeMappers(c, type.mapper, mapper)` maps them, into a
@@ -491,10 +537,10 @@ function getObjectTypeInstantiation(
   const typeMapper = type.mapper;
   const mapped = c.freeTypeLists.pop() ?? [];
   for (const tp of typeParameters) {
-    if (typeMapper === undefined) mapped.push(mapper.map(tp));
+    if (typeMapper === undefined) mapped.push(getMappedType(tp, mapper));
     else {
-      const t1 = typeMapper.map(tp);
-      mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : mapper.map(tp));
+      const t1 = getMappedType(tp, typeMapper);
+      mapped.push(t1 !== tp ? instantiateType(c, t1, mapper) : getMappedType(tp, mapper));
     }
   }
   const newAlias = alias ?? instantiateTypeAlias(c, type.alias, mapper);
@@ -804,10 +850,19 @@ export function instantiateSymbol(c: Checker, symbol: Symbol, mapper: TypeMapper
  * is resolved yet, so lazily instantiated members record it when tsgo would instantiate them.
  */
 export function keepsSymbolUnderInstantiation(c: Checker, symbol: Symbol, mapper: TypeMapper): boolean {
-  const symbolId = getSymbolId(symbol);
-  if (mapper.mapsThisOnly() && isThisless(symbol)) return true;
-  // A resolved type that can't change under instantiation keeps the symbol.
-  const type = c.symbolTypes.get(symbolId);
+  if (mapper.mapsThisOnly() && isThisless(symbol)) {
+    getSymbolId(symbol);
+    return true;
+  }
+  return keepsSymbolTypeUnderInstantiation(c, symbol);
+}
+
+/**
+ * Whether the resolved type of `symbol` (and its write type) can't change under instantiation, so that
+ * `instantiateSymbol` keeps it whatever the mapper. Once true, it stays true: types are resolved once.
+ */
+export function keepsSymbolTypeUnderInstantiation(c: Checker, symbol: Symbol): boolean {
+  const type = c.symbolTypes.get(getSymbolId(symbol));
   if (type !== undefined && !couldContainTypeVariables(c, type)) {
     if ((symbol.flags & SymbolFlags.SetAccessor) === 0) return true;
     const writeType = c.existingSymbolLinks(symbol)?.writeType;

package/src/compiler/jsdoc.ts

@@ -46,6 +46,7 @@ import {
   getTagName,
   getType,
   type EntityName,
+  getText,
 } from './ast.js';
 import { isReservedWord, tokenIsIdentifierOrKeyword } from './ast-utilities.js';
 import { CharacterCodes, isWhiteSpaceLike } from './character-codes.js';
@@ -937,6 +938,7 @@ export class JSDocParser {
         undefined,
         SyntaxKind.NamespaceKeyword,
         typeNameOrNamespaceName,
+        undefined,
         body,
       );
       if (nested) jsDocNamespaceNode.flags |= NodeFlags.NestedNamespace;
@@ -1270,7 +1272,7 @@ function textsEqual(a: Node, b: Node): boolean {
     if (
       a instanceof QualifiedName &&
       b instanceof QualifiedName &&
-      (a as QualifiedName).right.text === (b as QualifiedName).right.text
+      getText((a as QualifiedName).right) === getText((b as QualifiedName).right)
     ) {
       a = (a as QualifiedName).left;
       b = (b as QualifiedName).left;