tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/diagnostics.js

@@ -747,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;
     }
@@ -831,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),
         ]);
@@ -854,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

@@ -196,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;
@@ -273,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.