tsc-ts 0.0.10 → 0.1.1

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`. */

package/dist/api/compiler/compile-program.d.ts

@@ -105,6 +105,16 @@ export declare abstract class CompilerProgram {
     readonly times: CompileTimes;
     readonly emitter: ProgramEmitter;
     constructor(checked: CheckedProgram, times: CompileTimes);
+    /**
+     * Whether this run checked the program, which `getDiagnosticsOfProgram` sets when it checks it. A run
+     * stopped before checking, by syntax errors or `--noCheck`, keeps no record (`run-records.ts`).
+     */
+    checkedTheProgram: boolean;
+    /**
+     * The time spent in declaration emit while checking, to count as emit time rather than check time, since
+     * the last call. Only an incremental program emits while checking, to compute signatures.
+     */
+    takeNestedEmitTime(): number;
     get program(): Program;
     get options(): CompilerOptions;
     getConfigFileParsingDiagnostics(): readonly Diagnostic[];
@@ -112,6 +122,12 @@ export declare abstract class CompilerProgram {
     getProgramDiagnostics(): Diagnostic[];
     /** See `CheckedProgram.getGlobalDiagnostics`. */
     getGlobalDiagnostics(withCheckerThreads?: boolean): Diagnostic[];
+    /**
+     * Whether the global diagnostics found by checking are reported after the semantic diagnostics. An
+     * incremental program has them in the semantic diagnostics of the files they were found in
+     * (`CheckedProgram.globalsInFileDiagnostics`).
+     */
+    reportsGlobalDiagnosticsOfChecking(): boolean;
     /** Semantic diagnostics of every file. */
     abstract getSemanticDiagnostics(): Diagnostic[];
     /** Declaration emit errors of every file. */
@@ -131,12 +147,16 @@ export declare class PlainProgram extends CompilerProgram {
 /** Under `noEmitOnError`, a skipped emit with the errors that prevent it; otherwise `undefined`. */
 export declare function handleNoEmitOnError(program: CompilerProgram): EmitResult | undefined;
 /**
- * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
- * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
- * `noEmitOnError`) whether or not other errors were found.
+ * Config and syntax errors; without syntax errors, program, global and semantic errors too, and, when
+ * there are none of these, declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With
+ * `declarationsLater`, the declaration errors are left to the caller (`declarationDiagnosticsDue`).
  */
 export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean, declarationsLater?: boolean): Diagnostic[];
+/**
+ * Whether `getDiagnosticsOfProgram` adds the declaration errors to `diagnostics`: under `noEmit` (or
+ * `withDeclarationDiagnostics`) with declarations, when only config errors were found.
+ */
+export declare function declarationDiagnosticsDue(program: CompilerProgram, diagnostics: readonly Diagnostic[], withDeclarationDiagnostics: boolean): boolean;
 /** Combines emit results in order. */
 export declare function combineEmitResults(results: readonly EmitResult[]): EmitResult;
 export { CheckedProgram };

package/dist/api/compiler/compile-program.js

@@ -311,6 +311,18 @@ export class CompilerProgram {
         this.times = times;
         this.emitter = new ProgramEmitter(checked);
     }
+    /**
+     * Whether this run checked the program, which `getDiagnosticsOfProgram` sets when it checks it. A run
+     * stopped before checking, by syntax errors or `--noCheck`, keeps no record (`run-records.ts`).
+     */
+    checkedTheProgram = false;
+    /**
+     * The time spent in declaration emit while checking, to count as emit time rather than check time, since
+     * the last call. Only an incremental program emits while checking, to compute signatures.
+     */
+    takeNestedEmitTime() {
+        return 0;
+    }
     get program() {
         return this.checked.program;
     }
@@ -330,6 +342,14 @@ export class CompilerProgram {
     getGlobalDiagnostics(withCheckerThreads = true) {
         return this.checked.getGlobalDiagnostics(withCheckerThreads);
     }
+    /**
+     * Whether the global diagnostics found by checking are reported after the semantic diagnostics. An
+     * incremental program has them in the semantic diagnostics of the files they were found in
+     * (`CheckedProgram.globalsInFileDiagnostics`).
+     */
+    reportsGlobalDiagnosticsOfChecking() {
+        return !this.checked.globalsInFileDiagnostics;
+    }
 }
 /** Collects declaration emit errors without writing anything. */
 class DiscardingWriter extends OutputWriter {
@@ -363,11 +383,13 @@ export class PlainProgram extends CompilerProgram {
     }
     emit(writer) {
         const options = this.options;
-        if (options.noEmit !== true) {
-            const skipped = handleNoEmitOnError(this);
-            if (skipped !== undefined)
-                return skipped;
-        }
+        // A `noEmit` program emits nothing, and its emit is not skipped (tsgo's `HandleNoEmitOptions`): its
+        // declaration errors come with its other diagnostics (`getDiagnosticsOfProgram`).
+        if (options.noEmit === true)
+            return new EmitResult();
+        const skipped = handleNoEmitOnError(this);
+        if (skipped !== undefined)
+            return skipped;
         const program = this.program;
         const files = program.getSourceFiles();
         const parallel = this.checked.emittedInParallel;
@@ -379,7 +401,8 @@ export class PlainProgram extends CompilerProgram {
                 const emitted = parallel[i];
                 // The declaration thread emitted the declarations of the files it could (parallel-emit.ts).
                 const ahead = this.checked.declarationsEmittedAhead;
-                const declarations = () => ahead?.[i] ?? this.emitter.emit([file], 2 /* EmitOnly.Dts */, writer);
+                // The file's JavaScript is emitted too, here or on an emit thread.
+                const declarations = () => ahead?.[i] ?? this.emitter.emit([file], 4 /* EmitOnly.DtsAfterJs */, writer);
                 if (emitted === undefined)
                     return ahead !== undefined
                         ? combineEmitResults([this.emitter.emit([file], 1 /* EmitOnly.Js */, writer), declarations()])
@@ -390,14 +413,6 @@ export class PlainProgram extends CompilerProgram {
                     return written;
                 return combineEmitResults([written, declarations()]);
             }));
-        if (options.noEmit === true) {
-            // Emit is skipped only for files that would have been emitted.
-            result.emitSkipped = files.some((file) => program.sourceFileMayBeEmitted(file, false));
-            // Declaration emit still runs for its errors, as in tsgo, also when other errors were found.
-            if (getEmitDeclarations(options) && options.noEmitOnError !== true)
-                for (const d of this.getDeclarationDiagnostics())
-                    result.diagnostics.push(d);
-        }
         return result;
     }
 }
@@ -415,10 +430,9 @@ export function handleNoEmitOnError(program) {
     return result;
 }
 /**
- * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
- * declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With `declarationsLater`, the
- * declaration errors are left to `program.emit`, which reports them under `noEmit` (without
- * `noEmitOnError`) whether or not other errors were found.
+ * Config and syntax errors; without syntax errors, program, global and semantic errors too, and, when
+ * there are none of these, declaration errors under `noEmit` (or `withDeclarationDiagnostics`). With
+ * `declarationsLater`, the declaration errors are left to the caller (`declarationDiagnosticsDue`).
  */
 export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics, declarationsLater = false) {
     const result = [...program.getConfigFileParsingDiagnostics()];
@@ -438,25 +452,38 @@ export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics, dec
     for (const d of program.getGlobalDiagnostics(false))
         result.push(d);
     if (result.length === configCount) {
+        // With `--noCheck` the checker skips every file: the run checked nothing to sample (`run-records.ts`).
+        if (options.noCheck !== true)
+            program.checkedTheProgram = true;
         const checkStart = performance.now();
         const semantic = program.getSemanticDiagnostics();
-        program.times.checkTime = performance.now() - checkStart;
+        // Declaration emit that computed signatures while checking counts as emit time, as in TypeScript 7.1.
+        const nestedEmitTime = program.takeNestedEmitTime();
+        program.times.checkTime = Math.max(0, performance.now() - checkStart - nestedEmitTime);
+        program.times.emitTime += nestedEmitTime;
         for (const d of semantic)
             result.push(d);
         // Checking may have found more, such as missing global types.
-        for (const d of program.getGlobalDiagnostics())
-            result.push(d);
+        if (program.reportsGlobalDiagnosticsOfChecking())
+            for (const d of program.getGlobalDiagnostics())
+                result.push(d);
         mark('semantic diagnostics');
     }
-    if (!declarationsLater &&
-        (withDeclarationDiagnostics || options.noEmit === true) &&
-        getEmitDeclarations(options) &&
-        result.length === configCount) {
+    if (!declarationsLater && declarationDiagnosticsDue(program, result, withDeclarationDiagnostics))
         for (const d of program.getDeclarationDiagnostics())
             result.push(d);
-    }
     return result;
 }
+/**
+ * Whether `getDiagnosticsOfProgram` adds the declaration errors to `diagnostics`: under `noEmit` (or
+ * `withDeclarationDiagnostics`) with declarations, when only config errors were found.
+ */
+export function declarationDiagnosticsDue(program, diagnostics, withDeclarationDiagnostics) {
+    const options = program.options;
+    return ((withDeclarationDiagnostics || options.noEmit === true) &&
+        getEmitDeclarations(options) &&
+        diagnostics.length === program.getConfigFileParsingDiagnostics().length);
+}
 /** Combines emit results in order. */
 export function combineEmitResults(results) {
     const result = new EmitResult();