tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker.js

@@ -1,7 +1,7 @@
 import { sideOf } from './side-state.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, compareDiagnostics } from './diagnostics.js';
+import { Diagnostic, compareDiagnostics, equalDiagnostics, } from './diagnostics.js';
 import { ModuleKind, ScriptTarget, getEmitScriptTarget, getIsolatedModules, getStrictOptionValue, shouldPreserveConstEnums, } from './options.js';
 import { Symbol, getSymbolId } from './symbol.js';
 import { IndexInfo, IntrinsicType, LiteralType, NodeLinks, Signature, SymbolLinks, TypeParameter, TypePredicate, emptyTypes, TypeListCache, TypeListTable, } from './checker-types.js';
@@ -10,12 +10,14 @@ import { getFalseTypeFromConditionalType, getTrueTypeFromConditionalType } from
 import { createArrayType, createTypeFromGenericGlobalType, getBigIntLiteralType, getNumberLiteralType, getStringLiteralType, getTemplateLiteralType, getUnionType, newAnonymousType, newObjectType, } from './checker-type-factory.js';
 import { CheckerNameResolver, borrowLibGlobals, findLibGlobals, returnLibGlobals, setGlobal, SuggestionNameResolver, getGlobalStrictFunctionType, getGlobalType, initializeGlobals, mergeAmbientModulesAndAugmentations, } from './checker-symbols.js';
 import { PermissiveMapper, ReportingMapper, RestrictiveMapper, UniqueLiteralMapper } from './instantiation.js';
-import { Relation, RelationKey } from './relations.js';
-import { TypeNodeVisitor, checkSourceFile } from './checker-source-file.js';
+import { Relation, RelationKey, } 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 } from './checker-narrowing.js';
 import { JsxState } from './checker-jsx.js';
 import { SourceFileMetadata, getEmitModuleFormatOfFile } from './program-utilities.js';
+import { shareThreads, startThreadSharing } from './shared-results.js';
 /** What the checker needs from a program. */
 export class CheckerHost {
     /** How a module name in `file` resolved in `mode`, if the program resolved it. */
@@ -78,22 +80,40 @@ export class CheckerHost {
         return undefined;
     }
 }
-/** 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 {
     byFile = new Map();
     sortedFiles = new Set();
     global = [];
     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. */
+    byLocation = new Map();
+    /** The diagnostics reported since `startLog`, while recording, also those equal to one already added. */
     log = undefined;
