tsc-ts 0.0.9 → 0.0.10

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

@@ -197,6 +197,8 @@ class ParseTask {
     jsxRuntimeImport = undefined;
     /** The task of the same file name that was loaded instead of this one. */
     loadedTask = undefined;
+    /** Whether an import or a type reference directive adds the file (`ProcessedFiles.addedFiles`). */
+    byImport;
     constructor(normalizedFilePath, libFile, includeReason, isForAutomaticTypeDirective, increaseDepth, 
     /** A JavaScript file found in `node_modules`, loaded only within `maxNodeModuleJsDepth`. */
     elideOnDepth, packageId) {
@@ -207,6 +209,8 @@ class ParseTask {
         this.increaseDepth = increaseDepth;
         this.elideOnDepth = elideOnDepth;
         this.packageId = packageId;
+        const kind = includeReason !== undefined ? includeReason.kind : -1;
+        this.byImport = kind === 0 /* FileIncludeKind.Import */ || kind === 2 /* FileIncludeKind.TypeReferenceDirective */;
     }
     addSubTask(fileName, libFile, reason, increaseDepth, elideOnDepth, packageId) {
         (this.subTasks ??= []).push(new ParseTask(normalizePath(fileName), libFile, reason, false, increaseDepth, elideOnDepth, packageId));
@@ -223,12 +227,19 @@ class ParseTask {
         return trace ? (this.typeResolutionsTrace ??= []) : undefined;
     }
 }
+const noData = [];
 /** The tasks of one path, by file name casing. */
 class ParseTaskData {
     tasks = new Map();
     lowestDepth = Number.MAX_SAFE_INTEGER;
     startedSubTasks = false;
     packageId = undefined;
+    /** The index of this path's file in the program's files, once collected; -1 for none. */
+    index = -1;
+    /** For a deduplicated package's path, the tasks of the copy kept (`collect`). */
+    keptCopy = undefined;
+    /** The paths the file's imports and type reference directives add, once collected. */
+    added = noData;
     constructor(task) {
         this.tasks.set(task.normalizedFilePath, task);
     }
@@ -340,6 +351,7 @@ export class ProcessedFiles {
     redirectFilesByPath;
     projectReferenceMapper;
     preparedPackageJsons;
+    addedFiles;
     constructor(resolver, 
     /** Libraries first, sorted, then other files in load order. */
     files, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFiles, 
@@ -351,7 +363,12 @@ export 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) {
+    preparedPackageJsons, 
+    /**
+     * The files each file's imports and type reference directives added to the program, by index into
+     * `files`, without the file itself.
+     */
+    addedFiles) {
         this.resolver = resolver;
         this.files = files;
         this.filesByPath = filesByPath;
@@ -369,6 +386,7 @@ export class ProcessedFiles {
         this.redirectFilesByPath = redirectFilesByPath;
         this.projectReferenceMapper = projectReferenceMapper;
         this.preparedPackageJsons = preparedPackageJsons;
+        this.addedFiles = addedFiles;
     }
 }
 /** The files of `processed` with `file` in place of the file at its path, for `Program.updateFile`. */
@@ -377,7 +395,9 @@ export function withReplacedFile(processed, file) {
     files[files.findIndex((f) => f.path === file.path)] = file;
     const filesByPath = new Map(processed.filesByPath);
     filesByPath.set(file.path, file);
-    return new ProcessedFiles(processed.resolver, files, filesByPath, processed.missingFiles, processed.resolvedModules, processed.typeResolutionsInFile, processed.sourceFileMetadata, processed.jsxRuntimeImports, processed.importHelpersImportSpecifiers, processed.libFiles, processed.sourceFilesFoundSearchingNodeModules, processed.includeProcessor.copy(file.path), processed.outputFileToProjectReferenceSource, processed.redirectTargets, processed.redirectFilesByPath, processed.projectReferenceMapper, processed.preparedPackageJsons);
+    return new ProcessedFiles(processed.resolver, files, filesByPath, processed.missingFiles, processed.resolvedModules, processed.typeResolutionsInFile, processed.sourceFileMetadata, processed.jsxRuntimeImports, processed.importHelpersImportSpecifiers, processed.libFiles, processed.sourceFilesFoundSearchingNodeModules, processed.includeProcessor.copy(file.path), processed.outputFileToProjectReferenceSource, processed.redirectTargets, processed.redirectFilesByPath, processed.projectReferenceMapper, processed.preparedPackageJsons, 
+    // The file has the same references (`canReplaceFile`), and keeps its index.
+    processed.addedFiles);
 }
 /** Whether `file` imports the `importHelpers` module (tslib) under `options`. */
 export function needsImportHelpersImportSpecifier(file, options) {
@@ -1154,9 +1174,16 @@ export class FileLoader {
         const packageIdToSourceFile = new Map();
         const checkCasing = this.options.forceConsistentCasingInFileNames !== false;
         const seen = new Map();
-        const collectFiles = (tasks) => {
+        // The paths each file's imports and type reference directives add (the tasks of each path), for
+        // `ProcessedFiles.addedFiles`: recorded while collecting visits them, as their files are only known
+        // once every file is collected.
+        const fileData = [];
+        const libData = new Map();
+        const packageIdToData = new Map();
+        const collectFiles = (tasks, added) => {
             for (let task of tasks) {
                 const includeReason = task.includeReason;
+                const byImport = task.byImport;
                 // Automatic type directive tasks are an implementation detail, not a reason.
                 if (task.redirectedParseTask === undefined && !task.isForAutomaticTypeDirective) {
                     if (task.loadedTask !== undefined)
@@ -1165,6 +1192,8 @@ export class FileLoader {
                         addIncludeReason(includeProcessor, task, includeReason);
                 }
                 const data = this.taskDataByPath.get(task.path);
+                if (added !== undefined && data !== undefined && byImport)
+                    added.push(data);
                 if (!task.loaded || data === undefined)
                     continue;
                 const checkedName = seen.get(data);
@@ -1206,15 +1235,19 @@ export class FileLoader {
                             targets.push(task.normalizedFilePath);
                         redirectFilesByPath.set(task.path, new RedirectFile(files.length + redirectFilesByPath.size, task.normalizedFilePath, task.path, packageIdFile.path));
                         filesByPath.set(task.path, packageIdFile);
+                        data.keptCopy = packageIdToData.get(key);
                         if (data.lowestDepth > 0)
                             sourceFilesFoundSearchingNodeModules.add(task.path);
                         continue;
                     }
-                    if (file !== undefined)
+                    if (file !== undefined) {
                         packageIdToSourceFile.set(key, file);
+                        packageIdToData.set(key, data);
+                    }
                 }
+                let own = undefined;
                 if (task.subTasks !== undefined && task.subTasks.length > 0)
-                    collectFiles(task.subTasks);
+                    collectFiles(task.subTasks, (own = []));
                 const redirected = task.redirectedParseTask;
                 if (redirected !== undefined) {
                     outputFileToProjectReferenceSource.set(redirected.path, task.normalizedFilePath);
@@ -1235,11 +1268,15 @@ export class FileLoader {
                 }
                 if (task.libFile !== undefined) {
                     libFiles.push(file);
+                    libData.set(file, data);
                     libFilesByPath.set(path, task.libFile);
                 }
                 else {
                     files.push(file);
+                    fileData.push(data);
                 }
+                if (own !== undefined)
+                    data.added = own;
                 filesByPath.set(path, file);
                 resolvedModules.set(path, task.resolutionsInFile);
                 typeResolutionsInFile.set(path, task.typeResolutionsInFile);
@@ -1253,7 +1290,7 @@ export class FileLoader {
                     sourceFilesFoundSearchingNodeModules.add(path);
             }
         };
-        collectFiles(this.rootTasks);
+        collectFiles(this.rootTasks, undefined);
         const priorities = new Map();
         for (const file of libFiles)
             priorities.set(file, this.libFilePriority(file));
@@ -1261,6 +1298,25 @@ export class FileLoader {
         const allFiles = [...libFiles, ...files];
         for (const redirect of redirectFilesByPath.values())
             redirect.index += libFiles.length;
+        // The files a file adds, without reading its resolutions again or looking up their paths.
+        const dataOfFiles = [];
+        for (const file of libFiles)
+            dataOfFiles.push(libData.get(file));
+        for (const data of fileData)
+            dataOfFiles.push(data);
+        for (let i = 0; i < dataOfFiles.length; i++)
+            dataOfFiles[i].index = i;
+        const addedFiles = [];
+        for (let i = 0; i < dataOfFiles.length; i++) {
+            const added = [];
+            for (const data of dataOfFiles[i].added) {
+                const kept = data.keptCopy;
+                const k = kept !== undefined ? kept.index : data.index;
+                if (k >= 0 && k !== i)
+                    added.push(k);
+            }
+            addedFiles.push(added);
+        }
         const keys = [...this.libResolutions.keys()].sort();
         for (const key of keys) {
             const resolution = this.libResolutions.get(key);
@@ -1272,7 +1328,7 @@ export class FileLoader {
             for (const trace of resolution.trace)
                 host.trace(trace);
         }
-        return new ProcessedFiles(this.resolver, allFiles, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFilesByPath, sourceFilesFoundSearchingNodeModules, includeProcessor, outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, this.mapper, this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups);
+        return new ProcessedFiles(this.resolver, allFiles, filesByPath, missingFiles, resolvedModules, typeResolutionsInFile, sourceFileMetadata, jsxRuntimeImports, importHelpersImportSpecifiers, libFilesByPath, sourceFilesFoundSearchingNodeModules, includeProcessor, outputFileToProjectReferenceSource, redirectTargets, redirectFilesByPath, this.mapper, this.tookPreparedResolutions ? preparedPackageJsonLookups() : noPackageJsonLookups, addedFiles);
     }
 }
 const noPackageJsonLookups = [];

package/dist/api/compiler/parallel-parse.d.ts

@@ -128,7 +128,7 @@ export declare function fileSize(fileName: string): number;
  * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
  * which in a chunk of root files kept one thread busy after the others were done) and the files the
  * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
- * out in program order, in chunks of up to `maxChunk`.
+ * out in program order, in chunks of up to `maxChunk` files and about `maxChunkBytes` of text.
  */
 export declare class ParseQueue {
     private readonly libraries;
@@ -148,7 +148,8 @@ export declare class ParseQueue {
     left(): number;
     /**
      * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
-     * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+     * `full`, other files only go out in full chunks, `maxChunk` files or `maxChunkBytes` of text, and stay
+     * queued until there are as many.
      */
     next(threads: number, full?: boolean): LoadMessage | undefined;
 }

package/dist/api/compiler/parallel-parse.js

@@ -187,6 +187,12 @@ export function fileSize(fileName) {
 const maxChunk = 16;
 /** Files from this size (bytes) on take a parse thread 25 ms or more, and go out ahead of others. */
 const largeFile = 256 * 1024;
+/**
+ * The most text (bytes) a chunk of other files holds, about one large file's: a chunk ends with the file
+ * that reaches it. Sixteen of tsc-ts's own compiler sources, 50-200 KB each, made one chunk that kept its
+ * thread busy for 30-45 ms after the others were done.
+ */
+const maxChunkBytes = largeFile;
 /**
  * The files to hand out to parse threads, each queued once. Library files go out first, one per
  * chunk, also those found later through `/// <reference lib>`: a large one (`lib.dom.d.ts`) takes a
@@ -194,7 +200,7 @@ const largeFile = 256 * 1024;
  * Then, for the same reason, large files, one per chunk: root files (TypeScript's 3 MB `checker.ts`,
  * which in a chunk of root files kept one thread busy after the others were done) and the files the
  * parse threads found (`csstype`'s 0.9 MB of declarations, found through React's). The other files go
- * out in program order, in chunks of up to `maxChunk`.
+ * out in program order, in chunks of up to `maxChunk` files and about `maxChunkBytes` of text.
  */
 export class ParseQueue {
     libraries = new LoadJobs();
@@ -238,7 +244,8 @@ export class ParseQueue {
     }
     /**
      * The next chunk for one of `threads` parse threads, or `undefined` when nothing is left. With
-     * `full`, other files only go out `maxChunk` at a time, and stay queued until there are as many.
+     * `full`, other files only go out in full chunks, `maxChunk` files or `maxChunkBytes` of text, and stay
+     * queued until there are as many.
      */
     next(threads, full = false) {
         const libraries = this.libraries;
@@ -263,11 +270,16 @@ export class ParseQueue {
         }
         const queue = this.others;
         const left = queue.names.length - this.head;
-        if (left <= 0 || (full && left < maxChunk))
+        if (left <= 0)
             return undefined;
-        const size = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
+        const most = full ? maxChunk : Math.min(maxChunk, Math.max(1, Math.floor(left / threads)));
         const start = this.head;
-        const end = start + size;
+        let end = start;
+        let bytes = 0;
+        while (end < queue.names.length && end - start < most && bytes < maxChunkBytes)
+            bytes += queue.sizes[end++];
+        if (full && end - start < maxChunk && bytes < maxChunkBytes)
+            return undefined;
         this.head = end;
         return {
             stop: false,

package/dist/api/compiler/printer/emit-context.d.ts

@@ -91,6 +91,8 @@ export declare class EmitContext extends NodeFactory {
     getAutoGenerateInfo(node: Node): AutoGenerateInfo | undefined;
     /** The node a generated name is based on, following clones of generated names. */
     getNodeForGeneratedName(name: Node): Node;
+    /** Whether `node` has emit data: flags, ranges, helpers or synthesized comments. */
+    hasEmitNode(node: Node): boolean;
     getEmitFlags(node: Node): EmitFlags;
     setEmitFlags(node: Node, flags: EmitFlags): Node;
     addEmitFlags(node: Node, flags: EmitFlags): Node;

package/dist/api/compiler/printer/emit-context.js

@@ -228,6 +228,10 @@ export class EmitContext extends NodeFactory {
         return node;
     }
     // Emit data
+    /** Whether `node` has emit data: flags, ranges, helpers or synthesized comments. */
+    hasEmitNode(node) {
+        return this.lookup(node) !== undefined;
+    }
     getEmitFlags(node) {
         const emitNode = this.lookup(node);
         return emitNode === undefined ? 0 /* EmitFlags.None */ : emitNode.emitFlags;

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

@@ -101,6 +101,13 @@ export declare class Printer extends NameGeneratorHost {
     currentSourceFile: SourceFile | undefined;
     private sourceText;
     private lineStarts;
+    /**
+     * The line of the last `lineOf` lookup, `lookupLine`, and the positions it spans, `[lookupLineStart, lookupLineEnd)`,
+     * with `lookupLineEnd` -1 after the last line: printing reads positions mostly in order, so most lookups fall on that line.
+     */
+    private lookupLine;
+    private lookupLineStart;
+    private lookupLineEnd;
     private writer;
     private ownWriter;
     private uniqueHelperNames;
@@ -114,8 +121,25 @@ export declare class Printer extends NameGeneratorHost {
     private commentsDisabled;
     /** Emitting the `extends` clause of a conditional or infer type. */
     private inExtends;
-    /** Saved comment state: emit flags, comment pos, comment end, container pos, container end, declaration list end. */
-    private readonly commentStack;
+    /**
+     * Saved comment state, 32-bit values: emit flags, comment pos, comment end, container pos, container end,
+     * declaration list end.
+     * Flags are `commentFreeNode` for a node that `emitCommentsBeforeNode` handled in a comment-free range.
+     */
+    private commentStack;
+    /** The used length of `commentStack`: entries are written in place and kept for reuse once popped. */
+    private commentDepth;
+    /** Start positions of `//` and `/*` in `sourceText`, ascending; made on first use for each file. */
+    private commentStarts;
+    /**
+     * A range of `sourceText`, `[freeStart, freeEnd)`, where no comment starts and the last character is not trivia,
+     * so no comment is found from any position in it; -1 when there is none. `freeOwner` is the node it was made for.
+     */
+    private freeStart;
+    private freeEnd;
+    /** Whether no trailing comment follows `freeEnd`. */
+    private freeEndTrailingNone;
+    private freeOwner;
     /** Saved source map state: emit flags, pos, end, has token range. */
     private readonly sourceMapStack;
     /** The token position after `enterToken` skipped trivia. */
@@ -143,6 +167,13 @@ export declare class Printer extends NameGeneratorHost {
     private getLiteralTextOfNode;
     /** The text of an identifier, private identifier, literal or JSX namespaced name as printed. */
     getTextOfNode(node: Node): string;
+    /**
+     * Whether the source text of an identifier or private identifier of the current file, from the end of its leading
+     * trivia to its end, is its text: the text ends the node, and the character before it is not part of the token, as
+     * it would be in an identifier written with escapes. Nodes from JSDoc may span other text, so they are left to the
+     * general path.
+     */
+    private textIsSourceText;
     private isInCurrentSourceFile;
     private write1;
     private space;
@@ -155,6 +186,8 @@ export declare class Printer extends NameGeneratorHost {
     private writeLineSeparatorsAndIndentBefore;
     private writeLineSeparatorsAfter;
     private positionsAreOnSameLine;
+    /** The zero-based line of `pos` (-1 before the first line), which becomes the line of the last lookup. */
+    private lineOf;
     private rangeStart;
     private rangeIsOnSingleLine;
     private rangeEndIsOnSameLineAsRangeStart;
@@ -363,7 +396,20 @@ export declare class Printer extends NameGeneratorHost {
     private emitListItems;
     private emitAnyNode;
     private emitCommentsBeforeNode;
+    /** Saves the comment state of a node: its emit flags (or `commentFreeNode`), comment range and the containers. */
+    private pushCommentState;
     private emitCommentsAfterNode;
+    /**
+     * Whether `node` has no emit data and lies in a range of the source text where no comment is found, so that its
+     * comments need not be looked for. Outside such a range, a node whose own range is one starts it (`freeOwner`).
+     */
+    private inCommentFreeRange;
+    private endCommentFreeRange;
+    /** Whether the comment-free range shows that no trailing comment follows `pos`. */
+    private noCommentsAfter;
+    /** Makes `[pos, end)` the comment-free range if no comment starts in it and its last character is not trivia. */
+    private startCommentFreeRange;
+    private commentStartsOfFile;
     /** Emits comments before a token; returns whether `emitCommentsAfterToken` applies, with the token's position in `tokenPos`. */
     private emitCommentsBeforeToken;
     private emitCommentsAfterToken;