tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/diagnostics.d.ts

@@ -109,6 +109,11 @@ export declare class Diagnostic {
     readonly reportsDeprecated: boolean;
     skippedOnNoEmit: boolean;
     repopulateInfo: RepopulateInfo | undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted: string;
     constructor(file: DiagnosticFile | undefined, pos: number, end: number, message: DiagnosticMessage, args?: readonly string[]);
     localize(locale: Locale): string;
     addMessageChain(chain: Diagnostic | undefined): Diagnostic;
@@ -132,6 +137,14 @@ export declare function chainDiagnostic(chain: Diagnostic | undefined, message:
 export declare function compareCodePoints(a: string, b: string): number;
 /** The order tsc reports diagnostics in: by file, position, code, arguments, then elaboration. */
 export declare function compareDiagnostics(a: Diagnostic, b: Diagnostic): number;
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export declare function sortDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];
 /** Whether two diagnostics report the same thing, ignoring related information. */
 export declare function equalDiagnosticsNoRelatedInfo(a: Diagnostic, b: Diagnostic): boolean;
 export declare function equalDiagnostics(a: Diagnostic, b: Diagnostic): boolean;
@@ -145,6 +158,15 @@ export interface DiagnosticFormatOptions {
 export declare function flattenDiagnosticMessage(diagnostic: Diagnostic, newLine: string, locale: Locale): string;
 /** `file(line,col): error TS1005: message`, as tsc prints without `--pretty`. */
 export declare function formatDiagnostic(diagnostic: Diagnostic, options: DiagnosticFormatOptions): string;
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export declare class FormattedReports {
+    format: DiagnosticFormatOptions | undefined;
+}
+export declare const formattedReports: FormattedReports;
 /** `formatDiagnostic` of each diagnostic. */
 export declare function formatDiagnostics(diagnostics: readonly Diagnostic[], options: DiagnosticFormatOptions): string;
 /** The colored form with source snippets, as tsc prints with `--pretty`. */

package/dist/api/compiler/diagnostics.js

@@ -326,6 +326,11 @@ export class Diagnostic {
     reportsDeprecated;
     skippedOnNoEmit = false;
     repopulateInfo = undefined;
+    /**
+     * What `formatDiagnostic` gives for this diagnostic in `formattedReports.format`, where the checker
+     * thread that found it formatted it (`packResult`); `''` otherwise.
+     */
+    formatted = '';
     constructor(file, pos, end, message, args = []) {
         this.file = file;
         this.pos = pos;
@@ -358,6 +363,7 @@ export class Diagnostic {
         result.relatedInformation = this.relatedInformation;
         result.skippedOnNoEmit = this.skippedOnNoEmit;
         result.repopulateInfo = this.repopulateInfo;
+        result.formatted = this.formatted;
         return result;
     }
 }
@@ -463,10 +469,12 @@ function compareRelatedInfo(a, b) {
 export function compareDiagnostics(a, b) {
     if (a === b)
         return 0;
-    let c = compareCodePoints(fileNameOf(a), fileNameOf(b));
-    if (c !== 0)
-        return c;
-    c = a.pos - b.pos;
+    const c = compareCodePoints(fileNameOf(a), fileNameOf(b));
+    return c !== 0 ? c : compareDiagnosticsInFile(a, b);
+}
+/** `compareDiagnostics` of two diagnostics whose files have the same name. */
+function compareDiagnosticsInFile(a, b) {
+    let c = a.pos - b.pos;
     if (c !== 0)
         return c;
     c = a.end - b.end;
@@ -486,6 +494,66 @@ export function compareDiagnostics(a, b) {
         return c;
     return compareRelatedInfo(a.relatedInformation, b.relatedInformation);
 }
+/**
+ * `diagnostics` in the order of `compareDiagnostics`, equal ones in their order in `diagnostics`. File
+ * names are compared once per pair of files rather than once per pair of diagnostics: the distinct
+ * files are sorted by name, and each diagnostic sorts by its file's place in that order, then by the
+ * rest of `compareDiagnostics`. A program's diagnostics come a file at a time, so the files are found
+ * from the runs of one file.
+ */
+export function sortDiagnostics(diagnostics) {
+    const n = diagnostics.length;
+    if (n < 2)
+        return diagnostics.slice();
+    const fileIndices = new Map();
+    const files = [];
+    const fileOf = [];
+    let last = undefined;
+    let lastIndex = -1;
+    for (let i = 0; i < n; i++) {
+        const file = diagnostics[i].file;
+        if (lastIndex < 0 || file !== last) {
+            let k = fileIndices.get(file);
+            if (k === undefined) {
+                k = files.length;
+                fileIndices.set(file, k);
+                files.push(file);
+            }
+            last = file;
+            lastIndex = k;
+        }
+        fileOf.push(lastIndex);
+    }
+    // Files with the same name share a rank, as they compare equal.
+    const nameOf = (k) => {
+        const file = files[k];
+        return file === undefined ? '' : file.fileName;
+    };
+    const byName = [];
+    for (let k = 0; k < files.length; k++)
+        byName.push(k);
+    byName.sort((x, y) => compareCodePoints(nameOf(x), nameOf(y)));
+    const rank = [];
+    for (let k = 0; k < files.length; k++)
+        rank.push(0);
+    for (let k = 1; k < byName.length; k++)
+        rank[byName[k]] = rank[byName[k - 1]] + (nameOf(byName[k]) === nameOf(byName[k - 1]) ? 0 : 1);
+    const order = [];
+    for (let i = 0; i < n; i++)
+        order.push(i);
+    order.sort((x, y) => {
+        const c = rank[fileOf[x]] - rank[fileOf[y]];
+        if (c !== 0)
+            return c;
+        const a = diagnostics[x];
+        const b = diagnostics[y];
+        return a === b ? 0 : compareDiagnosticsInFile(a, b);
+    });
+    const sorted = [];
+    for (const i of order)
+        sorted.push(diagnostics[i]);
+    return sorted;
+}
 function equalChain(a, b) {
     if (a.length !== b.length)
         return false;
@@ -567,13 +635,27 @@ function formatDiagnosticIn(diagnostic, fileName, options) {
     result += `${categoryName(diagnostic.category)} TS${diagnostic.code}: `;
     return result + flattenDiagnosticMessage(diagnostic, options.newLine, options.locale) + options.newLine;
 }
+/**
+ * The plain format the main thread reports a compilation's diagnostics in (`DiagnosticReporter.plainFormat`),
+ * which its checker threads receive a copy of and format the diagnostics they send back in
+ * (`Diagnostic.formatted`). Unset where diagnostics are reported with color and context, or not at all.
+ */
+export class FormattedReports {
+    format = undefined;
+}
+export const formattedReports = new FormattedReports();
 /** `formatDiagnostic` of each diagnostic. */
 export function formatDiagnostics(diagnostics, options) {
     let result = '';
+    const formatted = options === formattedReports.format;
     // Sorted diagnostics come a file at a time: the relative name of the last file is kept.
     let lastFile = undefined;
     let lastName = '';
     for (const diagnostic of diagnostics) {
+        if (formatted && diagnostic.formatted !== '') {
+            result += diagnostic.formatted;
+            continue;
+        }
         const file = diagnostic.file;
         if (file !== undefined && file !== lastFile) {
             lastFile = file;
@@ -665,7 +747,7 @@ export function formatDiagnosticWithColorAndContext(diagnostic, options) {
     result += styled(categoryName(diagnostic.category), color);
     result += `${grey} TS${diagnostic.code}: ${reset}`;
     result += flattenDiagnosticMessage(diagnostic, newLine, options.locale);
-    if (file !== undefined && diagnostic.code !== messageCode(405 /* Diagnostics.File_appears_to_be_binary */)) {
+    if (file !== undefined && diagnostic.code !== messageCode(403 /* Diagnostics.File_appears_to_be_binary */)) {
         result +=
             newLine + codeSnippet(file, diagnostic.pos, diagnostic.end - diagnostic.pos, color, '', options) + newLine;
     }
@@ -749,20 +831,20 @@ export function formatErrorSummary(diagnostics, options) {
     if (totalErrorCount === 1) {
         message =
             globalErrorCount > 0 || firstFileName === ''
-                ? localizeMessage(locale, 1369 /* Diagnostics.Found_1_error */, [])
-                : localizeMessage(locale, 1411 /* Diagnostics.Found_1_error_in_0 */, [firstFileName]);
+                ? localizeMessage(locale, 1380 /* Diagnostics.Found_1_error */, [])
+                : localizeMessage(locale, 1422 /* Diagnostics.Found_1_error_in_0 */, [firstFileName]);
     }
     else if (fileCount === 0) {
-        message = localizeMessage(locale, 1370 /* Diagnostics.Found_0_errors */, [String(totalErrorCount)]);
+        message = localizeMessage(locale, 1381 /* Diagnostics.Found_0_errors */, [String(totalErrorCount)]);
     }
     else if (fileCount === 1) {
-        message = localizeMessage(locale, 1412 /* Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 */, [
+        message = localizeMessage(locale, 1423 /* Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 */, [
             String(totalErrorCount),
             firstFileName,
         ]);
     }
     else {
-        message = localizeMessage(locale, 1413 /* Diagnostics.Found_0_errors_in_1_files */, [
+        message = localizeMessage(locale, 1424 /* Diagnostics.Found_0_errors_in_1_files */, [
             String(totalErrorCount),
             String(fileCount),
         ]);
@@ -772,7 +854,7 @@ export function formatErrorSummary(diagnostics, options) {
         let maxErrors = 0;
         for (const entry of sorted)
             maxErrors = Math.max(maxErrors, entry.errors.length);
-        const headerRow = localizeMessage(locale, 1220 /* Diagnostics.Errors_Files */, []);
+        const headerRow = localizeMessage(locale, 1231 /* Diagnostics.Errors_Files */, []);
         const leftColumnHeadingLength = utf8Length(headerRow.split(' ')[0]);
         const lengthOfBiggestErrorCount = String(maxErrors).length;
         const leftPaddingGoal = Math.max(leftColumnHeadingLength, lengthOfBiggestErrorCount);

package/dist/api/compiler/emitter.d.ts

@@ -66,6 +66,12 @@ export declare const enum EmitOnly {
      * The declaration file alone, even without `declaration` and despite errors, for the shape
      * signature of incremental builds; it is written with its errors and without a map.
      */
-    ForcedDts = 3
+    ForcedDts = 3,
+    /**
+     * The declaration file of a file whose JavaScript this build emits in a separate request, such as on another
+     * thread. tsgo emits both with one emit context, so the emit flags its JavaScript transforms set on the file's
+     * own nodes also apply to its declarations; this replays those transforms first.
+     */
+    DtsAfterJs = 4
 }
 export declare function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly?: EmitOnly): EmitResult;

package/dist/api/compiler/emitter.js

@@ -1,4 +1,4 @@
-import { compareDiagnostics } from './diagnostics.js';
+import { compareDiagnostics, equalDiagnostics } from './diagnostics.js';
 import { JsxEmit, NewLineKind, getEmitScriptTarget, getIsolatedModules } from './options.js';
 import { getOutputPathsFor } from './output-paths.js';
 import { combinePaths, fileExtensionIs, getBaseFileName, getDirectoryPath, getRootLength, normalizePath, normalizeSlashes, ensureTrailingDirectorySeparator, containsPath, getNormalizedAbsolutePath, } from './path.js';
@@ -107,30 +107,52 @@ export function emitFiles(host, files, emitOnly = 0 /* EmitOnly.All */) {
         if (!sourceFileMayBeEmitted(file, options) || host.isSourceFileFromExternalLibrary(file))
             continue;
         const paths = getOutputPathsFor(file.fileName, file.scriptKind === 6 /* ScriptKind.JSON */, options, host, forced);
+        // As in tsgo, a file's JavaScript and declarations share one emit context: emit flags that JavaScript
+        // transforms set on the file's own nodes, such as a decorated parameter's name, also apply to its declarations.
+        const context = new EmitContext();
         if (paths.jsFilePath !== '' && (emitOnly === 0 /* EmitOnly.All */ || emitOnly === 1 /* EmitOnly.Js */)) {
             if (host.isEmitBlocked(paths.jsFilePath))
                 result.emitSkipped = true;
             else
-                emitJSFile(host, file, paths.jsFilePath, paths.sourceMapFilePath, result);
+                emitJSFile(host, context, file, paths.jsFilePath, paths.sourceMapFilePath, result);
         }
         if (paths.declarationFilePath !== '' && emitOnly !== 1 /* EmitOnly.Js */) {
             if (!forced && host.isEmitBlocked(paths.declarationFilePath))
                 result.emitSkipped = true;
-            else
-                emitDeclarationFile(host, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+            else {
+                if (emitOnly === 4 /* EmitOnly.DtsAfterJs */ && paths.jsFilePath !== '')
+                    replayScriptTransforms(host, context, file);
+                emitDeclarationFile(host, context, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+            }
         }
     }
     return result;
 }
+/**
+ * Runs the JavaScript transforms of `file` in `context` without printing, for the emit flags they set on the
+ * file's own nodes. Only the decorator transforms set any that declaration emit prints (on decorated parameters'
+ * names), so files without decorators are skipped.
+ */
+function replayScriptTransforms(host, context, file) {
+    if (!new SyntaxFacts().has(file, 262144 /* SubtreeFacts.ContainsDecorators */))
+        return;
+    let transformed = file;
+    const transformers = getScriptTransformers(host, context, file);
+    for (let i = 0; i < transformers.length; i++) {
+        const transformer = transformers[i];
+        if (transformer.unsupported !== '')
+            return;
+        transformed = transformer.transformSourceFile(transformed);
+    }
+}
 /** Emits a declaration file; the host's resolver must be a `DeclarationEmitResolver`. */
-function emitDeclarationFile(host, file, declarationFilePath, declarationMapPath, result, forced) {
+function emitDeclarationFile(host, context, file, declarationFilePath, declarationMapPath, result, forced) {
     const resolver = host.resolver;
     if (!(resolver instanceof DeclarationEmitResolver)) {
         result.errors.push(file.fileName + ': declaration emit needs a declaration resolver');
         return false;
     }
     const options = host.options;
-    const context = new EmitContext();
     const transformer = new DeclarationTransformer(context, host, options, resolver, declarationFilePath);
     const transformed = transformer.transformSourceFile(file);
     result.declarationTransformed = true;
@@ -152,9 +174,30 @@ function emitDeclarationFile(host, file, declarationFilePath, declarationMapPath
     printerOptions.omitBraceSourceMapPositions = true;
     const printer = new Printer(printerOptions, context);
     const emitSourceMaps = declarationMap && !fileExtensionIs(file.fileName, '.json');
-    return printSourceFile(host, declarationFilePath, forced ? '' : declarationMapPath, transformed, printer, emitSourceMaps, false, result, 
-    // Sorted, as tsgo's emitter diagnostics are; the order is part of the file's signature in build info.
-    diagnostics.length > 1 ? diagnostics.toSorted(compareDiagnostics) : diagnostics);
+    return printSourceFile(host, declarationFilePath, forced ? '' : declarationMapPath, transformed, printer, emitSourceMaps, false, result, emitterDiagnostics(diagnostics));
+}
+/**
+ * Declaration diagnostics as tsgo's emitter collects them: sorted, without repeats of an equal
+ * diagnostic. They are part of the file's signature in build info.
+ */
+function emitterDiagnostics(diagnostics) {
+    if (diagnostics.length < 2)
+        return diagnostics;
+    const sorted = diagnostics.toSorted(compareDiagnostics);
+    const result = [];
+    for (const diagnostic of sorted) {
+        // Equal diagnostics compare as 0, so a repeat is among the last ones kept that compare as 0.
+        let repeated = false;
+        for (let i = result.length - 1; i >= 0 && compareDiagnostics(result[i], diagnostic) === 0; i--) {
+            if (equalDiagnostics(result[i], diagnostic)) {
+                repeated = true;
+                break;
+            }
+        }
+        if (!repeated)
+            result.push(diagnostic);
+    }
+    return result;
 }
 function getScriptTransformers(host, context, file) {
     const options = host.options;
@@ -182,9 +225,8 @@ function isJsxTransformEnabled(options) {
     const jsx = options.jsx;
     return jsx === JsxEmit.React || jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev;
 }
-function emitJSFile(host, file, jsFilePath, sourceMapFilePath, result) {
+function emitJSFile(host, context, file, jsFilePath, sourceMapFilePath, result) {
     const options = host.options;
-    const context = new EmitContext();
     let transformed = file;
     const transformers = getScriptTransformers(host, context, file);
     for (let i = 0; i < transformers.length; i++) {

package/dist/api/compiler/file-include.d.ts

@@ -125,7 +125,8 @@ export declare class IncludeProcessor {
     /** The program is created: the processing diagnostics so far are those a copy takes. */
     noteProgramCreated(): void;
     reasonsOf(path: string): readonly FileIncludeReason[];
-    addReason(path: string, reason: FileIncludeReason): void;
+    /** Adds an include reason of the file at `path`; returns the file's reasons. */
+    addReason(path: string, reason: FileIncludeReason): FileIncludeReason[];
     addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void;
     /** Reports a file name that differs from an included one only in casing. */
     addCasingDiagnostic(file: string, existingCasing: string, currentCasing: string, reason: FileIncludeReason | undefined): void;

package/dist/api/compiler/file-include.js

@@ -347,14 +347,14 @@ export class ProcessingDiagnostic {
             const location = reason.getReferencedLocation(program);
             const fileName = location.ref?.fileName ?? '';
             if (reason.kind === 2 /* FileIncludeKind.TypeReferenceDirective */) {
-                return location.diagnosticAt(821 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, fileName);
+                return location.diagnosticAt(828 /* Diagnostics.Cannot_find_type_definition_file_for_0 */, fileName);
             }
             const libName = toFileNameLowerCase(fileName);
             const unqualified = stripLibAffixes(libName);
             const suggestion = getSpellingSuggestion(unqualified, libNames);
             return suggestion !== ''
-                ? location.diagnosticAt(859 /* Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 */, libName, suggestion)
-                : location.diagnosticAt(858 /* Diagnostics.Cannot_find_lib_definition_for_0 */, libName, suggestion);
+                ? location.diagnosticAt(866 /* Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 */, libName, suggestion)
+                : location.diagnosticAt(865 /* Diagnostics.Cannot_find_lib_definition_for_0 */, libName, suggestion);
         }
         return this.explainFile(program);
     }
@@ -495,12 +495,16 @@ export class IncludeProcessor {
     reasonsOf(path) {
         return this.fileIncludeReasons.get(path) ?? [];
     }
+    /** Adds an include reason of the file at `path`; returns the file's reasons. */
     addReason(path, reason) {
         const reasons = this.fileIncludeReasons.get(path);
-        if (reasons === undefined)
-            this.fileIncludeReasons.set(path, [reason]);
-        else
-            reasons.push(reason);
+        if (reasons === undefined) {
+            const added = [reason];
+            this.fileIncludeReasons.set(path, added);
+            return added;
+        }
+        reasons.push(reason);
+        return reasons;
     }
     addProcessingDiagnostic(diagnostic) {
         this.processingDiagnostics.push(diagnostic);

package/dist/api/compiler/file-loader.d.ts

@@ -147,6 +147,11 @@ export declare class ProcessedFiles {
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
     readonly preparedPackageJsons: readonly PackageJsonLookup[] | undefined;
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    readonly addedFiles: readonly (readonly number[])[];
     constructor(resolver: Resolver, 
     /** Libraries first, sorted, then other files in load order. */
     files: readonly SourceFile[], filesByPath: ReadonlyMap<string, SourceFile>, missingFiles: readonly string[], resolvedModules: ReadonlyMap<string, ModeAwareCache<ResolvedModule> | undefined>, typeResolutionsInFile: ReadonlyMap<string, ModeAwareCache<ResolvedTypeReferenceDirective> | undefined>, sourceFileMetadata: ReadonlyMap<string, SourceFileMetadata>, jsxRuntimeImports: ReadonlyMap<string, JsxRuntimeImport>, importHelpersImportSpecifiers: ReadonlyMap<string, StringLiteral>, libFiles: ReadonlyMap<string, LibFile>, 
@@ -158,7 +163,12 @@ export declare class ProcessedFiles {
      * The `package.json` lookups made resolving the files whose resolutions were taken from parse
      * threads (`preparedPackageJsonLookups`); `undefined` where they may miss some.
      */
-    preparedPackageJsons: readonly PackageJsonLookup[] | undefined);
+    preparedPackageJsons: readonly PackageJsonLookup[] | undefined, 
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    addedFiles: readonly (readonly number[])[]);
 }
 /** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
 export declare function withReplacedFile(processed: ProcessedFiles, file: SourceFile): ProcessedFiles;
@@ -186,6 +196,9 @@ export declare class FileLoader {
     private readonly supportedExtensionsWithJson;
     private readonly maxNodeModuleJsDepth;
     private readonly rootTasks;
+    /** The tasks of each path, created when a task of the path is first queued or built ahead. */
+    private readonly taskData;
+    /** The index in `taskData` of each path's tasks. */
     private readonly taskDataByPath;
     /** Work queued by `start`, run last-in first-out like tsgo's single-threaded work group. */
     private readonly work;
@@ -263,7 +276,14 @@ export declare class FileLoader {
     private pathForLibFile;
     private libFilePriority;
     private start;
+    /** The index in `taskData` of the tasks of `path`, created if needed. */
+    private dataIndexOf;
     private run;
+    /**
+     * Whether `run` drops `work` without loading its file: a JavaScript file past `maxNodeModuleJsDepth`,
+     * which no parse thread prepares, so the walk ahead does not wait for it.
+     */
+    private elides;
     /**
      * Whether running the work of `task` (of `data`'s path) may parse a file that parse threads have not
      * prepared yet: a task of the path not loaded yet, or `task`, a new casing.