tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,32 @@
+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';
+/** Reads response files. */
+export declare abstract class CommandLineHost {
+    readonly currentDirectory: string;
+    constructor(currentDirectory: string);
+    /** Returns `undefined` if the file can't be read. */
+    abstract readFile(path: string): string | undefined;
+}
+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. */
+    readonly raw: ReadonlyMap<string, OptionValue>;
+}
+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[];
+    readonly raw: ReadonlyMap<string, OptionValue>;
+}
+export declare function parseCommandLine(args: readonly string[], host: CommandLineHost): ParsedCommandLine;
+export declare function parseBuildCommandLine(args: readonly string[], host: CommandLineHost): ParsedBuildCommandLine;
+/** `'a', 'b', 'c'`: the option's value names without deprecated ones. */
+export declare function enumNamesList(option: OptionDeclaration): string;

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

@@ -0,0 +1,383 @@
+/**
+ * Parses `tsc` and `tsc --build` arguments into options, file names and diagnostics, as tsgo does.
+ */
+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';
+/** Reads response files. */
+export class CommandLineHost {
+    currentDirectory;
+    constructor(currentDirectory) {
+        this.currentDirectory = currentDirectory;
+    }
+}
+const compilerMode = {
+    options: compilerOptionsByName,
+    unknownOption: 1121 /* Diagnostics.Unknown_compiler_option_0 */,
+    missingArgument: 1222 /* Diagnostics.Compiler_option_0_expects_an_argument */,
+    otherModeOptions: buildOptionsByName,
+    wrongMode: 1167 /* 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 */,
+    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 */,
+};
+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 };
+}
+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;
+        const declaration = buildOptionsByName.get(name);
+        if (declaration === buildOption || (declaration !== undefined && declaration === compilerOptionsByName.get(name))) {
+            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'));
+    if (clean === true && verbose === true)
+        errors.push(createCompilerDiagnostic(1465 /* 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'));
+    if (watch === true && dry === true)
+        errors.push(createCompilerDiagnostic(1465 /* 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,
+    };
+}
+/** Resolves file path values of compiler options against `cwd`. */
+function toAbsolutePaths(name, value, cwd) {
+    const declaration = compilerOptionsByName.get(name);
+    if (declaration === undefined)
+        return value;
+    if (declaration.kind === 'list') {
+        if (declaration.element?.isFilePath === true && Array.isArray(value)) {
+            return value.map((path) => getNormalizedAbsolutePath(path, cwd));
+        }
+    }
+    else if (declaration.isFilePath === true && typeof value === 'string') {
+        return getNormalizedAbsolutePath(value, cwd);
+    }
+    return value;
+}
+class CommandLineParser {
+    mode;
+    host;
+    raw = new Map();
+    fileNames = [];
+    errors = [];
+    /**
+     * List options whose items were all dropped (`--types ,`). tsgo leaves them unset,
+     * though `raw` (and so `--init`) has `[]`.
+     */
+    droppedLists = new Set();
+    constructor(mode, host) {
+        this.mode = mode;
+        this.host = host;
+    }
+    parseArguments(args) {
+        let i = 0;
+        while (i < args.length) {
+            const arg = args[i];
+            i++;
+            if (arg === '')
+                continue;
+            if (arg.startsWith('@')) {
+                this.parseResponseFile(arg.slice(1));
+            }
+            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));
+                }
+            }
+            else {
+                this.fileNames.push(arg);
+            }
+        }
+    }
+    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;
+            return createCompilerDiagnostic(message, name);
+        }
+        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);
+        const text = this.host.readFile(path);
+        if (text === undefined) {
+            this.errors.push(createCompilerDiagnostic(1158 /* Diagnostics.Cannot_read_file_0 */, path));
+            return;
+        }
+        const args = [];
+        let pos = 0;
+        while (pos < text.length) {
+            while (pos < text.length && text.charCodeAt(pos) <= 32)
+                pos++;
+            if (pos >= text.length)
+                break;
+            const start = pos;
+            if (text.charCodeAt(pos) === 34 /* " */) {
+                pos++;
+                while (pos < text.length && text.charCodeAt(pos) !== 34)
+                    pos++;
+                if (pos < text.length) {
+                    args.push(text.slice(start + 1, pos));
+                    pos++;
+                }
+                else {
+                    this.errors.push(createCompilerDiagnostic(1223 /* Diagnostics.Unterminated_quoted_string_in_response_file_0 */, path));
+                }
+            }
+            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));
+            }
+        }
+        this.parseArguments(args);
+    }
+    /** Reads the value of `option` starting at `args[i]`; returns the index of the next argument. */
+    parseOptionValue(args, i, option, mode) {
+        const name = option.name;
+        const next = i < args.length ? args[i] : undefined;
+        if (option.isTSConfigOnly === true) {
+            const value = next ?? '';
+            if (value === 'null') {
+                this.raw.set(name, null);
+                return i + 1;
+            }
+            if (option.kind === 'boolean') {
+                if (value === 'false') {
+                    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));
+                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));
+            return value !== '' && !value.startsWith('-') ? i + 1 : i;
+        }
+        if (next === undefined) {
+            if (option.kind === 'boolean') {
+                this.raw.set(name, true);
+                return i;
+            }
+            this.errors.push(createCompilerDiagnostic(mode.missingArgument, name, valueTypeName(option)));
+            if (option.kind === 'list')
+                this.raw.set(name, []);
+            else if (option.kind === 'enum')
+                this.errors.push(invalidEnumValueError(option));
+            return i;
+        }
+        if (next === 'null') {
+            this.raw.set(name, null);
+            return i + 1;
+        }
+        switch (option.kind) {
+            case 'number': {
+                const value = parseInteger(next);
+                if (value === undefined) {
+                    this.errors.push(createCompilerDiagnostic(mode.missingArgument, name, 'number'));
+                }
+                else if (value >= (option.minValue ?? 0)) {
+                    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)));
+                }
+                return i + 1;
+            }
+            case 'boolean':
+                // The value is optional: only a literal `true` or `false` is consumed.
+                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);
+                return i + 1;
+            case 'list': {
+                const errorCount = this.errors.length;
+                const values = this.parseList(option, next);
+                this.raw.set(name, values ?? []);
+                if (values === undefined)
+                    this.droppedLists.add(name);
+                else
+                    this.droppedLists.delete(name);
+                return (values !== undefined && values.length > 0) || this.errors.length > errorCount ? i + 1 : i;
+            }
+            case 'enum':
+                this.raw.set(name, this.parseEnumValue(option, trimWhiteSpaceLike(next)));
+                return i + 1;
+            default:
+                throw new Error(`Option '${name}' of kind '${option.kind}' can't be given on the command line.`);
+        }
+    }
+    /** Parses comma-separated items; `undefined` if there were items but none was kept. */
+    parseList(option, text) {
+        const element = option.element;
+        const value = trimSpace(text);
+        if (element === undefined || value === '' || value.startsWith('-'))
+            return [];
+        const result = [];
+        for (const item of value.split(',')) {
+            if (element.kind === 'string') {
+                if (this.validateString(element, item) && item !== '')
+                    result.push(item);
+            }
+            else if (element.kind === 'enum') {
+                const converted = this.parseEnumValue(element, trimWhiteSpaceLike(item));
+                if (typeof converted === 'string' && converted !== '')
+                    result.push(converted);
+            }
+            else {
+                throw new Error(`Lists of ${element.kind} are not supported.`);
+            }
+        }
+        return result.length > 0 ? result : undefined;
+    }
+    /** Maps an enum name to its value; reports unknown names. An empty name is `null`. */
+    parseEnumValue(option, text) {
+        if (text === '')
+            return null;
+        const value = option.values?.get(text.toLowerCase());
+        if (value !== undefined)
+            return value;
+        this.errors.push(invalidEnumValueError(option));
+        return null;
+    }
+    /** Runs an option's extra validation; returns whether the value is valid. */
+    validateString(option, value) {
+        if (option.extraValidation === 'spec') {
+            const message = specError(value);
+            if (message !== undefined) {
+                this.errors.push(createCompilerDiagnostic(message));
+                return false;
+            }
+        }
+        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'));
+            return false;
+        }
+        return true;
+    }
+}
+function valueTypeName(option) {
+    if (option.kind === 'list')
+        return 'Array';
+    if (option.kind === 'listOrElement')
+        return (option.element?.kind ?? 'string') + ' or Array';
+    return option.kind;
+}
+function invalidEnumValueError(option) {
+    return createCompilerDiagnostic(1224 /* 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) {
+    const names = [];
+    if (option.values !== undefined) {
+        for (const name of option.values.keys()) {
+            if (option.deprecatedValues?.has(name) !== true)
+                names.push(name);
+        }
+    }
+    return "'" + names.join("', '") + "'";
+}
+/** Rejects `..` after a `**` wildcard in exclude specs. */
+function specError(spec) {
+    const wildcard = spec.startsWith('**/') ? 0 : spec.indexOf('/**/');
+    if (wildcard === -1)
+        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 */
+        : undefined;
+}
+/** Parses a decimal 64-bit integer with an optional sign, like Go's `strconv.Atoi`. */
+function parseInteger(text) {
+    let start = 0;
+    if (text.startsWith('+') || text.startsWith('-'))
+        start = 1;
+    if (start === text.length)
+        return undefined;
+    for (let i = start; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (ch < 48 || ch > 57)
+            return undefined;
+    }
+    let digits = text.slice(start);
+    while (digits.length > 1 && digits.startsWith('0'))
+        digits = digits.slice(1);
+    const limit = text.startsWith('-') ? '9223372036854775808' : '9223372036854775807';
+    if (digits.length > limit.length || (digits.length === limit.length && digits > limit))
+        return undefined;
+    return Number(text);
+}
+function trimSpace(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && isUnicodeWhiteSpace(text.charCodeAt(start)))
+        start++;
+    while (end > start && isUnicodeWhiteSpace(text.charCodeAt(end - 1)))
+        end--;
+    return text.slice(start, end);
+}
+function trimWhiteSpaceLike(text) {
+    let start = 0;
+    let end = text.length;
+    while (start < end && isWhiteSpaceLike(text.charCodeAt(start)))
+        start++;
+    while (end > start && isWhiteSpaceLike(text.charCodeAt(end - 1)))
+        end--;
+    return text.slice(start, end);
+}

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

@@ -0,0 +1,118 @@
+/**
+ * What `tsc` compiles: a checked program, plain or incremental, with the diagnostics it reports and
+ * the emit it does, like tsgo's `ProgramLike`.
+ */
+import type { SourceFile } from './ast.js';
+import type { Diagnostic } from './diagnostics.js';
+import { EmitOnly, EmitResult } from './emitter.js';
+import { type CompilerOptions } from './options.js';
+import type { Program } from './program.js';
+import { CheckedProgram } from './program-checker.js';
+import { DeclarationGlobals } from './transformers/declarations-syntactic.js';
+import { type MergedGlobals } from './transformers/reference-resolver.js';
+/** Where emit writes files. */
+export declare abstract class OutputWriter {
+    /**
+     * Writes `text` to `fileName`; returns an error message, `''`, or `skippedWrite` for a file left
+     * alone. `declarationDiagnostics` are the errors of a forced declaration emit.
+     */
+    abstract write(fileName: string, text: string, declarationDiagnostics: readonly Diagnostic[]): string;
+}
+/** Keeps the outputs written to it, as file name and text alternately, instead of writing them. */
+export declare class HoldingWriter extends OutputWriter {
+    private outputs;
+    write(fileName: string, text: string, _declarationDiagnostics: readonly Diagnostic[]): string;
+    /** The outputs kept since the last call. */
+    take(): string[];
+}
+/**
+ * Writes the outputs a checker thread held (`EmitResult.heldOutputs`) with `writer`; returns the emit
+ * result as if the thread had written them: an output that fails to be written is an error instead of
+ * an emitted file, and one the writer leaves unwritten (`skippedWrite`) isn't an emitted file.
+ */
+export declare function writeHeldOutputs(result: EmitResult, writer: OutputWriter): EmitResult;
+/** Collects what a forced declaration emit produces instead of writing it. */
+export declare class CapturingWriter extends OutputWriter {
+    /** Whether a file was written; its text can be empty. */
+    written: boolean;
+    text: string;
+    diagnostics: readonly Diagnostic[];
+    write(_fileName: string, text: string, declarationDiagnostics: readonly Diagnostic[]): string;
+}
+/** Phase timings in milliseconds, for `--diagnostics`. */
+export declare class CompileTimes {
+    configTime: number;
+    buildInfoReadTime: number;
+    parseTime: number;
+    bindTime: number;
+    checkTime: number;
+    emitTime: number;
+    changesComputeTime: number;
+    totalTime: number;
+}
+/**
+ * What the emit resolvers of a program index for all its files: the globals of emit's name
+ * resolution and, where declarations are resolved, those of declaration emit and the files by path.
+ * The thread that shares a program with checker threads builds them before publishing it
+ * (`shareWithCheckers`), so that the checkers' resolvers use one copy instead of each building its own.
+ */
+export declare class EmitIndexes {
+    readonly globals: MergedGlobals;
+    readonly declarations: DeclarationGlobals | undefined;
+    constructor(program: Program);
+}
+/** A checked program and the emit of its files. */
+export declare class ProgramEmitter {
+    readonly checked: CheckedProgram;
+    private host;
+    readonly program: Program;
+    constructor(checked: CheckedProgram);
+    /**
+     * The emit host, whose resolver resolves declarations where the options emit them or keep build info,
+     * or once `declarations` asks for it: a watch without build info computes the shape signatures of its
+     * rebuilds from forced declaration emit (`forcedDeclaration`).
+     */
+    private getHost;
+    emit(files: readonly SourceFile[], emitOnly: EmitOnly, writer: OutputWriter): EmitResult;
+    /** The declaration text and errors of `file`, emitted even without `declaration`. */
+    forcedDeclaration(file: SourceFile): CapturingWriter;
+}
+/** A program as `tsc` compiles it. */
+export declare abstract class CompilerProgram {
+    readonly checked: CheckedProgram;
+    readonly times: CompileTimes;
+    readonly emitter: ProgramEmitter;
+    constructor(checked: CheckedProgram, times: CompileTimes);
+    get program(): Program;
+    get options(): CompilerOptions;
+    getConfigFileParsingDiagnostics(): readonly Diagnostic[];
+    getSyntacticDiagnostics(): Diagnostic[];
+    getProgramDiagnostics(): Diagnostic[];
+    /** See `CheckedProgram.getGlobalDiagnostics`. */
+    getGlobalDiagnostics(withCheckerThreads?: boolean): Diagnostic[];
+    /** Semantic diagnostics of every file. */
+    abstract getSemanticDiagnostics(): Diagnostic[];
+    /** Declaration emit errors of every file. */
+    abstract getDeclarationDiagnostics(): Diagnostic[];
+    /** Emits the program (or what changed) with `writer`. */
+    abstract emit(writer: OutputWriter): EmitResult;
+}
+export declare const discardingWriter: OutputWriter;
+/** The declaration emit errors of `file` (none if it is not emitted). */
+export declare function declarationDiagnosticsOfFile(emitter: ProgramEmitter, file: SourceFile): Diagnostic[];
+/** A program compiled from scratch. */
+export declare class PlainProgram extends CompilerProgram {
+    getSemanticDiagnostics(): Diagnostic[];
+    getDeclarationDiagnostics(): Diagnostic[];
+    emit(writer: OutputWriter): EmitResult;
+}
+/** 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`).
+ */
+export declare function getDiagnosticsOfProgram(program: CompilerProgram, withDeclarationDiagnostics: boolean): Diagnostic[];
+/** Combines emit results in order. */
+export declare function combineEmitResults(results: readonly EmitResult[]): EmitResult;
+export { CheckedProgram };