tsc-ts 0.0.9 → 0.1.0

package/src/compiler/checker.ts

@@ -29,13 +29,26 @@
 // | checker-elaboration.ts          | reporting relation errors at the failing subexpression  |
 // | checker-grammar.ts              | grammar checks                                          |
 // | checker-flow.ts                 | control flow narrowing                                  |
-import type { DeferredCollisionCheck } from './checker-generated-code.js';
+import type { ModuleSpecifierResult } from './node-builder-names.js';
 import type { EmitHelperFileLinks } from './checker-emit-helpers.js';
 import { sideOf } from './side-state.js';
 import type { Node, PatternAmbientModule, SourceFile } from './ast.js';
-import { CompactSymbolLinkTable, IntLinkTable, LinkTable, PagedIdSet, SparseLinkTable } from './link-tables.js';
+import {
+  CompactIntLinkTable,
+  CompactLinkTable,
+  IntLinkTable,
+  LinkTable,
+  PagedIdSet,
+  SparseLinkTable,
+} from './link-tables.js';
 import { getErrorRangeForNode, getSourceFileOfNode } from './binder-utilities.js';
-import { Diagnostic, type DiagnosticMessage, Diagnostics, compareDiagnostics } from './diagnostics.js';
+import {
+  Diagnostic,
+  type DiagnosticMessage,
+  Diagnostics,
+  compareDiagnostics,
+  equalDiagnostics,
+} from './diagnostics.js';
 import {
   type CompilerOptions,
   ModuleKind,
@@ -51,6 +64,7 @@ import {
   IntrinsicType,
   LiteralType,
   MemberNames,
+  NamedMemberOrder,
   NodeLinks,
   ObjectFlags,
   ObjectType,
@@ -70,6 +84,8 @@ import {
   type ConditionalType,
   type InterfaceType,
   type TypeChecking,
+  type ConditionalResultKey,
+  type DistributedConditional,
 } from './checker-types.js';
 import { getBaseTypes } from './checker-declared-types.js';
 import type { ModuleResolution } from './checker-modules.js';
@@ -101,19 +117,28 @@ import {
   mergeAmbientModulesAndAugmentations,
 } from './checker-symbols.js';
 import { PermissiveMapper, ReportingMapper, RestrictiveMapper, UniqueLiteralMapper } from './instantiation.js';
-import { Relation, RelationKey, type InternedRelationKey, type Relater, TypeComparer } from './relations.js';
-import { TypeNodeVisitor, checkSourceFile } from './checker-source-file.js';
+import {
+  Relation,
+  RelationKey,
+  type InternedRelationKey,
+  type Relater,
+  TypeComparer,
+  type VarianceStackEntry,
+} from './relations.js';
+import { TypeNodeVisitor, checkSourceFile, produceDeferredDiagnostics } from './checker-source-file.js';
+import { checkObjectLiteralDeprecations } from './checker-deprecation.js';
 import { InferenceCaches } from './checker-inference.js';
 import { AssignmentMarker, type FlowLoopInfo, type FlowState, type FlowWalk } from './checker-narrowing.js';
 import type { FlowNode, FlowReduceLabel } from './flow.js';
 import { JsxState } from './checker-jsx.js';
-import type { DeferredIterationError, IterationTypes } from './checker-iteration.js';
+import type { IterationTypes } from './checker-iteration.js';
 import type { SpreadIndices } from './checker-contextual.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile } from './program-utilities.js';
 import type { GrammarChecker } from './checker-grammar.js';
 import type { ResolvedModule } from './module-resolution-types.js';
 import type { ModuleSpecifierHost } from './module-specifiers.js';
 import type { PropertyListIndex } from './checker-members.js';
+import { shareThreads, startThreadSharing, type ThreadSharing } from './shared-results.js';
 
 /** What the checker needs from a program. */
 export abstract class CheckerHost {
@@ -186,22 +211,36 @@ export abstract class CheckerHost {
   }
 }
 
-/** Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection. */
+/**
+ * Per-file and global diagnostics, sorted on read like tsgo's DiagnosticsCollection, which keeps one of
+ * each set of equal diagnostics.
+ */
 class DiagnosticCollection {
   private readonly byFile = new Map<string, Diagnostic[]>();
   private readonly sortedFiles = new Set<string>();
   private readonly global: Diagnostic[] = [];
   private globalSorted = true;
-  /** The diagnostics added since `startLog`, while recording. */
+  /** The diagnostics at each file, position, end and code, to find an equal one when adding. */
+  private readonly byLocation = new Map<string, Diagnostic[]>();
+  /** The diagnostics reported since `startLog`, while recording, also those equal to one already added. */
   private log: Diagnostic[] | undefined = undefined;
 
-  add(diagnostic: Diagnostic): void {
+  /** Adds `diagnostic` unless an equal one was added; returns the one the collection holds. */
+  add(diagnostic: Diagnostic): Diagnostic {
     if (this.log !== undefined) this.log.push(diagnostic);
+    if (this.added !== undefined) this.added.push(diagnostic);
     const file = diagnostic.file;
+    const key = `${file === undefined ? '' : file.fileName}\0${diagnostic.pos}\0${diagnostic.end}\0${diagnostic.code}`;
+    const existing = this.byLocation.get(key);
+    if (existing === undefined) this.byLocation.set(key, [diagnostic]);
+    else {
+      for (const d of existing) if (equalDiagnostics(d, diagnostic)) return d;
+      existing.push(diagnostic);
+    }
     if (file === undefined) {
       this.global.push(diagnostic);
       this.globalSorted = false;
-      return;
+      return diagnostic;
     }
     let list = this.byFile.get(file.fileName);
     if (list === undefined) {
@@ -210,6 +249,7 @@ class DiagnosticCollection {
     }
     list.push(diagnostic);
     this.sortedFiles.delete(file.fileName);
+    return diagnostic;
   }
 
   forFile(fileName: string): Diagnostic[] {
@@ -245,6 +285,44 @@ class DiagnosticCollection {
     return this.global.slice();
   }
 
+  /** The global diagnostics `withoutNewGlobals` removed. */
+  removedGlobals = 0;
+  /** Where results are shared between checker threads (shared-results.ts): every diagnostic added, in order. */
+  added: Diagnostic[] | undefined = undefined;
+
+  /** Runs `run`, then removes the global diagnostics it added. */
+  withoutNewGlobals<T>(run: () => T): T {
+    const outer = this.log;
+    const added: Diagnostic[] = [];
+    this.log = added;
+    try {
+      return run();
+    } finally {
+      this.log = outer;
+      if (outer !== undefined) for (const d of added) outer.push(d);
+      const globals = new Set<Diagnostic>();
+      for (const d of added) if (d.file === undefined) globals.add(d);
+      if (globals.size > 0) {
+        let kept = 0;
+        for (const d of this.global) {
+          if (!globals.has(d)) this.global[kept++] = d;
+          else this.forget(d);
+        }
+        this.removedGlobals += this.global.length - kept;
+        this.global.length = kept;
+      }
+    }
+  }
+
+  /** Removes the global diagnostic `diagnostic` from the location index. */
+  private forget(diagnostic: Diagnostic): void {
+    const key = `\0${diagnostic.pos}\0${diagnostic.end}\0${diagnostic.code}`;
+    const existing = this.byLocation.get(key);
+    if (existing === undefined) return;
+    const at = existing.indexOf(diagnostic);
+    if (at >= 0) existing.splice(at, 1);
+  }
+
   /** Records the diagnostics added from now on. */
   startLog(): void {
     this.log = [];
@@ -336,10 +414,20 @@ export class Checker implements TypeChecking {
   readonly memberPositionsInLists = new Map<Symbol[], Map<string, number>>();
   /** The property names of the last instantiation of each such list whose table is built on demand. */
   readonly memberNamesOfLists = new Map<Symbol[], MemberNames>();
+  /** The property order of the instantiations of each such list (`NamedMemberOrder`); null where it has none. */
+  readonly namedMemberOrdersOfLists = new Map<Symbol[], NamedMemberOrder | null>();
   /** Long lists of inherited properties, by name. */
   readonly propertiesByName = new Map<Symbol[], Map<string, Symbol>>();
   /** Number of `typeToString` calls in progress. */
   serializationLevel = 0;
+  /**
+   * `typeToString` results by type, enclosing declaration, flags and the type parameter of the variance check in
+   * progress: the prints that created no types, which a later print with the same inputs repeats exactly
+   * (`typeToString`).
+   */
+  readonly typeStrings = new Map<string, string>();
+  /** `symbolToString` results by symbol, then by enclosing declaration and flags, kept as `typeStrings` are. */
+  readonly symbolStrings = new Map<Symbol, Map<string, string>>();
   /** Whether `globalObjectType` is set; global type lookups before it can't suggest `typeof`. */
   hasGlobalObjectType = false;
   /** The node being checked, for errors with no better location. */
@@ -357,7 +445,7 @@ export class Checker implements TypeChecking {
    */
   modulesMerged = false;
   /** Module specifiers of `import("…")` types, by module symbol id, importing file path and resolution mode. */
-  readonly moduleSpecifiers = new Map<string, string>();
+  readonly moduleSpecifiers = new Map<string, ModuleSpecifierResult>();
   /** Specifier generation for hosts without a program. */
   fallbackModuleSpecifierHost: ModuleSpecifierHost | undefined = undefined;
 
@@ -375,6 +463,9 @@ export class Checker implements TypeChecking {
    * so far; null where a list repeats a name.
    */
   readonly propertyListIndexes = new Map<Symbol[], PropertyListIndex | number | null>();
+  // Types, targets and mappers of symbols keep a slot per id: they are dense enough, and read on hot
+  // paths. The other symbol columns, which most symbols leave empty, keep only their values
+  // (CompactLinkTable).
   /** The type of a value symbol. */
   readonly symbolTypes = new LinkTable<Type>();
   /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -382,24 +473,24 @@ export class Checker implements TypeChecking {
   /** The mapper of an instantiated symbol or a mapped type property. */
   readonly symbolMappers = new LinkTable<TypeMapper>();
   /** The literal type of a property name. */
-  readonly symbolNameTypes = new LinkTable<Type>();
+  readonly symbolNameTypes = new CompactLinkTable<Type>();
   /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
-  readonly symbolContainingTypes = new LinkTable<Type>();
+  readonly symbolContainingTypes = new CompactLinkTable<Type>();
   /** The key type of a mapped type property. */
-  readonly symbolKeyTypes = new LinkTable<Type>();
+  readonly symbolKeyTypes = new CompactLinkTable<Type>();
   /** The property a mapped, spread or synthetic property comes from. */
-  readonly symbolSyntheticOrigins = new LinkTable<Symbol>();
+  readonly symbolSyntheticOrigins = new CompactLinkTable<Symbol>();
   /** The left and right properties a spread property combines. */
-  readonly symbolLeftSpreads = new LinkTable<Symbol>();
-  readonly symbolRightSpreads = new LinkTable<Symbol>();
+  readonly symbolLeftSpreads = new CompactLinkTable<Symbol>();
+  readonly symbolRightSpreads = new CompactLinkTable<Symbol>();
   /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
-  readonly symbolReferenceKinds = new IntLinkTable();
+  readonly symbolReferenceKinds = new CompactIntLinkTable();
   /** The resolved symbol of an identifier, entity name or call. */
-  readonly resolvedSymbols = new CompactSymbolLinkTable();
+  readonly resolvedSymbols = new CompactLinkTable<Symbol>();
   /** The resolved type of a type node or expression. */
-  readonly resolvedTypes = new SparseLinkTable<Type>();
+  readonly resolvedTypes = new CompactLinkTable<Type>();
   /** The resolved signature of a call-like node or a signature declaration. */
-  readonly resolvedSignatures = new SparseLinkTable<Signature>();
+  readonly resolvedSignatures = new CompactLinkTable<Signature>();
   /** Merged symbols, indexed by the id of the symbol merged into them. */
   readonly mergedSymbols: Map<number, Symbol>;
   /**
@@ -576,15 +667,21 @@ export class Checker implements TypeChecking {
 
   // Resolution stacks for cycle detection (see pushTypeResolution).
   resolutionStart = 0;
-  inVarianceComputation = false;
+  /** The generic types whose variances are being computed, outermost first. */
+  varianceStack: VarianceStackEntry[] = [];
 
   // Instantiation
   instantiationDepth = 0;
+  /** The types being instantiated, outermost first: the first `instantiationDepth` entries are current. */
+  readonly instantiationStack: Type[] = [];
+  /** The calls being resolved, outermost first: the first `callResolutionDepth` entries are current. */
+  readonly callResolutionStack: Node[] = [];
+  callResolutionDepth = 0;
   instantiationCount = 0;
   /** Instantiations over the checker's lifetime (statistics). */
   totalInstantiations = 0;
-  /** Mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
-  readonly activeMappers: TypeMapper[] = [];
+  /** Ids of the mappers of the instantiations in progress: the first `activeMapperDepth` entries are live. */
+  activeMapperIds = new Int32Array(16);
   activeMapperDepth = 0;
   /** Per active mapper: its instantiations by type id, created on the first nested write. */
   readonly activeMapperCaches: (Map<number, Type> | undefined)[] = [];
@@ -599,21 +696,35 @@ export class Checker implements TypeChecking {
   /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
   readonly freeTypeLists: Type[][] = [];
   /**
-   * 1 by type id for the anonymous and mapped types whose declaration has no outer type parameters
+   * The ids of the anonymous and mapped types whose declaration has no outer type parameters
    * to instantiate (`getObjectTypeInstantiation`).
    */
-  readonly withoutOuterTypeParameters = new IntLinkTable();
+  readonly withoutOuterTypeParameters = new PagedIdSet();
   conditionalConstraintDepth = 0;
 
   readonly suggestionResolver: SuggestionNameResolver;
   readonly awaitedTypeStack: number[] = [];
   /** Iteration types by type id and iteration use. */
   readonly iterationTypesCache = new Map<number, IterationTypes>();
-  /** Whether diagnostics can be deferred to the end of the file being checked. */
-  saveDeferredDiagnostics = false;
-  deferredIterationErrors: DeferredIterationError[] = [];
-  /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
-  deferredCollisionChecks: DeferredCollisionCheck[] = [];
+  /**
+   * Diagnostics reported after the checks of the file being checked, or before the next global
+   * diagnostics are read, in the order they were deferred. Reporting them earlier could resolve types
+   * that are being resolved.
+   */
+  deferredDiagnostics: (() => void)[] = [];
+
+  /** Defers the diagnostic `report` reports at `node` (`deferredDiagnostics`). */
+  deferDiagnostic(node: Node, report: () => void): void {
+    this.deferredDiagnostics.push(report);
+    if (this.deferredDiagnosticFiles !== undefined)
+      this.deferredDiagnosticFiles.push(getSourceFileOfNode(node).fileName);
+  }
+
+  /**
+   * The checked object literals of each file whose members may set deprecated properties of their contextual
+   * types, reported when the file's suggestion diagnostics are asked for (`checkObjectLiteralDeprecations`).
+   */
+  readonly objectLiteralsForDeprecations = new Map<SourceFile, Node[]>();
   /** Binding patterns whose implied type is being computed as a contextual type. */
   readonly contextualBindingPatterns: Node[] = [];
   /** The binding pattern or assignment pattern that implied each type. */
@@ -666,11 +777,13 @@ export class Checker implements TypeChecking {
   flowTypeCache: Map<Node, Type> | undefined = undefined;
   flowInvocationCount = 0;
   /** The reduce labels being passed, innermost last; each limits its target label's antecedents. */
-  readonly flowReduceLabels: FlowReduceLabel[] = [];
+  flowReduceLabels: FlowReduceLabel[] = [];
   readonly flowNodeReachable = new Map<FlowNode, boolean>();
   readonly flowNodePostSuper = new Map<FlowNode, boolean>();
   lastFlowNode: FlowNode | undefined = undefined;
   lastFlowNodeReachable = false;
+  /** Symbols whose explicit type is being found, for flow analysis of self-referential `for...of`. */
+  readonly resolvingExplicitTypeOfSymbol = new Set<Symbol>();
   readonly assignmentMarker: AssignmentMarker;
   readonly primitiveTypeAliasSuggestions = new Map<string, Symbol>();
 
@@ -697,6 +810,9 @@ export class Checker implements TypeChecking {
   readonly ambientModuleSymbols: Symbol[] = [];
   readonly patternAmbientModules: PatternAmbientModule[] = [];
   readonly patternAmbientModuleAugmentations = new Map<string, Symbol>();
+  /** The pattern module each entry of `patternAmbientModuleAugmentations` augments. */
+  readonly patternAmbientModuleAugmentationTargets = new Map<string, Symbol>();
+  readonly moduleImportAttributesTypes = new Map<Symbol, Type>();
 
   readonly inferenceCaches = new InferenceCaches();
   /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
@@ -706,6 +822,28 @@ export class Checker implements TypeChecking {
   resolutionDepth = 0;
   /** The number of resolution cycles found (`pushTypeResolution`). */
   resolutionCycleCount = 0;
+  /**
+   * While an `inferTypesFromUnstarted` walk runs: the unions and intersections whose properties
+   * `hasUnmatchedProperty` searched before they were resolved. Such a search creates fewer types
+   * than one of the resolved properties.
+   */
+  unresolvedPropertySearches: Type[] | undefined = undefined;
+  // The fields of shared results come last, so the fields before keep their places.
+  /** TSC_TS_SHARE: the checker thread's sharing with the other checker threads. */
+  threadSharing: ThreadSharing | undefined = undefined;
+  /**
+   * Where results are shared (shared-results.ts): for each conditional type made as a member of the distribution of a
+   * conditional type instantiation, that instantiation and the constituent it is for.
+   */
+  distributedConditionals: Map<Type, DistributedConditional> | undefined = undefined;
+  /** The same members by `distributedKey`. */
+  distributedByKey: Map<string, Type> | undefined = undefined;
+  /** The conditional types conditional type instantiations resolved to, with the instantiation's root and key. */
+  conditionalResults: Map<Type, ConditionalResultKey> | undefined = undefined;
+  /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
+  indexedAccessKeyFlags: Map<Type, number> | undefined = undefined;
+  /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
+  deferredDiagnosticFiles: string[] | undefined = undefined;
 
   constructor(host: CheckerHost) {
     this.host = host;
@@ -918,6 +1056,13 @@ export class Checker implements TypeChecking {
     mergeAmbientModulesAndAugmentations(this);
     this.modulesMerged = true;
     this.mergeDiagnostics.push(this.diagnostics.takeLog(), this.suggestionDiagnostics.takeLog());
+    if (shareThreads) startThreadSharing(this);
+    if (this.threadSharing !== undefined) {
+      this.distributedConditionals = new Map<Type, DistributedConditional>();
+      this.distributedByKey = new Map<string, Type>();
+      this.conditionalResults = new Map<Type, ConditionalResultKey>();
+      this.indexedAccessKeyFlags = new Map<Type, number>();
+    }
   }
 
   // ---- Public API
@@ -932,14 +1077,29 @@ export class Checker implements TypeChecking {
   /** Checks `file`, including unused identifiers, and returns its suggestion diagnostics. */
   getSuggestionDiagnostics(file: SourceFile): Diagnostic[] {
     checkSourceFile(this, file, true);
+    checkObjectLiteralDeprecations(this, file);
     return this.suggestionDiagnostics.forFile(file.fileName);
   }
 
   /** Diagnostics without a file, such as missing global types. */
   getGlobalDiagnostics(): Diagnostic[] {
+    produceDeferredDiagnostics(this);
     return this.diagnostics.globals();
   }
 
+  /**
+   * Runs `run` (such as emitting declarations), then forgets the global diagnostics it reported:
+   * the program collects global diagnostics before it emits.
+   */
+  withoutGlobalDiagnostics<T>(run: () => T): T {
+    return this.diagnostics.withoutNewGlobals(run);
+  }
+
+  /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+  forgottenGlobalDiagnostics(): number {
+    return this.diagnostics.removedGlobals;
+  }
+
   // ---- Links
 
   /** The rarely used links of `symbol`, created on first use. */
@@ -1043,15 +1203,15 @@ export class Checker implements TypeChecking {
 
   /** Reports `message` at `node`, or as a global diagnostic without a node. */
   error(node: Node | undefined, message: DiagnosticMessage, ...args: string[]): Diagnostic {
-    const diagnostic = createDiagnosticForNode(node, message, args);
-    this.addDiagnostic(diagnostic);
-    return diagnostic;
+    return this.addDiagnostic(createDiagnosticForNode(node, message, args));
   }
 
-  addDiagnostic(diagnostic: Diagnostic): void {
+  /** Reports `diagnostic`; returns the equal diagnostic already reported, if any, else `diagnostic`. */
+  addDiagnostic(diagnostic: Diagnostic): Diagnostic {
     this.reports++;
     // Discard diagnostics created while at the maximum number of nested typeToString calls.
-    if (this.serializationLevel < maxSerializationLevel) this.diagnostics.add(diagnostic);
+    if (this.serializationLevel < maxSerializationLevel) return this.diagnostics.add(diagnostic);
+    return diagnostic;
   }
 
   addSuggestion(diagnostic: Diagnostic): void {
@@ -1097,6 +1257,7 @@ export function disposeChecker(c: Checker): void {
   c.sharedSymbolCopies.clear();
   c.memberPositionsInLists.clear();
   c.memberNamesOfLists.clear();
+  c.namedMemberOrdersOfLists.clear();
   c.propertiesByName.clear();
   c.symbolAccessibilityCaches = undefined;
   c.unresolvedSymbols.clear();
@@ -1122,8 +1283,8 @@ export function disposeChecker(c: Checker): void {
   c.cachedTypesById.clear();
   c.cachedTypesByPair.clear();
   c.iterationTypesCache.clear();
-  c.deferredIterationErrors = [];
-  c.deferredCollisionChecks = [];
+  c.deferredDiagnostics = [];
+  c.objectLiteralsForDeprecations.clear();
   c.errorTypes.clear();
   c.globalTypeCache.clear();
   c.globalSymbolCache.clear();
@@ -1134,8 +1295,11 @@ export function disposeChecker(c: Checker): void {
   c.flowNodePostSuper.clear();
   c.primitiveTypeAliasSuggestions.clear();
   c.patternAmbientModuleAugmentations.clear();
+  c.patternAmbientModuleAugmentationTargets.clear();
+  c.moduleImportAttributesTypes.clear();
   c.sharedFlowTypes.length = 0;
   c.relationComparers = [];
+  c.inferenceCaches.unstartedInferences.clear();
 }
 
 export const enum VarianceReporting {

package/src/compiler/command-line.ts

@@ -8,20 +8,18 @@ import {
   buildOption,
   buildOptionsByName,
   compilerOptionsByName,
-  watchOptionsByName,
   type OptionDeclaration,
   type OptionNameMap,
 } from './option-declarations.js';
 import {
   setBuildOption,
   setCompilerOption,
-  setWatchOption,
   type BuildOptions,
   type CompilerOptions,
   type OptionValue,
-  type WatchOptions,
 } from './options.js';
-import { getNormalizedAbsolutePath } from './path.js';
+import { getNormalizedAbsolutePath, isNetworkPathValue } from './path.js';
+import { getSpellingSuggestion } from './spelling.js';
 
 /** Reads response files. */
 export abstract class CommandLineHost {
@@ -33,7 +31,6 @@ export abstract class CommandLineHost {
 
 export interface ParsedCommandLine {
   readonly options: CompilerOptions;
-  readonly watchOptions: WatchOptions;
   readonly fileNames: readonly string[];
   readonly errors: readonly Diagnostic[];
   /** Options as written, keyed by declaration name in first-seen order. Paths are not made absolute. */
@@ -44,7 +41,6 @@ export interface ParsedBuildCommandLine {
   readonly buildOptions: BuildOptions;
   /** Only options shared with `tsc`, and `build`. */
   readonly compilerOptions: CompilerOptions;
-  readonly watchOptions: WatchOptions;
   /** Project paths as given; `["."]` if none. */
   readonly projects: readonly string[];
   readonly errors: readonly Diagnostic[];
@@ -55,6 +51,8 @@ export interface ParsedBuildCommandLine {
 interface ParserMode {
   readonly options: OptionNameMap;
   readonly unknownOption: DiagnosticMessage;
+  /** An unknown option with a spelling suggestion among `options`. */
+  readonly unknownOptionDidYouMean: DiagnosticMessage;
   readonly missingArgument: DiagnosticMessage;
   /** Options of the other mode, reported with `wrongMode` instead of as unknown. */
   readonly otherModeOptions?: OptionNameMap;
@@ -64,6 +62,7 @@ interface ParserMode {
 const compilerMode: ParserMode = {
   options: compilerOptionsByName,
   unknownOption: Diagnostics.Unknown_compiler_option_0,
+  unknownOptionDidYouMean: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
   missingArgument: Diagnostics.Compiler_option_0_expects_an_argument,
   otherModeOptions: buildOptionsByName,
   wrongMode: Diagnostics.Compiler_option_0_may_only_be_used_with_build,
@@ -72,29 +71,22 @@ const compilerMode: ParserMode = {
 const buildMode: ParserMode = {
   options: buildOptionsByName,
   unknownOption: Diagnostics.Unknown_build_option_0,
+  unknownOptionDidYouMean: Diagnostics.Unknown_build_option_0_Did_you_mean_1,
   missingArgument: Diagnostics.Build_option_0_requires_a_value_of_type_1,
   otherModeOptions: compilerOptionsByName,
   wrongMode: Diagnostics.Compiler_option_0_may_not_be_used_with_build,
 };
 
-const watchMode: ParserMode = {
-  options: watchOptionsByName,
-  unknownOption: Diagnostics.Unknown_watch_option_0,
-  missingArgument: Diagnostics.Watch_option_0_requires_a_value_of_type_1,
-};
-
 export function parseCommandLine(args: readonly string[], host: CommandLineHost): ParsedCommandLine {
   const parser = new CommandLineParser(compilerMode, host);
   parser.parseArguments(args);
   const cwd = host.currentDirectory;
   const options: CompilerOptions = {};
-  const watchOptions: WatchOptions = {};
   for (const [name, value] of parser.raw) {
     if (parser.droppedLists.has(name)) continue;
     setCompilerOption(options, name, toAbsolutePaths(name, value, cwd));
-    setWatchOption(watchOptions, name, value);
   }
-  return { options, watchOptions, fileNames: parser.fileNames, errors: parser.errors, raw: parser.raw };
+  return { options, fileNames: parser.fileNames, errors: parser.errors, raw: parser.raw };
 }
 
 export function parseBuildCommandLine(args: readonly string[], host: CommandLineHost): ParsedBuildCommandLine {
@@ -102,7 +94,6 @@ export function parseBuildCommandLine(args: readonly string[], host: CommandLine
   parser.parseArguments(args);
   const buildOptions: BuildOptions = {};
   const compilerOptions: CompilerOptions = {};
-  const watchOptions: WatchOptions = {};
   for (const [name, value] of parser.raw) {
     if (parser.droppedLists.has(name)) continue;
     const declaration = buildOptionsByName.get(name);
@@ -110,7 +101,6 @@ export function parseBuildCommandLine(args: readonly string[], host: CommandLine
       setCompilerOption(compilerOptions, name, value);
     }
     setBuildOption(buildOptions, name, value);
-    setWatchOption(watchOptions, name, value);
   }
   const errors = parser.errors;
   const { clean, force, verbose, dry } = buildOptions;
@@ -126,7 +116,6 @@ export function parseBuildCommandLine(args: readonly string[], host: CommandLine
   return {
     buildOptions,
     compilerOptions,
-    watchOptions,
     projects: parser.fileNames.length > 0 ? parser.fileNames : ['.'],
     errors,
     raw: parser.raw,
@@ -156,6 +145,8 @@ class CommandLineParser {
    * though `raw` (and so `--init`) has `[]`.
    */
   readonly droppedLists = new Set<string>();
+  /** Response files being read, so one that includes itself is skipped. */
+  private readonly responseFiles = new Set<string>();
 
   constructor(
     private readonly mode: ParserMode,
@@ -173,13 +164,8 @@ class CommandLineParser {
       } else if (arg.startsWith('-')) {
         const name = arg.startsWith('--') ? arg.slice(2) : arg.slice(1);
         const option = this.mode.options.find(name, true);
-        if (option !== undefined) {
-          i = this.parseOptionValue(args, i, option, this.mode);
-        } else {
-          const watchOption = watchOptionsByName.find(name, true);
-          if (watchOption !== undefined) i = this.parseOptionValue(args, i, watchOption, watchMode);
-          else this.errors.push(this.unknownOptionError(name, arg));
-        }
+        if (option !== undefined) i = this.parseOptionValue(args, i, option, this.mode);
+        else this.errors.push(this.unknownOptionError(name, arg));
       } else {
         this.fileNames.push(arg);
       }
@@ -193,12 +179,21 @@ class CommandLineParser {
         other.name === 'build' ? Diagnostics.Option_build_must_be_the_first_command_line_argument : this.mode.wrongMode;
       return createCompilerDiagnostic(message, name);
     }
+    const suggestion = getSpellingSuggestion(name, this.mode.options.names());
+    if (suggestion !== '') return createCompilerDiagnostic(this.mode.unknownOptionDidYouMean, arg, suggestion);
     return createCompilerDiagnostic(this.mode.unknownOption, arg);
   }
 
   /** Splits a response file into arguments at whitespace; `"` quotes an argument. */
   private parseResponseFile(fileName: string): void {
     const path = getNormalizedAbsolutePath(fileName, this.host.currentDirectory);
+    if (this.responseFiles.has(path)) return;
+    this.responseFiles.add(path);
+    this.readResponseFile(fileName, path);
+    this.responseFiles.delete(path);
+  }
+
+  private readResponseFile(fileName: string, path: string): void {
     const text = this.host.readFile(path);
     if (text === undefined) {
       this.errors.push(createCompilerDiagnostic(Diagnostics.Cannot_read_file_0, path));
@@ -217,10 +212,12 @@ class CommandLineParser {
           args.push(text.slice(start + 1, pos));
           pos++;
         } else {
-          this.errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, path));
+          // The file name as written.
+          this.errors.push(
+            createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName),
+          );
         }
       } else {
-        // tsgo panics when the file ends in an argument; tsc accepts it.
         while (pos < text.length && text.charCodeAt(pos) > 32) pos++;
         args.push(text.slice(start, pos));
       }
@@ -300,7 +297,10 @@ class CommandLineParser {
         this.raw.set(name, next !== 'false');
         return next === 'true' || next === 'false' ? i + 1 : i;
       case 'string':
-        if (this.validateString(option, next)) this.raw.set(name, next);
+        if (!this.validateString(option, next)) return i + 1;
+        if (option.isFilePath === true && isNetworkPathValue(next!, this.host.currentDirectory))
+          this.errors.push(createCompilerDiagnostic(Diagnostics.Network_path_0_is_not_supported, next!));
+        else this.raw.set(name, next);
         return i + 1;
       case 'list': {
         const errorCount = this.errors.length;