+    /** Adds `diagnostic` unless an equal one was added; returns the one the collection holds. */
     add(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) {
@@ -102,6 +122,7 @@ class DiagnosticCollection {
         }
         list.push(diagnostic);
         this.sortedFiles.delete(file.fileName);
+        return diagnostic;
     }
     forFile(fileName) {
         const list = this.byFile.get(fileName);
@@ -137,6 +158,50 @@ 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 = undefined;
+    /** Runs `run`, then removes the global diagnostics it added. */
+    withoutNewGlobals(run) {
+        const outer = this.log;
+        const added = [];
+        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();
+            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. */
+    forget(diagnostic) {
+        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() {
         this.log = [];
@@ -220,10 +285,20 @@ export class Checker {
     memberPositionsInLists = new Map();
     /** The property names of the last instantiation of each such list whose table is built on demand. */
     memberNamesOfLists = new Map();
+    /** The property order of the instantiations of each such list (`NamedMemberOrder`); null where it has none. */
+    namedMemberOrdersOfLists = new Map();
     /** Long lists of inherited properties, by name. */
     propertiesByName = new Map();
     /** 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`).
+     */
+    typeStrings = new Map();
+    /** `symbolToString` results by symbol, then by enclosing declaration and flags, kept as `typeStrings` are. */
+    symbolStrings = new Map();
     /** 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. */
@@ -257,6 +332,9 @@ export class Checker {
      * so far; null where a list repeats a name.
      */
     propertyListIndexes = new Map();
+    // 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. */
     symbolTypes = new LinkTable();
     /** For instantiated and synthetic symbols, the symbol they come from. */
@@ -264,24 +342,24 @@ export class Checker {
     /** The mapper of an instantiated symbol or a mapped type property. */
     symbolMappers = new LinkTable();
     /** The literal type of a property name. */
-    symbolNameTypes = new LinkTable();
+    symbolNameTypes = new CompactLinkTable();
     /** The mapped type of a mapped type property, or the union/intersection of a synthetic property. */
-    symbolContainingTypes = new LinkTable();
+    symbolContainingTypes = new CompactLinkTable();
     /** The key type of a mapped type property. */
-    symbolKeyTypes = new LinkTable();
+    symbolKeyTypes = new CompactLinkTable();
     /** The property a mapped, spread or synthetic property comes from. */
-    symbolSyntheticOrigins = new LinkTable();
+    symbolSyntheticOrigins = new CompactLinkTable();
     /** The left and right properties a spread property combines. */
-    symbolLeftSpreads = new LinkTable();
-    symbolRightSpreads = new LinkTable();
+    symbolLeftSpreads = new CompactLinkTable();
+    symbolRightSpreads = new CompactLinkTable();
     /** Bits of SymbolFlags for the meanings in which a symbol was referenced. */
-    symbolReferenceKinds = new IntLinkTable();
+    symbolReferenceKinds = new CompactIntLinkTable();
     /** The resolved symbol of an identifier, entity name or call. */
-    resolvedSymbols = new CompactSymbolLinkTable();
+    resolvedSymbols = new CompactLinkTable();
     /** The resolved type of a type node or expression. */
-    resolvedTypes = new SparseLinkTable();
+    resolvedTypes = new CompactLinkTable();
     /** The resolved signature of a call-like node or a signature declaration. */
-    resolvedSignatures = new SparseLinkTable();
+    resolvedSignatures = new CompactLinkTable();
     /** Merged symbols, indexed by the id of the symbol merged into them. */
     mergedSymbols;
     /**
@@ -451,14 +529,20 @@ export class Checker {
     globalSymbolCache = new Map();
     // Resolution stacks for cycle detection (see pushTypeResolution).
     resolutionStart = 0;
-    inVarianceComputation = false;
+    /** The generic types whose variances are being computed, outermost first. */
+    varianceStack = [];
     // Instantiation
     instantiationDepth = 0;
+    /** The types being instantiated, outermost first: the first `instantiationDepth` entries are current. */
+    instantiationStack = [];
+    /** The calls being resolved, outermost first: the first `callResolutionDepth` entries are current. */
+    callResolutionStack = [];
+    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. */
-    activeMappers = [];
+    /** 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. */
     activeMapperCaches = [];
@@ -473,20 +557,32 @@ export class Checker {
     /** Empty lists for type arguments that are compared with cached instantiations before any is kept. */
     freeTypeLists = [];
     /**
-     * 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`).
      */
-    withoutOuterTypeParameters = new IntLinkTable();
+    withoutOuterTypeParameters = new PagedIdSet();
     conditionalConstraintDepth = 0;
     suggestionResolver;
     awaitedTypeStack = [];
     /** Iteration types by type id and iteration use. */
     iterationTypesCache = new Map();
-    /** Whether diagnostics can be deferred to the end of the file being checked. */
-    saveDeferredDiagnostics = false;
-    deferredIterationErrors = [];
-    /** Collision checks waiting for the end of the file (checker-generated-code.ts). */
-    deferredCollisionChecks = [];
+    /**
+     * 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 = [];
+    /** Defers the diagnostic `report` reports at `node` (`deferredDiagnostics`). */
+    deferDiagnostic(node, report) {
+        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`).
+     */
+    objectLiteralsForDeprecations = new Map();
     /** Binding patterns whose implied type is being computed as a contextual type. */
     contextualBindingPatterns = [];
     /** The binding pattern or assignment pattern that implied each type. */
@@ -543,6 +639,8 @@ export class Checker {
     flowNodePostSuper = new Map();
     lastFlowNode = undefined;
     lastFlowNodeReachable = false;
+    /** Symbols whose explicit type is being found, for flow analysis of self-referential `for...of`. */
+    resolvingExplicitTypeOfSymbol = new Set();
     assignmentMarker;
     primitiveTypeAliasSuggestions = new Map();
     /** Renamed binding elements in parameters of bodiless signatures, checked for use with their file. */
@@ -566,6 +664,9 @@ export class Checker {
     ambientModuleSymbols = [];
     patternAmbientModules = [];
     patternAmbientModuleAugmentations = new Map();
+    /** The pattern module each entry of `patternAmbientModuleAugmentations` augments. */
+    patternAmbientModuleAugmentationTargets = new Map();
+    moduleImportAttributesTypes = new Map();
     inferenceCaches = new InferenceCaches();
     /** The type resolution stack: the first `resolutionDepth` entries are live, later slots are reused. */
     resolutionTargets = [];
@@ -574,6 +675,28 @@ export class Checker {
     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 = 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 = 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 = undefined;
+    /** The same members by `distributedKey`. */
+    distributedByKey = undefined;
+    /** The conditional types conditional type instantiations resolved to, with the instantiation's root and key. */
+    conditionalResults = undefined;
+    /** The access flags of the key `getIndexedAccessTypeEx` keeps each indexed access type by. */
+    indexedAccessKeyFlags = undefined;
+    /** Where results are shared between checker threads (shared-results.ts): the file of each diagnostic deferred. */
+    deferredDiagnosticFiles = undefined;
     constructor(host) {
         this.host = host;
         const options = host.getCompilerOptions();
@@ -763,6 +886,14 @@ export class Checker {
         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();
+            this.distributedByKey = new Map();
+            this.conditionalResults = new Map();
+            this.indexedAccessKeyFlags = new Map();
+        }
     }
     // ---- Public API
     /** Checks `file` if needed and returns its semantic diagnostics, sorted. */
@@ -774,12 +905,25 @@ export class Checker {
     /** Checks `file`, including unused identifiers, and returns its suggestion diagnostics. */
     getSuggestionDiagnostics(file) {
         checkSourceFile(this, file, true);
+        checkObjectLiteralDeprecations(this, file);
         return this.suggestionDiagnostics.forFile(file.fileName);
     }
     /** Diagnostics without a file, such as missing global types. */
     getGlobalDiagnostics() {
+        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(run) {
+        return this.diagnostics.withoutNewGlobals(run);
+    }
+    /** The global diagnostics `withoutGlobalDiagnostics` forgot so far. */
+    forgottenGlobalDiagnostics() {
+        return this.diagnostics.removedGlobals;
+    }
     // ---- Links
     /** The rarely used links of `symbol`, created on first use. */
     symbolLinks(symbol) {
@@ -847,15 +991,15 @@ export class Checker {
     // ---- Diagnostics
     /** Reports `message` at `node`, or as a global diagnostic without a node. */
     error(node, message, ...args) {
-        const diagnostic = createDiagnosticForNode(node, message, args);
-        this.addDiagnostic(diagnostic);
-        return diagnostic;
+        return this.addDiagnostic(createDiagnosticForNode(node, message, args));
     }
+    /** Reports `diagnostic`; returns the equal diagnostic already reported, if any, else `diagnostic`. */
     addDiagnostic(diagnostic) {
         this.reports++;
         // Discard diagnostics created while at the maximum number of nested typeToString calls.
         if (this.serializationLevel < maxSerializationLevel)
-            this.diagnostics.add(diagnostic);
+            return this.diagnostics.add(diagnostic);
+        return diagnostic;
     }
     addSuggestion(diagnostic) {
         this.reports++;
@@ -901,6 +1045,7 @@ export function disposeChecker(c) {
     c.sharedSymbolCopies.clear();
     c.memberPositionsInLists.clear();
     c.memberNamesOfLists.clear();
+    c.namedMemberOrdersOfLists.clear();
     c.propertiesByName.clear();
     c.symbolAccessibilityCaches = undefined;
     c.unresolvedSymbols.clear();
@@ -926,8 +1071,8 @@ export function disposeChecker(c) {
     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();
@@ -938,8 +1083,11 @@ export function disposeChecker(c) {
     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();
 }
 /** A diagnostic at `node`'s error range, or a global one without a node. */
 export function createDiagnosticForNode(node, message, args) {

package/dist/api/compiler/command-line.d.ts

@@ -1,6 +1,6 @@
 import { type Diagnostic } from './diagnostics.js';
 import { type OptionDeclaration } from './option-declarations.js';
-import { type BuildOptions, type CompilerOptions, type OptionValue, type WatchOptions } from './options.js';
+import { type BuildOptions, type CompilerOptions, type OptionValue } from './options.js';
 /** Reads response files. */
 export declare abstract class CommandLineHost {
     readonly currentDirectory: string;
@@ -10,7 +10,6 @@ export declare 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. */
@@ -20,7 +19,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[];

package/dist/api/compiler/command-line.js

@@ -4,9 +4,10 @@
 import { isUnicodeWhiteSpace, isWhiteSpaceLike } from './character-codes.js';
 import { createCompilerDiagnostic } from './diagnostics.js';
 import { isValidLocale } from './locale.js';
-import { buildOption, buildOptionsByName, compilerOptionsByName, watchOptionsByName, } from './option-declarations.js';
-import { setBuildOption, setCompilerOption, setWatchOption, } from './options.js';
-import { getNormalizedAbsolutePath } from './path.js';
+import { buildOption, buildOptionsByName, compilerOptionsByName, } from './option-declarations.js';
+import { setBuildOption, setCompilerOption, } from './options.js';
+import { getNormalizedAbsolutePath, isNetworkPathValue } from './path.js';
+import { getSpellingSuggestion } from './spelling.js';
 /** Reads response files. */
 export class CommandLineHost {
     currentDirectory;
@@ -16,43 +17,37 @@ export class CommandLineHost {
 }
 const compilerMode = {
     options: compilerOptionsByName,
-    unknownOption: 1121 /* Diagnostics.Unknown_compiler_option_0 */,
-    missingArgument: 1222 /* Diagnostics.Compiler_option_0_expects_an_argument */,
+    unknownOption: 1128 /* Diagnostics.Unknown_compiler_option_0 */,
+    unknownOptionDidYouMean: 1130 /* Diagnostics.Unknown_compiler_option_0_Did_you_mean_1 */,
+    missingArgument: 1233 /* Diagnostics.Compiler_option_0_expects_an_argument */,
     otherModeOptions: buildOptionsByName,
-    wrongMode: 1167 /* Diagnostics.Compiler_option_0_may_only_be_used_with_build */,
+    wrongMode: 1174 /* Diagnostics.Compiler_option_0_may_only_be_used_with_build */,
 };
 const buildMode = {
     options: buildOptionsByName,
-    unknownOption: 1147 /* Diagnostics.Unknown_build_option_0 */,
-    missingArgument: 1148 /* Diagnostics.Build_option_0_requires_a_value_of_type_1 */,
+    unknownOption: 1154 /* Diagnostics.Unknown_build_option_0 */,
+    unknownOptionDidYouMean: 1159 /* Diagnostics.Unknown_build_option_0_Did_you_mean_1 */,
+    missingArgument: 1155 /* Diagnostics.Build_option_0_requires_a_value_of_type_1 */,
     otherModeOptions: compilerOptionsByName,
-    wrongMode: 1168 /* Diagnostics.Compiler_option_0_may_not_be_used_with_build */,
-};
-const watchMode = {
-    options: watchOptionsByName,
-    unknownOption: 1153 /* Diagnostics.Unknown_watch_option_0 */,
-    missingArgument: 1155 /* Diagnostics.Watch_option_0_requires_a_value_of_type_1 */,
+    wrongMode: 1175 /* Diagnostics.Compiler_option_0_may_not_be_used_with_build */,
 };
 export function parseCommandLine(args, host) {
     const parser = new CommandLineParser(compilerMode, host);
     parser.parseArguments(args);
     const cwd = host.currentDirectory;
     const options = {};
-    const 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, host) {
     const parser = new CommandLineParser(buildMode, host);
     parser.parseArguments(args);
     const buildOptions = {};
     const compilerOptions = {};
-    const watchOptions = {};
     for (const [name, value] of parser.raw) {
         if (parser.droppedLists.has(name))
             continue;
@@ -61,23 +56,21 @@ export function parseBuildCommandLine(args, host) {
             setCompilerOption(compilerOptions, name, value);
         }
         setBuildOption(buildOptions, name, value);
-        setWatchOption(watchOptions, name, value);
     }
     const errors = parser.errors;
     const { clean, force, verbose, dry } = buildOptions;
     const watch = compilerOptions.watch;
     if (clean === true && force === true)
-        errors.push(createCompilerDiagnostic(1465 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'force'));
+        errors.push(createCompilerDiagnostic(1476 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'force'));
     if (clean === true && verbose === true)
-        errors.push(createCompilerDiagnostic(1465 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'verbose'));
+        errors.push(createCompilerDiagnostic(1476 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'verbose'));
     if (clean === true && watch === true)
-        errors.push(createCompilerDiagnostic(1465 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'watch'));
+        errors.push(createCompilerDiagnostic(1476 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'clean', 'watch'));
     if (watch === true && dry === true)
-        errors.push(createCompilerDiagnostic(1465 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'watch', 'dry'));
+        errors.push(createCompilerDiagnostic(1476 /* Diagnostics.Options_0_and_1_cannot_be_combined */, 'watch', 'dry'));
     return {
         buildOptions,
         compilerOptions,
-        watchOptions,
         projects: parser.fileNames.length > 0 ? parser.fileNames : ['.'],
         errors,
         raw: parser.raw,
@@ -109,6 +102,8 @@ class CommandLineParser {
      * though `raw` (and so `--init`) has `[]`.
      */
     droppedLists = new Set();
+    /** Response files being read, so one that includes itself is skipped. */
+    responseFiles = new Set();
     constructor(mode, host) {
         this.mode = mode;
         this.host = host;
@@ -126,16 +121,10 @@ 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) {
+                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));
-                }
+                else
+                    this.errors.push(this.unknownOptionError(name, arg));
             }
             else {
                 this.fileNames.push(arg);
@@ -145,17 +134,27 @@ class CommandLineParser {
     unknownOptionError(name, arg) {
         const other = this.mode.otherModeOptions?.get(name);
         if (other !== undefined && this.mode.wrongMode !== undefined) {
-            const message = other.name === 'build' ? 1464 /* Diagnostics.Option_build_must_be_the_first_command_line_argument */ : this.mode.wrongMode;
+            const message = other.name === 'build' ? 1475 /* 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. */
     parseResponseFile(fileName) {
         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);
+    }
+    readResponseFile(fileName, path) {
         const text = this.host.readFile(path);
         if (text === undefined) {
-            this.errors.push(createCompilerDiagnostic(1158 /* Diagnostics.Cannot_read_file_0 */, path));
+            this.errors.push(createCompilerDiagnostic(1165 /* Diagnostics.Cannot_read_file_0 */, path));
             return;
         }
         const args = [];
@@ -175,11 +174,11 @@ class CommandLineParser {
                     pos++;
                 }
                 else {
-                    this.errors.push(createCompilerDiagnostic(1223 /* Diagnostics.Unterminated_quoted_string_in_response_file_0 */, path));
+                    // The file name as written.
+                    this.errors.push(createCompilerDiagnostic(1234 /* 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));
@@ -202,10 +201,10 @@ class CommandLineParser {
                     this.raw.set(name, false);
                     return i + 1;
                 }
-                this.errors.push(createCompilerDiagnostic(1382 /* Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line */, name));
+                this.errors.push(createCompilerDiagnostic(1393 /* Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line */, name));
                 return value === 'true' ? i + 1 : i;
             }
-            this.errors.push(createCompilerDiagnostic(1237 /* Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line */, name));
+            this.errors.push(createCompilerDiagnostic(1248 /* Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line */, name));
             return value !== '' && !value.startsWith('-') ? i + 1 : i;
         }
         if (next === undefined) {
@@ -234,7 +233,7 @@ class CommandLineParser {
                     this.raw.set(name, value);
                 }
                 else {
-                    this.errors.push(createCompilerDiagnostic(1116 /* Diagnostics.Option_0_requires_value_to_be_greater_than_1 */, name, String(option.minValue ?? 0)));
+                    this.errors.push(createCompilerDiagnostic(1123 /* Diagnostics.Option_0_requires_value_to_be_greater_than_1 */, name, String(option.minValue ?? 0)));
                 }
                 return i + 1;
             }
@@ -243,7 +242,11 @@ class CommandLineParser {
                 this.raw.set(name, next !== 'false');
                 return next === 'true' || next === 'false' ? i + 1 : i;
             case 'string':
-                if (this.validateString(option, next))
+                if (!this.validateString(option, next))
+                    return i + 1;
+                if (option.isFilePath === true && isNetworkPathValue(next, this.host.currentDirectory))
+                    this.errors.push(createCompilerDiagnostic(1195 /* Diagnostics.Network_path_0_is_not_supported */, next));
+                else
                     this.raw.set(name, next);
                 return i + 1;
             case 'list': {
@@ -306,7 +309,7 @@ class CommandLineParser {
             }
         }
         else if (option.extraValidation === 'locale' && !isValidLocale(value)) {
-            this.errors.push(createCompilerDiagnostic(1225 /* Diagnostics.Locale_must_be_an_IETF_BCP_47_language_tag_Examples_Colon_0_1 */, 'en', 'ja-jp'));
+            this.errors.push(createCompilerDiagnostic(1236 /* Diagnostics.Locale_must_be_an_IETF_BCP_47_language_tag_Examples_Colon_0_1 */, 'en', 'ja-jp'));
             return false;
         }
         return true;
@@ -320,7 +323,7 @@ function valueTypeName(option) {
     return option.kind;
 }
 function invalidEnumValueError(option) {
-    return createCompilerDiagnostic(1224 /* Diagnostics.Argument_for_0_option_must_be_Colon_1 */, '--' + option.name, enumNamesList(option));
+    return createCompilerDiagnostic(1235 /* Diagnostics.Argument_for_0_option_must_be_Colon_1 */, '--' + option.name, enumNamesList(option));
 }
 /** `'a', 'b', 'c'`: the option's value names without deprecated ones. */
 export function enumNamesList(option) {
@@ -340,7 +343,7 @@ function specError(spec) {
         return undefined;
     const lastDotDot = spec.endsWith('/..') ? spec.length : spec.lastIndexOf('/../');
     return lastDotDot > wildcard
-        ? 1140 /* Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */
+        ? 1147 /* Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0 */
         : undefined;
 }
 /** Parses a decimal 64-bit integer with an optional sign, like Go's `strconv.Atoi`. */