tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,384 @@
+import { EmitHost, EmitResult, emitFiles, skippedWrite, sourceFileMayBeEmitted } from './emitter.js';
+import { Resolver } from './module-resolution.js';
+import { getEmitDeclarations } from './options.js';
+import { CheckedProgram } from './program-checker.js';
+import { CheckerDeclarationEmitResolver, CheckerEmitResolver } from './checker-emit-resolver.js';
+import { getEmitModuleFormatOfFile } from './program-utilities.js';
+import { DeclarationGlobals, SyntacticDeclarationEmitResolver } from './transformers/declarations-syntactic.js';
+import { mark } from './timeline.js';
+import { ModuleFormatHost } from './transformers/module.js';
+import { ModuleLookup, ReferenceResolver } from './transformers/reference-resolver.js';
+/** Where emit writes files. */
+export class OutputWriter {
+}
+/** Keeps the outputs written to it, as file name and text alternately, instead of writing them. */
+export class HoldingWriter extends OutputWriter {
+    outputs = [];
+    write(fileName, text, _declarationDiagnostics) {
+        this.outputs.push(fileName, text);
+        return '';
+    }
+    /** The outputs kept since the last call. */
+    take() {
+        const outputs = this.outputs;
+        this.outputs = [];
+        return outputs;
+    }
+}
+/**
+ * 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 function writeHeldOutputs(result, writer) {
+    const held = result.heldOutputs;
+    let failed = undefined;
+    let skipped = undefined;
+    for (let i = 0; i < held.length; i += 2) {
+        const error = writer.write(held[i], held[i + 1], []);
+        if (error === skippedWrite) {
+            if (skipped === undefined)
+                skipped = new Set();
+            skipped.add(held[i]);
+        }
+        else if (error !== '') {
+            if (failed === undefined)
+                failed = new Map();
+            failed.set(held[i], error);
+        }
+    }
+    if (failed === undefined && skipped === undefined)
+        return result;
+    const copy = new EmitResult();
+    copy.emitSkipped = result.emitSkipped;
+    for (const f of result.emittedFiles)
+        if (failed?.has(f) !== true && skipped?.has(f) !== true)
+            copy.emittedFiles.push(f);
+    for (const e of result.errors)
+        copy.errors.push(e);
+    if (failed !== undefined)
+        for (const e of failed.values())
+            copy.errors.push(e);
+    for (const u of result.unsupported)
+        copy.unsupported.push(u);
+    for (const d of result.diagnostics)
+        copy.diagnostics.push(d);
+    for (const s of result.declarationSignatures)
+        copy.declarationSignatures.push(s);
+    return copy;
+}
+/** Collects what a forced declaration emit produces instead of writing it. */
+export class CapturingWriter extends OutputWriter {
+    /** Whether a file was written; its text can be empty. */
+    written = false;
+    text = '';
+    diagnostics = [];
+    write(_fileName, text, declarationDiagnostics) {
+        this.written = true;
+        this.text = text;
+        this.diagnostics = declarationDiagnostics;
+        return skippedWrite;
+    }
+}
+/** Phase timings in milliseconds, for `--diagnostics`. */
+export class CompileTimes {
+    configTime = 0;
+    buildInfoReadTime = 0;
+    parseTime = 0;
+    bindTime = 0;
+    checkTime = 0;
+    emitTime = 0;
+    changesComputeTime = 0;
+    totalTime = 0;
+}
+/** Module formats from the program's file metadata. */
+class ProgramFormats extends ModuleFormatHost {
+    program;
+    constructor(program) {
+        super();
+        this.program = program;
+    }
+    getEmitModuleFormat(fileName) {
+        const program = this.program;
+        return getEmitModuleFormatOfFile(fileName, program.options, program.sourceFileMetadata(program.toPath(fileName)));
+    }
+}
+/** Module specifiers resolved to files of the program. */
+class ProgramModules extends ModuleLookup {
+    program;
+    resolver;
+    constructor(program) {
+        super();
+        this.program = program;
+        this.resolver = new Resolver(program.host, program.options);
+    }
+    resolveModule(location, file, specifier) {
+        const mode = this.program.getModeForUsageLocation(file, location);
+        // The program resolved the module names its files import; others, such as names emit
+        // synthesizes, are resolved here.
+        const recorded = this.program.getResolvedModule(file, specifier, mode);
+        const resolved = recorded !== undefined
+            ? recorded.resolvedFileName
+            : this.resolver.resolveModuleName(specifier, file.fileName, mode).resolvedFileName;
+        return resolved === '' ? undefined : this.program.getSourceFile(resolved);
+    }
+}
+class ProgramEmitHost extends EmitHost {
+    program;
+    writer = undefined;
+    constructor(program, resolver) {
+        super(program.options, resolver, new ProgramFormats(program), program.commonSourceDirectory(), program.currentDirectory, program.useCaseSensitiveFileNames);
+        this.program = program;
+    }
+    isEmitBlocked(fileName) {
+        return this.program.isEmitBlocked(fileName);
+    }
+    isSourceFileFromExternalLibrary(file) {
+        return this.program.isSourceFileFromExternalLibrary(file);
+    }
+    writeFile(fileName, text, declarationDiagnostics) {
+        const writer = this.writer;
+        if (writer === undefined)
+            return skippedWrite;
+        return writer.write(fileName, text, declarationDiagnostics ?? []);
+    }
+}
+/** Whether a program's emit resolves declarations, which incremental builds need for their shape signatures. */
+function resolvesDeclarations(options) {
+    return getEmitDeclarations(options) || options.incremental === true || options.composite === true;
+}
+/**
+ * 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 class EmitIndexes {
+    globals;
+    declarations;
+    constructor(program) {
+        const options = program.options;
+        const files = program.getSourceFiles();
+        this.globals = new ReferenceResolver(options, files, new ProgramModules(program)).merged;
+        this.declarations = resolvesDeclarations(options)
+            ? new DeclarationGlobals(files, program.currentDirectory)
+            : undefined;
+    }
+}
+/** A checked program and the emit of its files. */
+export class ProgramEmitter {
+    checked;
+    host = undefined;
+    program;
+    constructor(checked) {
+        this.checked = checked;
+        this.program = checked.program;
+    }
+    /**
+     * 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`).
+     */
+    getHost(declarations) {
+        let host = this.host;
+        if (host === undefined || (declarations && !(host.resolver instanceof CheckerDeclarationEmitResolver))) {
+            const program = this.program;
+            const options = program.options;
+            const files = program.getSourceFiles();
+            const indexes = program.emitIndexes;
+            const references = new ReferenceResolver(options, files, new ProgramModules(program), indexes !== undefined ? indexes.globals : undefined);
+            const emitResolver = new CheckerEmitResolver(options, references, this.checked.checker);
+            // Declaration emit is also needed for the shape signatures of incremental builds.
+            let resolver = emitResolver;
+            if (declarations || resolvesDeclarations(options)) {
+                const syntactic = new SyntacticDeclarationEmitResolver(options, files, program.currentDirectory, emitResolver, indexes !== undefined ? indexes.declarations : undefined);
+                resolver = new CheckerDeclarationEmitResolver(this.checked.checker, syntactic);
+            }
+            host = new ProgramEmitHost(program, resolver);
+            this.host = host;
+        }
+        return host;
+    }
+    emit(files, emitOnly, writer) {
+        // Where `emitFiles` would emit nothing, it is not given a host, whose resolvers index every file.
+        const options = this.program.options;
+        if ((options.noEmit === true && emitOnly !== 3 /* EmitOnly.ForcedDts */) ||
+            !files.some((file) => sourceFileMayBeEmitted(file, options))) {
+            const result = new EmitResult();
+            result.emitSkipped = options.noEmit === true && emitOnly !== 3 /* EmitOnly.ForcedDts */;
+            return result;
+        }
+        const host = this.getHost(emitOnly === 3 /* EmitOnly.ForcedDts */);
+        host.writer = writer;
+        const result = emitFiles(host, files, emitOnly);
+        host.writer = undefined;
+        return result;
+    }
+    /** The declaration text and errors of `file`, emitted even without `declaration`. */
+    forcedDeclaration(file) {
+        const writer = new CapturingWriter();
+        this.emit([file], 3 /* EmitOnly.ForcedDts */, writer);
+        return writer;
+    }
+}
+/** A program as `tsc` compiles it. */
+export class CompilerProgram {
+    checked;
+    times;
+    emitter;
+    constructor(checked, times) {
+        this.checked = checked;
+        this.times = times;
+        this.emitter = new ProgramEmitter(checked);
+    }
+    get program() {
+        return this.checked.program;
+    }
+    get options() {
+        return this.checked.program.options;
+    }
+    getConfigFileParsingDiagnostics() {
+        return this.program.getConfigFileParsingDiagnostics();
+    }
+    getSyntacticDiagnostics() {
+        return this.program.getSyntacticDiagnostics();
+    }
+    getProgramDiagnostics() {
+        return this.program.getProgramDiagnostics();
+    }
+    /** See `CheckedProgram.getGlobalDiagnostics`. */
+    getGlobalDiagnostics(withCheckerThreads = true) {
+        return this.checked.getGlobalDiagnostics(withCheckerThreads);
+    }
+}
+/** Collects declaration emit errors without writing anything. */
+class DiscardingWriter extends OutputWriter {
+    write(_fileName, _text, _declarationDiagnostics) {
+        return skippedWrite;
+    }
+}
+export const discardingWriter = new DiscardingWriter();
+/** The declaration emit errors of `file` (none if it is not emitted). */
+export function declarationDiagnosticsOfFile(emitter, file) {
+    return emitter.emit([file], 3 /* EmitOnly.ForcedDts */, discardingWriter).diagnostics;
+}
+/** A program compiled from scratch. */
+export class PlainProgram extends CompilerProgram {
+    getSemanticDiagnostics() {
+        return this.checked.getSemanticDiagnostics(undefined);
+    }
+    getDeclarationDiagnostics() {
+        const files = this.program.getSourceFiles();
+        const parallel = this.checked.declarationsInParallel;
+        if (parallel === undefined)
+            return this.emitter.emit(files, 3 /* EmitOnly.ForcedDts */, discardingWriter).diagnostics;
+        // Declaration emit is per file: the files checker threads emitted, the others here, in order.
+        const result = [];
+        for (let i = 0; i < files.length; i++) {
+            const diagnostics = parallel[i] ?? declarationDiagnosticsOfFile(this.emitter, files[i]);
+            for (const d of diagnostics)
+                result.push(d);
+        }
+        return result;
+    }
+    emit(writer) {
+        const options = this.options;
+        if (options.noEmit !== true) {
+            const skipped = handleNoEmitOnError(this);
+            if (skipped !== undefined)
+                return skipped;
+        }
+        const program = this.program;
+        const files = program.getSourceFiles();
+        const parallel = this.checked.emittedInParallel;
+        // Checker threads emitted the files they checked (parallel-check.ts); the others are emitted here, in order.
+        const result = parallel === undefined
+            ? this.emitter.emit(files, 0 /* EmitOnly.All */, writer)
+            : combineEmitResults(files.map((file, i) => {
+                const emitted = parallel[i];
+                return emitted !== undefined
+                    ? writeHeldOutputs(emitted, writer)
+                    : this.emitter.emit([file], 0 /* EmitOnly.All */, writer);
+            }));
+        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;
+    }
+}
+/** Under `noEmitOnError`, a skipped emit with the errors that prevent it; otherwise `undefined`. */
+export function handleNoEmitOnError(program) {
+    if (program.options.noEmitOnError !== true)
+        return undefined;
+    const diagnostics = getDiagnosticsOfProgram(program, true);
+    if (diagnostics.length === 0)
+        return undefined;
+    const result = new EmitResult();
+    for (const d of diagnostics)
+        result.diagnostics.push(d);
+    result.emitSkipped = true;
+    return result;
+}
+/**
+ * Config and syntax errors; without syntax errors, program, global and semantic errors too, and
+ * declaration errors under `noEmit` (or `withDeclarationDiagnostics`).
+ */
+export function getDiagnosticsOfProgram(program, withDeclarationDiagnostics) {
+    const result = [...program.getConfigFileParsingDiagnostics()];
+    const configCount = result.length;
+    for (const d of program.getSyntacticDiagnostics())
+        result.push(d);
+    mark('syntactic diagnostics');
+    if (result.length !== configCount)
+        return result;
+    for (const d of program.getProgramDiagnostics())
+        result.push(d);
+    mark('program diagnostics');
+    const options = program.options;
+    if (options.listFilesOnly === true)
+        return result;
+    // Those found by checking come after the semantic diagnostics, as with a single checker.
+    for (const d of program.getGlobalDiagnostics(false))
+        result.push(d);
+    if (result.length === configCount) {
+        const checkStart = performance.now();
+        const semantic = program.getSemanticDiagnostics();
+        program.times.checkTime = performance.now() - checkStart;
+        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);
+        mark('semantic diagnostics');
+    }
+    if ((withDeclarationDiagnostics || options.noEmit === true) &&
+        getEmitDeclarations(options) &&
+        result.length === configCount) {
+        for (const d of program.getDeclarationDiagnostics())
+            result.push(d);
+    }
+    return result;
+}
+/** Combines emit results in order. */
+export function combineEmitResults(results) {
+    const result = new EmitResult();
+    for (const r of results) {
+        if (r.emitSkipped)
+            result.emitSkipped = true;
+        for (const d of r.diagnostics)
+            result.diagnostics.push(d);
+        for (const f of r.emittedFiles)
+            result.emittedFiles.push(f);
+        for (const e of r.errors)
+            result.errors.push(e);
+        for (const u of r.unsupported)
+            result.unsupported.push(u);
+    }
+    return result;
+}
+export { CheckedProgram };

