tsc-ts 0.0.8 → 0.0.10

package/dist/api/compiler/parser.js

@@ -3010,17 +3010,12 @@ export class Parser extends ScannerErrorReporter {
         return false;
     }
     parseTypeOrTypePredicate() {
-        if (this.isIdentifier()) {
-            const state = this.beginSpeculation();
+        // `x is T`: the identifier is parsed only once `is` is known to follow it.
+        if (this.isIdentifier() && this.lookAhead(nextTokenIsIsKeywordOnSameLine)) {
             const pos = this.nodePos();
             const id = this.parseIdentifier(1 /* IdentifierUse.Name */);
-            if (this.token() === 142 /* SyntaxKind.IsKeyword */ && !this.hasPrecedingLineBreak()) {
-                this.endSpeculation(state);
-                this.nextToken();
-                return this.finishNode(new TypePredicateNode(undefined, id, this.parseType()), pos);
-            }
-            this.rewind(state);
-            this.endSpeculation(state);
+            this.nextToken();
+            return this.finishNode(new TypePredicateNode(undefined, id, this.parseType()), pos);
         }
         return this.parseType();
     }
@@ -5982,6 +5977,9 @@ function nextTokenCanFollowExportModifier(p) {
 function nextTokenIsClassKeywordOnSameLine(p) {
     return p.nextToken() === 85 /* SyntaxKind.ClassKeyword */ && !p.hasPrecedingLineBreak();
 }
+function nextTokenIsIsKeywordOnSameLine(p) {
+    return p.nextToken() === 142 /* SyntaxKind.IsKeyword */ && !p.hasPrecedingLineBreak();
+}
 function nextTokenIsFunctionKeywordOnSameLine(p) {
     return p.nextToken() === 99 /* SyntaxKind.FunctionKeyword */ && !p.hasPrecedingLineBreak();
 }
@@ -6034,11 +6032,14 @@ function nextIsUnParenthesizedAsyncArrowFunction(p) {
         // `async =>` is a simple arrow function with a parameter named `async`.
         if (p.hasPrecedingLineBreak() || p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */)
             return false;
-        const expr = p.parseBinaryExpressionOrHigher(0 /* OperatorPrecedence.Lowest */);
-        if (!p.hasPrecedingLineBreak() &&
-            expr.kind === 79 /* SyntaxKind.Identifier */ &&
-            p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */)
-            return true;
+        // The binary expression after `async` is a lone identifier followed by `=>` only when an identifier
+        // token is followed by `=>`. Any other first token starts another kind of expression or none, and any
+        // other token after the identifier continues the expression or ends it before `=>`. Checking the
+        // tokens gives the same answer as parsing the expression, whose nodes would be discarded.
+        if (!p.isIdentifier())
+            return false;
+        p.nextToken();
+        return !p.hasPrecedingLineBreak() && p.token() === 38 /* SyntaxKind.EqualsGreaterThanToken */;
     }
     return 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;

package/dist/api/compiler/printer/printer.js

@@ -39,6 +39,8 @@ export class PrinterOptions {
         this.terminateUnterminatedLiterals = false;
     }
 }
+/** The saved emit flags of a node whose comments were not looked for (`Printer.inCommentFreeRange`). */
+const commentFreeNode = -1;
 export class Printer extends NameGeneratorHost {
     options;
     context;
@@ -50,6 +52,13 @@ export class Printer extends NameGeneratorHost {
     currentSourceFile;
     sourceText;
     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.
+     */
+    lookupLine;
+    lookupLineStart;
+    lookupLineEnd;
     writer;
     ownWriter;
     uniqueHelperNames;
@@ -63,8 +72,25 @@ export class Printer extends NameGeneratorHost {
     commentsDisabled;
     /** Emitting the `extends` clause of a conditional or infer type. */
     inExtends;
-    /** Saved comment state: emit flags, comment pos, comment end, container pos, container end, declaration list end. */
+    /**
+     * 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.
+     */
     commentStack;
+    /** The used length of `commentStack`: entries are written in place and kept for reuse once popped. */
+    commentDepth;
+    /** Start positions of `//` and `/*` in `sourceText`, ascending; made on first use for each file. */
+    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.
+     */
+    freeStart;
+    freeEnd;
+    /** Whether no trailing comment follows `freeEnd`. */
+    freeEndTrailingNone;
+    freeOwner;
     /** Saved source map state: emit flags, pos, end, has token range. */
     sourceMapStack;
     /** The token position after `enterToken` skipped trivia. */
@@ -94,6 +120,9 @@ export class Printer extends NameGeneratorHost {
         this.currentSourceFile = undefined;
         this.sourceText = '';
         this.lineStarts = [];
+        this.lookupLine = -1;
+        this.lookupLineStart = 0;
+        this.lookupLineEnd = 0;
         this.writer = new TextWriter(options.newLine, 4);
         this.ownWriter = undefined;
         this.uniqueHelperNames = undefined;
@@ -105,7 +134,13 @@ export class Printer extends NameGeneratorHost {
         this.detachedComments = [];
         this.commentsDisabled = options.removeComments;
         this.inExtends = false;
-        this.commentStack = [];
+        this.commentStack = new Int32Array(96);
+        this.commentDepth = 0;
+        this.commentStarts = undefined;
+        this.freeStart = -1;
+        this.freeEnd = -1;
+        this.freeEndTrailingNone = false;
+        this.freeOwner = undefined;
         this.sourceMapStack = [];
         this.tokenPos = 0;
         this.sourceMapsDisabled = true;
@@ -150,6 +185,11 @@ export class Printer extends NameGeneratorHost {
         this.currentSourceFile = sourceFile;
         this.sourceText = sourceFile === undefined ? '' : sourceFile.text;
         this.lineStarts = sourceFile === undefined ? [] : sourceFile.lineStarts();
+        this.lookupLine = -1;
+        this.lookupLineStart = 0;
+        this.lookupLineEnd = 0;
+        this.commentStarts = undefined;
+        this.endCommentFreeRange();
         return true;
     }
     /** Prints `node` into `writer`, adding mappings to `sourceMapGenerator` if given. */
@@ -234,6 +274,9 @@ export class Printer extends NameGeneratorHost {
             case 79 /* SyntaxKind.Identifier */:
             case 80 /* SyntaxKind.PrivateIdentifier */:
             case 296 /* SyntaxKind.JsxNamespacedName */:
+                // Its text either way: the source text, or the text of a node from elsewhere.
+                if (this.textIsSourceText(node))
+                    return node.text;
                 if (!canUseSourceFile || !this.isInCurrentSourceFile(node)) {
                     if (node instanceof Identifier)
                         return node.text;
@@ -256,6 +299,39 @@ export class Printer extends NameGeneratorHost {
         }
         return getSourceTextOfNode(this.sourceText, node);
     }
+    /**
+     * 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.
+     */
+    textIsSourceText(node) {
+        if (!(node instanceof Identifier) && !(node instanceof PrivateIdentifier))
+            return false;
+        if ((node.flags & (8 /* NodeFlags.Reparsed */ | 4194304 /* NodeFlags.JSDoc */ | 268435456 /* NodeFlags.ReparserTransformedLiteral */)) !== 0)
+            return false;
+        const text = node.text;
+        const source = this.sourceText;
+        const end = node.end;
+        const start = end - text.length;
+        if (text.length === 0 || start < node.pos || end > source.length)
+            return false;
+        if (!source.startsWith(text, start))
+            return false;
+        if (start === node.pos)
+            return true;
+        const before = source.charCodeAt(start - 1);
+        return !((before >= 97 /* CharacterCodes.a */ && before <= 122 /* CharacterCodes.z */) ||
+            (before >= 65 /* CharacterCodes.A */ && before <= 90 /* CharacterCodes.Z */) ||
+            (before >= 48 /* CharacterCodes._0 */ && before <= 57 /* CharacterCodes._9 */) ||
+            before === 95 /* CharacterCodes._ */ ||
+            before === 36 /* CharacterCodes.$ */ ||
+            before === 92 /* CharacterCodes.backslash */ ||
+            before === 123 /* CharacterCodes.openBrace */ ||
+            before === 125 /* CharacterCodes.closeBrace */ ||
+            before === 35 /* CharacterCodes.hash */ ||
+            before > 127 /* CharacterCodes.maxAsciiCharacter */);
+    }
     isInCurrentSourceFile(node) {
         const file = this.currentSourceFile;
         if (file === undefined)
@@ -331,7 +407,28 @@ export class Printer extends NameGeneratorHost {
     }
     // Lines between nodes
     positionsAreOnSameLine(pos1, pos2) {
-        return getLinesBetweenPositions(this.lineStarts, pos1, pos2) === 0;
+        if (pos1 === pos2)
+            return true;
+        const lower = pos1 < pos2 ? pos1 : pos2;
+        const upper = pos1 < pos2 ? pos2 : pos1;
+        // What getLinesBetweenPositions finds: no line starts in (lower, upper].
+        if (lower < 0) {
+            const first = this.lineStarts.length > 0 ? this.lineStarts[0] | 0 : -1;
+            return first < 0 || upper < first;
+        }
+        this.lineOf(lower);
+        return this.lookupLineEnd < 0 || upper < this.lookupLineEnd;
+    }
+    /** The zero-based line of `pos` (-1 before the first line), which becomes the line of the last lookup. */
+    lineOf(pos) {
+        if (pos >= this.lookupLineStart && (pos < this.lookupLineEnd || this.lookupLineEnd < 0) && this.lookupLine >= 0)
+            return this.lookupLine;
+        const starts = this.lineStarts;
+        const line = computeLineOfPosition(starts, pos);
+        this.lookupLine = line;
+        this.lookupLineStart = line >= 0 ? starts[line] | 0 : 0;
+        this.lookupLineEnd = line + 1 < starts.length ? starts[line + 1] | 0 : -1;
+        return line;
     }
     rangeStart(pos) {
         return getStartPositionOfRange(this.sourceText, pos, false);
@@ -617,8 +714,13 @@ export class Printer extends NameGeneratorHost {
         return true;
     }
     // Names
-    // Source text of names reparsed from JSDoc can span lines.
+    // Source text of names reparsed from JSDoc can span lines; an identifier's own source text has no line breaks.
     emitIdentifierText(node) {
+        if (!this.context.autoGenerate.has(node) && this.textIsSourceText(node)) {
+            // writeText's answer for text without line breaks.
+            this.writer.write(node.text);
+            return false;
+        }
         return this.writer.writeText(this.getTextOfNode(node));
     }
     emitIdentifierName(node) {
@@ -3751,10 +3853,19 @@ export class Printer extends NameGeneratorHost {
     emitCommentsBeforeNode(node) {
         if (!this.shouldEmitComments(node))
             return false;
+        if (this.inCommentFreeRange(node)) {
+            // What the general path does for a node without emit data and without comments.
+            this.pushCommentState(commentFreeNode, node.pos, node.end);
+            this.containerPos = node.pos;
+            this.containerEnd = node.end;
+            if (node.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+                this.declarationListContainerEnd = node.end;
+            return true;
+        }
         const flags = this.context.getEmitFlags(node);
         const pos = this.context.commentPos(node);
         const end = this.context.commentEnd(node);
-        this.commentStack.push(flags, pos, end, this.containerPos, this.containerEnd, this.declarationListContainerEnd);
+        this.pushCommentState(flags, pos, end);
         this.emitLeadingCommentsOfNode(node, flags, pos, end);
         if ((flags & 128 /* EmitFlags.NoLeadingComments */) === 0) {
             const synthesized = this.context.getSyntheticLeadingComments(node);
@@ -3766,17 +3877,43 @@ export class Printer extends NameGeneratorHost {
             this.commentsDisabled = true;
         return true;
     }
+    /** Saves the comment state of a node: its emit flags (or `commentFreeNode`), comment range and the containers. */
+    pushCommentState(flags, pos, end) {
+        let stack = this.commentStack;
+        const at = this.commentDepth;
+        if (at + 6 > stack.length) {
+            const grown = new Int32Array(stack.length * 2);
+            grown.set(stack);
+            this.commentStack = grown;
+            stack = grown;
+        }
+        stack[at] = flags;
+        stack[at + 1] = pos;
+        stack[at + 2] = end;
+        stack[at + 3] = this.containerPos;
+        stack[at + 4] = this.containerEnd;
+        stack[at + 5] = this.declarationListContainerEnd;
+        this.commentDepth = at + 6;
+        return true;
+    }
     emitCommentsAfterNode(node) {
         const stack = this.commentStack;
-        const base = stack.length - 6;
-        // `| 0` keeps scriptc from typing array reads as possibly undefined.
-        const flags = stack[base] | 0;
-        const pos = stack[base + 1] | 0;
-        const end = stack[base + 2] | 0;
-        const containerPos = stack[base + 3] | 0;
-        const containerEnd = stack[base + 4] | 0;
-        const declarationListContainerEnd = stack[base + 5] | 0;
-        stack.length = base;
+        const base = this.commentDepth - 6;
+        const flags = stack[base];
+        const pos = stack[base + 1];
+        const end = stack[base + 2];
+        const containerPos = stack[base + 3];
+        const containerEnd = stack[base + 4];
+        const declarationListContainerEnd = stack[base + 5];
+        this.commentDepth = base;
+        if (node === this.freeOwner)
+            this.endCommentFreeRange();
+        if (flags === commentFreeNode) {
+            this.containerPos = containerPos;
+            this.containerEnd = containerEnd;
+            this.declarationListContainerEnd = declarationListContainerEnd;
+            return true;
+        }
         if ((flags & 512 /* EmitFlags.NoNestedComments */) !== 0)
             this.commentsDisabled = false;
         if ((flags & 256 /* EmitFlags.NoTrailingComments */) === 0) {
@@ -3792,6 +3929,87 @@ export class Printer extends NameGeneratorHost {
             this.emitTrailingCommentsOfNode(node, flags, typeNode.pos, typeNode.end, containerPos, containerEnd, declarationListContainerEnd);
         return true;
     }
+    /**
+     * 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`).
+     */
+    inCommentFreeRange(node) {
+        const pos = node.pos;
+        const end = node.end;
+        if (pos < 0 || end <= pos || node.kind === 11 /* SyntaxKind.JsxText */ || node.kind === 347 /* SyntaxKind.NotEmittedStatement */)
+            return false;
+        if (this.freeEnd < 0) {
+            if (!this.startCommentFreeRange(pos, end))
+                return false;
+            this.freeOwner = node;
+        }
+        else if (pos < this.freeStart)
+            return false;
+        if (this.context.hasEmitNode(node))
+            return false;
+        return end < this.freeEnd || (end === this.freeEnd && this.freeEndTrailingNone);
+    }
+    endCommentFreeRange() {
+        this.freeStart = -1;
+        this.freeEnd = -1;
+        this.freeEndTrailingNone = false;
+        this.freeOwner = undefined;
+        return true;
+    }
+    /** Whether the comment-free range shows that no trailing comment follows `pos`. */
+    noCommentsAfter(pos) {
+        return pos >= this.freeStart && (pos < this.freeEnd || (pos === this.freeEnd && this.freeEndTrailingNone));
+    }
+    /** Makes `[pos, end)` the comment-free range if no comment starts in it and its last character is not trivia. */
+    startCommentFreeRange(pos, end) {
+        const text = this.sourceText;
+        if (end > text.length)
+            return false;
+        const last = text.charCodeAt(end - 1);
+        if (last === 32 /* CharacterCodes.space */ ||
+            last === 9 /* CharacterCodes.tab */ ||
+            last === 10 /* CharacterCodes.lineFeed */ ||
+            last === 13 /* CharacterCodes.carriageReturn */ ||
+            last === 11 /* CharacterCodes.verticalTab */ ||
+            last === 12 /* CharacterCodes.formFeed */ ||
+            last > 127 /* CharacterCodes.maxAsciiCharacter */)
+            return false;
+        const starts = this.commentStartsOfFile();
+        // The first comment start at or after `pos`.
+        let low = 0;
+        let high = starts.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (starts[middle] < pos)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low < starts.length && starts[low] < end)
+            return false;
+        this.freeStart = pos;
+        this.freeEnd = end;
+        this.freeEndTrailingNone = getTrailingCommentRanges(text, end) === undefined;
+        return true;
+    }
+    commentStartsOfFile() {
+        const cached = this.commentStarts;
+        if (cached !== undefined)
+            return cached;
+        const text = this.sourceText;
+        const length = text.length;
+        const list = [];
+        for (let i = text.indexOf('/'); i >= 0 && i + 1 < length; i = text.indexOf('/', i + 1)) {
+            const next = text.charCodeAt(i + 1);
+            if (next === 47 /* CharacterCodes.slash */ || next === 42 /* CharacterCodes.asterisk */)
+                list.push(i);
+        }
+        const starts = new Int32Array(list.length);
+        for (let i = 0; i < list.length; i++)
+            starts[i] = list[i];
+        this.commentStarts = starts;
+        return starts;
+    }
     /** Emits comments before a token; returns whether `emitCommentsAfterToken` applies, with the token's position in `tokenPos`. */
     emitCommentsBeforeToken(pos, contextNode, flags) {
         if ((flags & 1 /* TokenEmitFlags.NoComments */) !== 0 || this.commentsDisabled) {
@@ -3897,6 +4115,8 @@ export class Printer extends NameGeneratorHost {
     emitLeadingComments(pos, elided) {
         if (this.commentsDisabled || this.currentSourceFile === undefined || pos < 0 || pos === this.containerPos)
             return false;
+        if (pos >= this.freeStart && pos < this.freeEnd)
+            return false;
         // 1: only triple-slash comments, 2: all but triple-slash comments, 0: all.
         let tripleSlash = 0;
         if (!elided) {
@@ -3947,6 +4167,8 @@ export class Printer extends NameGeneratorHost {
             this.currentSourceFile === undefined ||
             (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd)))
             return false;
+        if (this.noCommentsAfter(pos))
+            return false;
         const ranges = getTrailingCommentRanges(this.sourceText, pos);
         if (ranges === undefined)
             return false;
@@ -3965,6 +4187,8 @@ export class Printer extends NameGeneratorHost {
             return false;
         if (this.containerEnd !== -1 && (pos === this.containerEnd || pos === this.declarationListContainerEnd))
             return false;
+        if (this.noCommentsAfter(pos))
+            return false;
         const comments = getTrailingCommentRanges(this.sourceText, pos);
         if (comments === undefined)
             return false;

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

@@ -120,6 +120,10 @@ export declare class CheckedProgram {
      * emit. Set once every file is checked, when checker threads emit (parallel-check.ts).
      */
     emittedInParallel: (EmitResult | undefined)[] | undefined;
+    /** Emit threads emitted only the JavaScript of `emittedInParallel`: declarations are emitted here. */
+    javaScriptEmittedOnThreads: boolean;
+    /** The declaration emit of each file on the declaration thread (parallel-emit.ts); undefined for one it didn't emit. */
+    declarationsEmittedAhead: (EmitResult | undefined)[] | undefined;
     /**
      * The global diagnostics of this thread's checker before it emitted files while checker threads
      * checked (`emitUncheckedFiles`), reported instead of its current ones.
@@ -134,6 +138,23 @@ export declare class CheckedProgram {
      * incremental program keeps them unfiltered under `noEmit` too.
      */
     unfilteredDiagnosticsOfFile(file: SourceFile): Diagnostic[];
+    /**
+     * Checks the statements `start` to `end` of the declaration file `file` with this checker, one of the
+     * ranges that several checkers check it in (`checkSourceFileRange`, parallel-check.ts), and returns
+     * whether the checker then has diagnostics in the file.
+     */
+    checkRange(file: SourceFile, start: number, end: number): boolean;
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, where checkers checked it in
+     * ranges and found no diagnostics in it (`checkRange`).
+     */
+    unfilteredDiagnosticsOfCleanRanges(file: SourceFile): Diagnostic[];
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, from a new checker that checks it
+     * whole: for a file checked in ranges that found diagnostics in it (parallel-check.ts), part of which this
+     * thread's checker may have checked.
+     */
+    unfilteredDiagnosticsOfFileOnNewChecker(file: SourceFile): Diagnostic[];
     /**
      * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
      * Once checker threads checked the program, they come from the threads' diagnostics of the file,
@@ -156,6 +177,7 @@ export declare class CheckedProgram {
     skipTypeChecking(file: SourceFile): boolean;
     private collect;
     private collectChecked;
+    /** `checks` are the checker's diagnostics of `file`. */
     private getBindAndCheckDiagnostics;
     getIncludeProcessorDiagnostics(file: SourceFile): Diagnostic[];
 }

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

@@ -4,6 +4,7 @@ import { ModuleSpecifierHost } from './module-specifiers.js';
 import { sortAndDeduplicateDiagnostics } from './program.js';
 import { getEmitModuleFormatOfFile, getEmitSyntaxForUsageLocation, isCheckJsEnabledForFile, } from './program-utilities.js';
 import { bindSourceFile } from './binder.js';
+import { checkSourceFileRange } from './checker-source-file.js';
 import { computeLineOfPosition } from './scanner.js';
 /** What the checker needs, answered by a program. */
 export class ProgramCheckerHost extends CheckerHost {
@@ -209,6 +210,10 @@ export class CheckedProgram {
      * emit. Set once every file is checked, when checker threads emit (parallel-check.ts).
      */
     emittedInParallel = undefined;
+    /** Emit threads emitted only the JavaScript of `emittedInParallel`: declarations are emitted here. */
+    javaScriptEmittedOnThreads = false;
+    /** The declaration emit of each file on the declaration thread (parallel-emit.ts); undefined for one it didn't emit. */
+    declarationsEmittedAhead = undefined;
     /**
      * The global diagnostics of this thread's checker before it emitted files while checker threads
      * checked (`emitUncheckedFiles`), reported instead of its current ones.
@@ -250,6 +255,37 @@ export class CheckedProgram {
             result.push(d);
         return result;
     }
+    /**
+     * Checks the statements `start` to `end` of the declaration file `file` with this checker, one of the
+     * ranges that several checkers check it in (`checkSourceFileRange`, parallel-check.ts), and returns
+     * whether the checker then has diagnostics in the file.
+     */
+    checkRange(file, start, end) {
+        return checkSourceFileRange(this.checker, file, start, end);
+    }
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, where checkers checked it in
+     * ranges and found no diagnostics in it (`checkRange`).
+     */
+    unfilteredDiagnosticsOfCleanRanges(file) {
+        const result = this.getBindAndCheckDiagnostics(file, []);
+        for (const d of this.getIncludeProcessorDiagnostics(file))
+            result.push(d);
+        return result;
+    }
+    /**
+     * The diagnostics of `file`, as `unfilteredDiagnosticsOfFile` gives them, from a new checker that checks it
+     * whole: for a file checked in ranges that found diagnostics in it (parallel-check.ts), part of which this
+     * thread's checker may have checked.
+     */
+    unfilteredDiagnosticsOfFileOnNewChecker(file) {
+        const checker = this.createChecker();
+        const result = this.getBindAndCheckDiagnostics(file, checker.getDiagnostics(file));
+        disposeChecker(checker);
+        for (const d of this.getIncludeProcessorDiagnostics(file))
+            result.push(d);
+        return result;
+    }
     /**
      * The bind and check diagnostics of `file` before `noEmit` filtering and without include errors.
      * Once checker threads checked the program, they come from the threads' diagnostics of the file,
@@ -331,10 +367,11 @@ export class CheckedProgram {
         }
         return sortAndDeduplicateDiagnostics(result);
     }
-    getBindAndCheckDiagnostics(file) {
+    /** `checks` are the checker's diagnostics of `file`. */
+    getBindAndCheckDiagnostics(file, checks) {
         const options = this.program.options;
         const diagnostics = file.bindDiagnostics.slice();
-        for (const d of this.checker.getDiagnostics(file))
+        for (const d of checks ?? this.checker.getDiagnostics(file))
             diagnostics.push(d);
         if (isPlainJSFile(file, options)) {
             const result = [];

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

@@ -111,12 +111,8 @@ export declare class Program implements OutputPathsHost {
     /** Packages that modules resolved into, by name: whether any resolution into them was a declaration file. */
     getPackagesMap(): ReadonlyMap<string, boolean>;
     getResolvedModule(file: SourceFile, moduleName: string, mode: ModuleKind): ResolvedModule | undefined;
-    /** The program files that the imports and type reference directives of `file` resolved to. */
-    /**
-     * The files `file` imports and references through type directives. `byFileName`, the program's
-     * files by file name, finds a file without computing its path when it is resolved by that name.
-     */
-    getResolvedFilesOf(file: SourceFile, byFileName?: ReadonlyMap<string, SourceFile>): SourceFile[];
+    /** The files each file added to the program (`ProcessedFiles.addedFiles`), as indices of `getSourceFiles`. */
+    addedFiles(): readonly (readonly number[])[];
     /** The specifier of the implicit JSX runtime import of `file`, if any. */
     jsxRuntimeImportSpecifier(path: string): Node | undefined;
     getResolvedModuleFromModuleSpecifier(file: SourceFile, specifier: Node): ResolvedModule | undefined;