tsc-ts 0.0.9 → 0.1.0

package/src/compiler/tsc-watch.ts

@@ -474,14 +474,6 @@ class Watcher {
 
   start(): void {
     const sys = this.sys;
-    if (this.config.options.incremental === true || this.config.options.composite === true) {
-      this.snapshot = readBuildInfoProgram(
-        this.config,
-        new FileBuildInfoReader(new SystemFileSystem(sys)),
-        sys.defaultLibraryPath,
-        sys.currentDirectory,
-      );
-    }
     this.status.report(
       watchRestart.resumed
         ? Diagnostics.File_change_detected_Starting_incremental_compilation
@@ -491,59 +483,86 @@ class Watcher {
       watchRestart.firstBuildDone();
       this.changes.watch([this.stamps, this.configStamps]);
     };
-    // A program shared with checker threads is never written: symbols get their ids when created.
     const options = this.config.options;
-    if (parallelParse.spawn !== undefined && checkerThreads(options.checkers, options.singleThreaded) > 1)
+    if (parallelParse.spawn !== undefined && options.singleThreaded !== true) {
+      // Parse threads load the first program, as they load a compile's (`parsesAhead`, tsc-cli.ts), and
+      // it is shared with them: its symbols get their ids when they are created.
       assignSymbolIdsAtCreation();
-    const threads = this.firstBuildThreads();
-    if (threads > 1) this.buildOnThreads(threads, watchChanges);
-    else this.build(watchChanges);
-  }
-
-  /**
-   * The checker threads of the first build: those of a compile (`compileThreads`), or 1 to build on this
-   * thread. A first build without old state checks every file, as a compile does; rebuilds check what a
-   * change affects (`rebuildThreads`). With build info (`--incremental`), the first build stays here.
-   */
-  private firstBuildThreads(): number {
-    const options = this.config.options;
-    if (this.snapshot !== undefined || isIncremental(options) || parallelParse.spawn === undefined) return 1;
-    return checkerThreads(options.checkers, options.singleThreaded);
+      this.buildOnThreads(watchChanges);
+      return;
+    }
+    if (isIncremental(options))
+      this.snapshot = readBuildInfoProgram(
+        this.config,
+        new FileBuildInfoReader(new SystemFileSystem(sys)),
+        sys.defaultLibraryPath,
+        sys.currentDirectory,
+      );
+    this.build(watchChanges);
   }
 
   /**
-   * Builds the first program as a compile does: parse threads load its files, and checker threads check
-   * it (parallel-check.ts) unless it checks little. The program is shared with them, so it gets its own
-   * copy of the config and a host of its own. Its files go to the watch's file maps for rebuilds to take,
-   * and are never written again: rebuilds check them with the checker's side tables. Calls `done` once
-   * the build is reported.
+   * Builds the first program as a compile does: parse threads load its files while this thread reads the
+   * build info (`--incremental`), and checker threads check it (parallel-check.ts) unless it checks little.
+   * Without old state, every file is checked, as a compile does; with build info, the files the changes
+   * since affect are, as a rebuild checks them (`recheckOnThreads`). The program is shared with the
+   * threads, so it gets its own copy of the config and a host of its own. Its files go to the watch's
+   * file maps for rebuilds to take, and are never written again: rebuilds check them with the checker's
+   * side tables. Calls `done` once the build is reported.
    */
-  private buildOnThreads(threads: number, done: () => void): void {
+  private buildOnThreads(done: () => void): void {
     releaseProgramCaches();
     const sys = this.sys;
     const config = copyCommandLine(this.config);
     const options = config.options;
+    const incremental = isIncremental(options);
     const session = new ParseSession(
-      parseThreads(threads),
+      parseThreads(checkerThreads(options.checkers, options.singleThreaded)),
       options,
       sys.currentDirectory,
       config.configName,
       config.fileNames.length > 0,
     );
-    const host = new WatchCompilerHost(
-      sys,
-      new CachedFileSystem(new SystemFileSystem(sys)),
-      this.locale,
-      new WatchSourceFiles(),
-    );
+    const fs = new CachedFileSystem(new SystemFileSystem(sys));
+    const host = new WatchCompilerHost(sys, fs, this.locale, new WatchSourceFiles());
     const loader = new FileLoader(host, config);
     let rootFilesAdded = false;
+    // The build info lists the real paths of the `package.json` files module resolution looked up, as
+    // a compile's does (tsc-cli.ts): those of the threads' lookups are resolved into the file system's cache.
+    const resolvesPackageJsons = incremental && config.configName !== '' && config.buildInfoFileName() !== '';
     session.onIdle = (batch) => {
       if (!rootFilesAdded) rootFilesAdded = loader.addRootFiles(rootFilesPerChunk);
       loader.walkAhead(batch.files);
+      if (resolvesPackageJsons) {
+        const lookups = batch.packageJsons;
+        for (let k = 0; k < lookups.directories.length; k++)
+          if (lookups.exists[k]! || lookups.directoryExists[k]!)
+            fs.realpath(combinePaths(lookups.directories[k]!, 'package.json'));
+      }
+    };
+    // The build info is read while the threads parse, as a compile reads it, or here if they are done first.
+    let buildInfoRead = !incremental;
+    const readBuildInfo = (): void => {
+      if (buildInfoRead) return;
+      buildInfoRead = true;
+      this.snapshot = readBuildInfoProgram(
+        config,
+        new FileBuildInfoReader(new SystemFileSystem(sys)),
+        sys.defaultLibraryPath,
+        sys.currentDirectory,
+      );
+      mark('build info read');
     };
     session.start(config.fileNames, () => {
-      const program = new Program(config, host, loader);
+      readBuildInfo();
+      let program = new Program(config, host, loader);
+      // Where the threads' lookups may miss some `package.json` files of the build info, the program is
+      // loaded again, resolving every file's imports and references itself, as a compile does.
+      if (incremental && !program.hasAllPackageJsonLookups()) {
+        const own = new FileLoader(host, config);
+        own.takesPreparedResolutions = false;
+        program = new Program(config, host, own);
+      }
       // The session's callbacks keep the loader: its tasks go once checking has started.
       releaseLater(loader);
       this.files = this.files.next();
@@ -552,16 +571,25 @@ class Watcher {
         this.files.current.set(watchFileKey(file.fileName, file.path, indicator), file);
       }
       const checked = new CheckedProgram(program);
+      // The incremental program `finishBuild` makes after checking keeps the globals found checking a file
+      // with the file.
+      checked.globalsInFileDiagnostics = true;
       const finish = (): void => {
-        this.finishBuild(checked);
         // Rebuilds parse what changed themselves.
         clearPreparedFiles();
         done();
       };
-      const count = checkerThreads(options.checkers, options.singleThreaded, program);
-      if (count > 1) startParallelCheck(checked, count, finish);
-      else finish();
+      const threads = checkerThreads(options.checkers, options.singleThreaded, program);
+      if (this.snapshot !== undefined && threads > 1) return this.recheckOnThreads(checked, threads, new Map(), finish);
+      const report = (): void => {
+        this.finishBuild(checked);
+        finish();
+      };
+      if (this.snapshot === undefined && threads > 1) startParallelCheck(checked, threads, report);
+      else report();
     });
+    if (incremental && sys.fileExists(config.buildInfoFileName())) session.queueAhead();
+    readBuildInfo();
   }
 
   private configFiles(): string[] {
@@ -650,6 +678,7 @@ class Watcher {
       computeLastSignatures(this.snapshot, this.lastChecked, this.files.parsed);
     this.lastChecked = undefined;
     const checked = new CheckedProgram(program);
+    checked.globalsInFileDiagnostics = true;
     const signatures = new Map<string, string>();
     const threads = this.rebuildThreads(checked, signatures);
     // A new checker for checker threads: `rebuildThreads` may have emitted declarations with this one.
@@ -690,9 +719,9 @@ class Watcher {
    * affects the global scope. A changed file whose declaration file keeps the signature of the last
    * build affects only itself (`getFilesAffectedBy`); its signature is computed with `checked`'s checker
    * and added to `signatures`. That is what the change affects at most; `recheckOnThreads` then takes
-   * what it does affect. A watch whose first config kept it on one thread gave its symbols no ids at
-   * creation (`start`), so its rebuilds, which take the unchanged files of earlier builds, stay on this
-   * thread after a config edit turns checker threads on.
+   * what it does affect. A watch that started without parse threads (`--singleThreaded`) gave its symbols
+   * no ids at creation (`start`), so its rebuilds, which take the unchanged files of earlier builds, stay on
+   * this thread after a config edit turns checker threads on.
    */
   private rebuildThreads(checked: CheckedProgram, signatures: Map<string, string>): number {
     const program = checked.program;

package/src/compiler/tsconfig.ts

@@ -38,6 +38,7 @@ import { ModuleResolutionHost, resolveConfig } from './module-resolution.js';
 import {
   compilerOptionsByName,
   OptionNameMap,
+  optionsForCompiler,
   typeAcquisitionDeclarations,
   type OptionDeclaration,
 } from './option-declarations.js';
@@ -45,6 +46,7 @@ import {
   getAllowJS,
   getResolveJsonModule,
   mergeCompilerOptions,
+  PluginImport,
   setCompilerOption,
   setTypeAcquisitionOption,
   type CompilerOptions,
@@ -72,6 +74,7 @@ import {
   getPathFromPathComponents,
   hasJSFileExtension,
   isDeclarationFileName,
+  isNetworkPathValue,
   isRootedDiskPath,
   normalizePath,
   normalizeSlashes,
@@ -223,6 +226,11 @@ export class ParsedCommandLine implements OutputPathsHost {
   private outputDtsToReference: Map<string, SourceOutputAndProjectReference> | undefined = undefined;
   private commonSourceDirectoryValue: string | undefined = undefined;
   private referencePaths: string[] | undefined = undefined;
+  /**
+   * The config file's JSON, with what the configs it extends add to `files`, `include`, `exclude` and
+   * `compileOnSave`; `undefined` without a config file.
+   */
+  raw: JsonValue | undefined = undefined;
 
   constructor(
     readonly options: CompilerOptions,
@@ -452,6 +460,33 @@ export function findPropertyAssignment(
   return undefined;
 }
 
+/**
+ * A diagnostic at property `propertyName` of the `index`th project reference: at its value, else at the
+ * reference, else a compiler diagnostic. As in tsgo, `index` counts the references the JSON value kept.
+ */
+function diagnosticAtProjectReferenceProperty(
+  file: SourceFile | undefined,
+  index: number,
+  propertyName: string,
+  message: DiagnosticMessage,
+  ...args: string[]
+): Diagnostic {
+  let node: Node | undefined;
+  const root = getTsConfigObjectLiteral(file);
+  if (root !== undefined)
+    for (const property of root.properties.nodes) {
+      if (!(property instanceof PropertyAssignment) || propertyNameText(property.name) !== 'references') continue;
+      const initializer = (property as PropertyAssignment).initializer;
+      if (!(initializer instanceof ArrayLiteralExpression)) continue;
+      const elements = initializer.elements.nodes;
+      if (index >= elements.length || !(elements[index] instanceof ObjectLiteralExpression)) continue;
+      const element = elements[index] as ObjectLiteralExpression;
+      node = findPropertyAssignment(element, propertyName)?.initializer ?? element;
+      break;
+    }
+  return diagnosticAtNode(file, node, message, ...args);
+}
+
 /** The string literal `value` in the array of the root property `key`. */
 export function findTsConfigArrayElement(
   file: SourceFile | undefined,
@@ -490,8 +525,17 @@ export function propertyNameText(name: Node): string | undefined {
 
 // ---- Spec validation
 
-/** Rejects specs ending in `**` (for `include`) and `..` after a `**`. */
-export function specToDiagnostic(spec: string, disallowTrailingRecursion: boolean): DiagnosticMessage | undefined {
+/**
+ * Rejects specs that resolve to a network root (`basePath` given), specs ending in `**` (for `include`) and `..`
+ * after a `**`. `?` is a wildcard in specs, so only UNC and device roots name a network path there.
+ */
+export function specToDiagnostic(
+  spec: string,
+  disallowTrailingRecursion: boolean,
+  basePath?: string,
+): DiagnosticMessage | undefined {
+  if (basePath !== undefined && getNormalizedAbsolutePath(spec, basePath).startsWith('//'))
+    return Diagnostics.Network_path_0_is_not_supported;
   if (disallowTrailingRecursion) {
     const trimmed = spec.endsWith('/') ? spec.slice(0, -1) : spec;
     if (trimmed === '**' || trimmed.endsWith('/**')) {
@@ -509,6 +553,7 @@ export function specToDiagnostic(spec: string, disallowTrailingRecursion: boolea
 function validateSpecs(
   specs: readonly JsonValue[],
   disallowTrailingRecursion: boolean,
+  basePath: string,
   file: SourceFile,
   key: string,
   errors: Diagnostic[],
@@ -516,7 +561,7 @@ function validateSpecs(
   const result: string[] = [];
   for (const spec of specs) {
     if (typeof spec !== 'string') continue;
-    const message = specToDiagnostic(spec, disallowTrailingRecursion);
+    const message = specToDiagnostic(spec, disallowTrailingRecursion, basePath);
     if (message === undefined) result.push(spec);
     else errors.push(diagnosticAtNode(file, findTsConfigArrayElement(file, key, spec), message, spec));
   }
@@ -763,6 +808,8 @@ class ConfigFileConverter {
   readonly options: CompilerOptions;
   readonly typeAcquisition: TypeAcquisition = {};
   extendedConfigPaths: string[] | undefined = undefined;
+  /** Names of compiler options written at the root instead of in `compilerOptions`. */
+  readonly rootCompilerOptions: Node[] = [];
 
   constructor(
     private readonly parser: ConfigParser,
@@ -797,7 +844,9 @@ class ConfigFileConverter {
         }
       }
       const name = getBaseFileName(this.file.fileName) === 'jsconfig.json' ? 'jsconfig.json' : 'tsconfig.json';
-      this.errors.push(createCompilerDiagnostic(Diagnostics.The_root_value_of_a_0_file_must_be_an_object, name));
+      this.errors.push(
+        diagnosticAtNode(this.file, root, Diagnostics.The_root_value_of_a_0_file_must_be_an_object, name),
+      );
       return new JsonObject();
     }
     return this.convertObject(root, rootDeclaration);
@@ -932,10 +981,16 @@ class ConfigFileConverter {
           this.file,
           this.errors,
         );
-      } else if (option === undefined && key === 'excludes') {
-        this.errors.push(
-          diagnosticAtNode(this.file, property.name, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude),
-        );
+      } else if (option === undefined) {
+        if (key === 'excludes')
+          this.errors.push(
+            diagnosticAtNode(this.file, property.name, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude),
+          );
+        for (const compilerOption of optionsForCompiler)
+          if (compilerOption.name === key) {
+            this.rootCompilerOptions.push(property.name);
+            break;
+          }
       }
     }
   }
@@ -949,6 +1004,14 @@ function setCompilerOptionFromJson(options: CompilerOptions, option: OptionDecla
     options.paths = paths;
     return;
   }
+  if (option.name === 'plugins') {
+    if (!(value instanceof JsonArray)) return;
+    options.plugins = value.items.map((item) => {
+      const name = item instanceof JsonObject ? item.entries.get('name') : undefined;
+      return new PluginImport(typeof name === 'string' ? name : '');
+    });
+    return;
+  }
   setCompilerOption(options, option.name, toOptionValue(option, value));
 }
 
@@ -1063,20 +1126,41 @@ export class ConfigParser {
     let validatedIncludeBeforeSubstitution: string[] = [];
     let validatedInclude: string[] = [];
     if (include.items !== undefined) {
-      validatedIncludeBeforeSubstitution = validateSpecs(include.items, true, file.sourceFile, 'include', errors);
+      validatedIncludeBeforeSubstitution = validateSpecs(
+        include.items,
+        true,
+        basePathForFileNames,
+        file.sourceFile,
+        'include',
+        errors,
+      );
       validatedInclude =
         substituteConfigDirInList(validatedIncludeBeforeSubstitution, basePathForFileNames) ??
         validatedIncludeBeforeSubstitution;
     }
     let validatedExclude: string[] = [];
     if (exclude.items !== undefined) {
-      validatedExclude = validateSpecs(exclude.items, false, file.sourceFile, 'exclude', errors);
+      validatedExclude = validateSpecs(exclude.items, false, basePathForFileNames, file.sourceFile, 'exclude', errors);
       validatedExclude = substituteConfigDirInList(validatedExclude, basePathForFileNames) ?? validatedExclude;
     }
     let validatedFilesBeforeSubstitution: string[] = [];
     let validatedFiles: string[] = [];
     if (files.items !== undefined) {
-      for (const spec of files.items) if (typeof spec === 'string') validatedFilesBeforeSubstitution.push(spec);
+      for (const spec of files.items) {
+        if (typeof spec !== 'string') continue;
+        if (isNetworkPathValue(spec, basePathForFileNames)) {
+          errors.push(
+            diagnosticAtNode(
+              file.sourceFile,
+              findTsConfigArrayElement(file.sourceFile, 'files', spec),
+              Diagnostics.Network_path_0_is_not_supported,
+              spec,
+            ),
+          );
+          continue;
+        }
+        validatedFilesBeforeSubstitution.push(spec);
+      }
       validatedFiles =
         substituteConfigDirInList(validatedFilesBeforeSubstitution, basePathForFileNames) ??
         validatedFilesBeforeSubstitution;
@@ -1118,18 +1202,67 @@ export class ConfigParser {
 
     const projectReferences: ProjectReference[] = [];
     if (references.items !== undefined) {
-      for (const reference of references.items) {
+      const items = references.items;
+      for (let index = 0; index < items.length; index++) {
+        const reference = items[index];
         if (!(reference instanceof JsonObject)) continue;
         const path = reference.entries.get('path');
+        if (typeof path !== 'string') {
+          errors.push(
+            diagnosticAtProjectReferenceProperty(
+              file.sourceFile,
+              index,
+              'path',
+              Diagnostics.Compiler_option_0_requires_a_value_of_type_1,
+              'reference.path',
+              'string',
+            ),
+          );
+          continue;
+        }
+        if (path === '') {
+          errors.push(
+            diagnosticAtProjectReferenceProperty(
+              file.sourceFile,
+              index,
+              'path',
+              Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string,
+              'reference.path',
+            ),
+          );
+          continue;
+        }
+        if (isNetworkPathValue(path, basePathForFileNames)) {
+          errors.push(
+            diagnosticAtProjectReferenceProperty(
+              file.sourceFile,
+              index,
+              'path',
+              Diagnostics.Network_path_0_is_not_supported,
+              path,
+            ),
+          );
+          continue;
+        }
         const circular = reference.entries.get('circular');
-        if (typeof path !== 'string' || path === '') continue;
+        if (circular !== undefined && typeof circular !== 'boolean')
+          errors.push(
+            diagnosticAtProjectReferenceProperty(
+              file.sourceFile,
+              index,
+              'circular',
+              Diagnostics.Compiler_option_0_requires_a_value_of_type_1,
+              'reference.circular',
+              'boolean',
+            ),
+          );
         projectReferences.push(
           new ProjectReference(getNormalizedAbsolutePath(path, basePathForFileNames), path, circular === true),
         );
       }
     }
 
-    return new ParsedCommandLine(
+    const parsedCommandLine = new ParsedCommandLine(
       options,
       parsed.typeAcquisition,
       fileNames,
@@ -1140,6 +1273,8 @@ export class ConfigParser {
       cs,
       literalFiles.size,
     );
+    parsedCommandLine.raw = raw;
+    return parsedCommandLine;
   }
 
   /** A config file's options with what it extends applied. */
@@ -1159,6 +1294,17 @@ export class ConfigParser {
 
     const converter = new ConfigFileConverter(this, file.sourceFile, basePath, configFileName, errors);
     const raw = converter.convertRoot();
+    // A compiler option at the root is reported once, unless there's a `compilerOptions` too.
+    const rootOption = converter.rootCompilerOptions.length > 0 ? converter.rootCompilerOptions[0] : undefined;
+    if (rootOption !== undefined && raw instanceof JsonObject && !raw.entries.has('compilerOptions'))
+      errors.push(
+        diagnosticAtNode(
+          file.sourceFile,
+          rootOption,
+          Diagnostics.X_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file,
+          propertyNameText(rootOption) ?? '',
+        ),
+      );
     const own = new OwnConfig(raw, converter.options, converter.typeAcquisition, converter.extendedConfigPaths);
     const ownOptions = converter.options;
     // `paths` may be inherited, so remember which directory it is relative to.
@@ -1303,6 +1449,10 @@ export class ConfigParser {
     }
     const validated = validateOptionValue(option, value, valueExpression, file, errors);
     if (validated === null || option.isFilePath !== true || typeof validated !== 'string') return validated;
+    if (isNetworkPathValue(validated, basePath)) {
+      errors.push(diagnosticAtNode(file, valueExpression, Diagnostics.Network_path_0_is_not_supported, validated));
+      return null;
+    }
     let path = normalizeSlashes(validated);
     if (!startsWithConfigDirTemplate(path)) path = getNormalizedAbsolutePath(path, basePath);
     return path === '' ? '.' : path;
@@ -1375,6 +1525,10 @@ export class ConfigParser {
     errors: Diagnostic[],
   ): string {
     extendedConfig = normalizeSlashes(extendedConfig);
+    if (isNetworkPathValue(extendedConfig, basePath)) {
+      errors.push(diagnosticAtNode(file, valueExpression, Diagnostics.Network_path_0_is_not_supported, extendedConfig));
+      return '';
+    }
     if (isRootedDiskPath(extendedConfig) || extendedConfig.startsWith('./') || extendedConfig.startsWith('../')) {
       let path = getNormalizedAbsolutePath(extendedConfig, basePath);
       if (!this.fs.fileExists(path) && !path.endsWith('.json')) {
@@ -1415,25 +1569,28 @@ export class ConfigParser {
     const wildcardJsonFiles = new Map<string, string>();
     const supportedExtensions = getSupportedExtensions(options);
     const extensionsWithJson = getSupportedExtensionsWithJsonIfResolveJsonModule(options);
-    // Keys of literal files are the specs as written, as in tsgo.
+    // Literal files are keyed by path, so `a.ts` and `./a.ts` are one file, also when `include` matches it.
     for (const fileName of specs.validatedFilesSpec) {
-      literalFiles.set(getCanonicalFileName(fileName, cs), getNormalizedAbsolutePath(fileName, basePath));
+      const file = getNormalizedAbsolutePath(fileName, basePath);
+      literalFiles.set(getCanonicalFileName(file, cs), file);
     }
     if (onRootFile !== undefined) for (const fileName of literalFiles.values()) onRootFile(fileName);
 
     const includes = specs.validatedIncludeSpecs;
     if (includes.length > 0) {
-      // Matches go to `onRootFile` a directory at a time, without those that a file of the same name
-      // with a higher priority extension leaves out below.
+      // Matches go to `onRootFile` a directory at a time, without the literal files, which it has, and those that a
+      // file of the same name with a higher priority extension leaves out below.
       let directory = '';
       let pending: string[] = [];
       const flush = (): void => {
         if (onRootFile === undefined || pending.length === 0) return;
         const siblings = new Map<string, string>();
         for (const file of pending) siblings.set(getCanonicalFileName(file, cs), file);
-        for (const file of pending)
+        for (const file of pending) {
+          if (literalFiles.has(getCanonicalFileName(file, cs))) continue;
           if (!hasFileWithHigherPriorityExtension(file, supportedExtensions, literalFiles, siblings, cs))
             onRootFile(file);
+        }
         pending = [];
       };
       const onMatch =

package/src/compiler/type-printer.ts

@@ -29,7 +29,26 @@ export function typeToString(c: Checker, t: Type, enclosingDeclaration?: Node, f
   // Without explicit flags, unique symbols print as such and aliases from other scopes are used.
   const formatFlags =
     flags ?? NodeBuilderFlags.AllowUniqueESSymbolType | NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope;
-  return typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+  // Prints nested in a serialization depend on its depth (typeToStringFromTypeNode), so only the others are kept.
+  if (c.serializationLevel !== 0) return typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+  // The variance check in progress names the marker types (`sub-T`, `super-T`) after its type parameter.
+  const variance = c.varianceTypeParameter;
+  const key =
+    String(t.id) +
+    ',' +
+    String(enclosingDeclaration === undefined ? 0 : enclosingDeclaration.id) +
+    ',' +
+    String(formatFlags) +
+    ',' +
+    String(variance === undefined ? 0 : variance.id);
+  const cached = c.typeStrings.get(key);
+  if (cached !== undefined) return cached;
+  // A print that creates no types reads only types that exist and settled state, so printing again gives the same
+  // text and creates nothing; prints that create types run each time, as in tsgo, so type ids stay in tsgo's order.
+  const typeCount = c.typeCount;
+  const text = typeToStringFromTypeNode(c, t, enclosingDeclaration, formatFlags) ?? '';
+  if (c.typeCount === typeCount) c.typeStrings.set(key, text);
+  return text;
 }
 
 /** `symbol` as text: the expression naming it, as seen from `enclosingDeclaration` if given. */
@@ -39,12 +58,27 @@ export function symbolToString(
   enclosingDeclaration?: Node,
   internalFlags: NodeBuilderInternalFlags = NodeBuilderInternalFlags.None,
 ): string {
+  // Kept as typeToString keeps type prints: outside serializations, when printing created no types.
+  const key = String(enclosingDeclaration === undefined ? 0 : enclosingDeclaration.id) + ',' + String(internalFlags);
+  const kept = c.serializationLevel === 0 ? c.symbolStrings.get(symbol) : undefined;
+  const cached = kept?.get(key);
+  if (cached !== undefined) return cached;
+  const typeCount = c.typeCount;
   const b = new NodeBuilder(c, enclosingDeclaration, NodeBuilderFlags.IgnoreErrors, internalFlags, undefined);
-  return printSingleLine(
+  const text = printSingleLine(
     b,
     symbolToExpression(b, symbol, SymbolFlags.All),
     enclosingDeclaration !== undefined && enclosingDeclaration.kind === SyntaxKind.SourceFile,
   );
+  if (c.serializationLevel === 0 && c.typeCount === typeCount) {
+    let byKey = kept;
+    if (byKey === undefined) {
+      byKey = new Map<string, string>();
+      c.symbolStrings.set(symbol, byKey);
+    }
+    byKey.set(key, text);
+  }
+  return text;
 }
 
 /** `signature` as text: a call or construct signature without its trailing semicolon. */

package/src/compiler/types.ts

@@ -70,10 +70,11 @@ export const enum ScriptTarget {
   ES2023 = 10,
   ES2024 = 11,
   ES2025 = 12,
+  ES2026 = 13,
   ESNext = 99,
   JSON = 100,
   Latest = ESNext,
-  LatestStandard = ES2025,
+  LatestStandard = ES2026,
 }
 
 export const enum LanguageVariant {