package/dist/api/compiler/diagnostic-locales.d.ts

@@ -0,0 +1,22 @@
+/** The languages diagnostics are translated into, in tsgo's matcher order. */
+export declare const enum Locale {
+    /** Untranslated English. */
+    Default = 0,
+    ZhCN = 1,
+    ZhTW = 2,
+    CsCZ = 3,
+    DeDE = 4,
+    EsES = 5,
+    FrFR = 6,
+    ItIT = 7,
+    JaJP = 8,
+    KoKR = 9,
+    PlPL = 10,
+    PtBR = 11,
+    RuRU = 12,
+    TrTR = 13
+}
+/** The BCP 47 tag of each locale, indexed by `Locale`. */
+export declare const localeTags: readonly string[];
+/** The translated texts of `locale` in message order, separated by line feeds; empty where untranslated. */
+export declare function translations(locale: Locale): string;

package/dist/api/compiler/diagnostic-locales.js

@@ -0,0 +1,64 @@
+// Generated by scripts/generate-diagnostics.mjs. Do not edit.
+import { zhCN } from './locales/zh-CN.js';
+import { zhTW } from './locales/zh-TW.js';
+import { csCZ } from './locales/cs-CZ.js';
+import { deDE } from './locales/de-DE.js';
+import { esES } from './locales/es-ES.js';
+import { frFR } from './locales/fr-FR.js';
+import { itIT } from './locales/it-IT.js';
+import { jaJP } from './locales/ja-JP.js';
+import { koKR } from './locales/ko-KR.js';
+import { plPL } from './locales/pl-PL.js';
+import { ptBR } from './locales/pt-BR.js';
+import { ruRU } from './locales/ru-RU.js';
+import { trTR } from './locales/tr-TR.js';
+/** The BCP 47 tag of each locale, indexed by `Locale`. */
+export const localeTags = [
+    'en',
+    'zh-CN',
+    'zh-TW',
+    'cs-CZ',
+    'de-DE',
+    'es-ES',
+    'fr-FR',
+    'it-IT',
+    'ja-JP',
+    'ko-KR',
+    'pl-PL',
+    'pt-BR',
+    'ru-RU',
+    'tr-TR',
+];
+/** The translated texts of `locale` in message order, separated by line feeds; empty where untranslated. */
+export function translations(locale) {
+    switch (locale) {
+        case 1 /* Locale.ZhCN */:
+            return zhCN;
+        case 2 /* Locale.ZhTW */:
+            return zhTW;
+        case 3 /* Locale.CsCZ */:
+            return csCZ;
+        case 4 /* Locale.DeDE */:
+            return deDE;
+        case 5 /* Locale.EsES */:
+            return esES;
+        case 6 /* Locale.FrFR */:
+            return frFR;
+        case 7 /* Locale.ItIT */:
+            return itIT;
+        case 8 /* Locale.JaJP */:
+            return jaJP;
+        case 9 /* Locale.KoKR */:
+            return koKR;
+        case 10 /* Locale.PlPL */:
+            return plPL;
+        case 11 /* Locale.PtBR */:
+            return ptBR;
+        case 12 /* Locale.RuRU */:
+            return ruRU;
+        case 13 /* Locale.TrTR */:
+            return trTR;
+        default:
+            return '';
+    }
+}