tsc-ts 0.0.9 → 0.0.10

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.

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

@@ -210,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.

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;

package/dist/api/compiler/program.js

@@ -7,7 +7,7 @@
  * ```
  */
 import { ArrayLiteralExpression, Decorator, getText, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, } from './ast.js';
-import { compareDiagnostics, createCompilerDiagnostic, Diagnostic, equalDiagnostics, equalDiagnosticsNoRelatedInfo, useThreadTextCaches, } from './diagnostics.js';
+import { compareDiagnostics, createCompilerDiagnostic, Diagnostic, equalDiagnostics, equalDiagnosticsNoRelatedInfo, sortDiagnostics, useThreadTextCaches, } from './diagnostics.js';
 import { canReplaceFile, FileLoader, jsxRuntimeImportOf, modeAwareKey, needsImportHelpersImportSpecifier, withReplacedFile, } from './file-loader.js';
 import { PackageJsonLookup } from './package-json.js';
 import { ProcessingDiagnostic } from './file-include.js';
@@ -325,34 +325,9 @@ export class Program {
     getResolvedModule(file, moduleName, mode) {
         return this.processed.resolvedModules.get(file.path)?.get(modeAwareKey(moduleName, mode));
     }
-    /** 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, byFileName) {
-        const result = [];
-        const modules = this.processed.resolvedModules.get(file.path);
-        if (modules !== undefined)
-            for (const resolved of modules.values()) {
-                const name = resolved.resolvedFileName;
-                if (name === '')
-                    continue;
-                const target = byFileName?.get(name) ?? this.getSourceFileForResolvedModule(name);
-                if (target !== undefined)
-                    result.push(target);
-            }
-        const types = this.processed.typeResolutionsInFile.get(file.path);
-        if (types !== undefined)
-            for (const resolved of types.values()) {
-                const name = resolved.resolvedFileName;
-                if (name === '')
-                    continue;
-                const target = byFileName?.get(name) ?? this.getSourceFile(name);
-                if (target !== undefined)
-                    result.push(target);
-            }
-        return result;
+    /** The files each file added to the program (`ProcessedFiles.addedFiles`), as indices of `getSourceFiles`. */
+    addedFiles() {
+        return this.processed.addedFiles;
     }
     /** The specifier of the implicit JSX runtime import of `file`, if any. */
     jsxRuntimeImportSpecifier(path) {
@@ -986,7 +961,7 @@ class NodeCollector extends NodeVisitor {
 }
 /** Sorts diagnostics and merges duplicates, combining their related information. */
 export function sortAndDeduplicateDiagnostics(diagnostics) {
-    const sorted = [...diagnostics].sort(compareDiagnostics);
+    const sorted = sortDiagnostics(diagnostics);
     if (sorted.length < 2)
         return sorted;
     const result = [];

package/dist/api/compiler/relations.js

@@ -232,6 +232,16 @@ export function isTypeRelatedTo(c, source, target, relation) {
         if ((source.flags & 394239 /* TypeFlags.Singleton */) !== 0)
             return true;
     }
+    else {
+        // What the relater decides first for types that may simplify (Relater.isRelatedToEx): their normal forms are
+        // one type, or can be identical only with identical flags.
+        const s = getNormalizedType(c, source, false);
+        const t = getNormalizedType(c, target, true);
+        if (s === t)
+            return true;
+        if (s.flags !== t.flags)
+            return false;
+    }
     if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) !== 0) {
         const related = relation.get(getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key);
         if (related !== 0 /* RelationComparisonResult.None */)

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

@@ -139,7 +139,7 @@ export declare class SymbolRareFields implements ProgramLifetime {
 }
 export declare class Symbol implements ProgramLifetime {
     flags: SymbolFlags;
-    /** The check flags, and `valueDeclarationIsFirst`. */
+    /** The check flags, and `SymbolBits.ValueDeclarationIsFirst`. */
     private bits;
     readonly name: string;
     /**

package/dist/api/compiler/symbol.js

@@ -8,11 +8,9 @@ export class SymbolRareFields {
     /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
     valueDeclaration = undefined;
 }
-/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
-const valueDeclarationIsFirst = 1 << 30;
 export class Symbol {
     flags;
-    /** The check flags, and `valueDeclarationIsFirst`. */
+    /** The check flags, and `SymbolBits.ValueDeclarationIsFirst`. */
     bits;
     name;
     /**
@@ -35,17 +33,17 @@ export class Symbol {
         this.id = idsAtCreation ? takeSymbolId() : 0;
     }
     get checkFlags() {
-        return (this.bits & ~valueDeclarationIsFirst);
+        return (this.bits & ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */);
     }
     set checkFlags(flags) {
-        this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+        this.bits = (this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) | flags;
     }
     /** Makes `node` the first declaration, keeping the value declaration. */
     setFirst(node) {
-        if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+        if ((this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) !== 0 && node !== this.declaration) {
             // The value declaration stays what it was.
             this.rareFieldsOrNew().valueDeclaration = this.declaration;
-            this.bits &= ~valueDeclarationIsFirst;
+            this.bits &= ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
         }
         this.declaration = node;
     }
@@ -54,7 +52,7 @@ export class Symbol {
      * says; any other is kept in the rare fields.
      */
     get valueDeclaration() {
-        if ((this.bits & valueDeclarationIsFirst) !== 0)
+        if ((this.bits & 1073741824 /* SymbolBits.ValueDeclarationIsFirst */) !== 0)
             return this.declaration;
         const group = this.rareFields;
         return group === undefined ? undefined : group.valueDeclaration;
@@ -62,12 +60,12 @@ export class Symbol {
     set valueDeclaration(node) {
         const group = this.rareFields;
         if (node !== undefined && node === this.declaration) {
-            this.bits |= valueDeclarationIsFirst;
+            this.bits |= 1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
             if (group !== undefined)
                 group.valueDeclaration = undefined;
             return;
         }
-        this.bits &= ~valueDeclarationIsFirst;
+        this.bits &= ~1073741824 /* SymbolBits.ValueDeclarationIsFirst */;
         if (node !== undefined || group !== undefined)
             this.rareFieldsOrNew().valueDeclaration = node;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsc-ts",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "The TypeScript 7 compiler, ported to TypeScript and compiled to a native executable.",
   "license": "Apache-2.0",
   "repository": {
@@ -29,18 +29,18 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@scriptc/threads": "0.4.2"
+    "@scriptc/threads": "0.4.5"
   },
   "engines": {
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@tsc-ts/darwin-arm64": "0.0.9",
-    "@tsc-ts/darwin-x64": "0.0.9",
-    "@tsc-ts/linux-arm64-gnu": "0.0.9",
-    "@tsc-ts/linux-arm64-musl": "0.0.9",
-    "@tsc-ts/linux-x64-gnu": "0.0.9",
-    "@tsc-ts/linux-x64-musl": "0.0.9",
-    "@tsc-ts/win32-x64-msvc": "0.0.9"
+    "@tsc-ts/darwin-arm64": "0.0.10",
+    "@tsc-ts/darwin-x64": "0.0.10",
+    "@tsc-ts/linux-arm64-gnu": "0.0.10",
+    "@tsc-ts/linux-arm64-musl": "0.0.10",
+    "@tsc-ts/linux-x64-gnu": "0.0.10",
+    "@tsc-ts/linux-x64-musl": "0.0.10",
+    "@tsc-ts/win32-x64-msvc": "0.0.10"
   }
 }

package/src/compiler/ast.ts

@@ -8258,6 +8258,8 @@ export class SourceFile extends Node {
   identifierCount: number;
   nodeCount: number;
   textCount: number;
+  /** The API's binary encoding of this file, when an API server keeps it (`keptEncodingOf`). */
+  apiEncoding: Uint8Array | undefined;
   /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
   imports: Node[];
   /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
@@ -8325,6 +8327,7 @@ export class SourceFile extends Node {
     this.identifierCount = 0;
     this.nodeCount = 0;
     this.textCount = 0;
+    this.apiEncoding = undefined;
     this.imports = [];
     this.moduleAugmentations = emptyNodes;
     this.ambientModuleNames = emptyStrings;

package/src/compiler/checker-calls.ts

@@ -975,7 +975,9 @@ export function reorderCandidates(c: Checker, signatures: Signature[], callChain
       cutoffIndex++;
     } else spliceIndex = index;
     if (callChainFlags !== 0) signature = getOptionalCallSignature(c, signature, callChainFlags);
-    result.splice(spliceIndex, 0, signature);
+    // Most signatures go at the end, where a push is cheaper than an inserting splice.
+    if (spliceIndex === result.length) result.push(signature);
+    else result.splice(spliceIndex, 0, signature);
   }
   return result;
 }

package/src/compiler/checker-grammar.ts

@@ -3143,7 +3143,8 @@ function checkGrammarObjectLiteralExpression(
   node: ObjectLiteralExpression,
   inDestructuring: boolean,
 ): boolean {
-  const seen = new Map<string, DeclarationMeaning>();
+  // An object literal with one property can't repeat a name, so it needs no table of names.
+  const seen = node.properties.nodes.length > 1 ? new Map<string, DeclarationMeaning>() : undefined;
   for (const property of node.properties.nodes) {
     if (property.kind === SyntaxKind.SpreadAssignment) {
       if (inDestructuring) {
@@ -3222,7 +3223,7 @@ function checkGrammarObjectLiteralExpression(
     }
     if (inDestructuring) continue;
     const effectiveName = getEffectivePropertyNameForPropertyNameNode(g.c, name);
-    if (effectiveName === undefined) continue;
+    if (effectiveName === undefined || seen === undefined) continue;
     const existingKind = seen.get(effectiveName);
     if (existingKind === undefined) {
       seen.set(effectiveName, currentKind);

package/src/compiler/checker-inference.ts

@@ -733,8 +733,13 @@ class InferenceState {
             // Keep candidates with the highest depth first.
             index = 0;
             while (index < inference.candidateDepths.length && inference.candidateDepths[index] >= this.depth) index++;
-            inference.candidates.splice(index, 0, candidate);
-            inference.candidateDepths.splice(index, 0, this.depth);
+            if (index === inference.candidates.length) {
+              inference.candidates.push(candidate);
+              inference.candidateDepths.push(this.depth);
+            } else {
+              inference.candidates.splice(index, 0, candidate);
+              inference.candidateDepths.splice(index, 0, this.depth);
+            }
             clearCachedInferences(this.inferences);
           }
         }