tsc-ts 0.0.5 → 0.0.7

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

@@ -1,4 +1,5 @@
 import { FunctionDeclaration, Identifier, type Node, NodeList, SourceFile } from '../ast.js';
+import { ClusteredLinkTable } from '../link-tables.js';
 import { SyntaxKind } from '../syntax-kind.js';
 import { EmitFlags } from './emit-flags.js';
 import { AutoGenerateInfo } from './auto-generate.js';
@@ -54,8 +55,10 @@ export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
 export declare class EmitContext extends NodeFactory {
     readonly autoGenerate: Map<Node, AutoGenerateInfo>;
     readonly textSource: Map<Node, Node>;
-    readonly original: Map<Node, Node>;
-    readonly emitNodes: Map<Node, EmitNode>;
+    /** The node each node was made from, by node id. */
+    readonly original: ClusteredLinkTable<Node>;
+    /** The emit data of nodes, by node id. */
+    readonly emitNodes: ClusteredLinkTable<EmitNode>;
     private lastLookup;
     private lastEmitNode;
     readonly assignedNames: Map<Node, Node>;

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

@@ -1,6 +1,7 @@
 // Side tables that transforms fill in and the printer reads: original nodes, emit flags,
 // comment and source map ranges, synthesized comments, generated names and emit helpers.
 import { ExpressionStatement, FunctionDeclaration, Identifier, NodeList, PrivateIdentifier, StringLiteral, VariableDeclaration, VariableStatement, } from '../ast.js';
+import { ClusteredLinkTable } from '../link-tables.js';
 import { NodeFactory } from './factory.js';
 import { isParseTreeNode, isPrologueDirective } from './utilities.js';
 export { EmitHelper, compareEmitHelpers, noPriority } from './helpers.js';
@@ -90,7 +91,9 @@ export { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
 export class EmitContext extends NodeFactory {
     autoGenerate;
     textSource;
+    /** The node each node was made from, by node id. */
     original;
+    /** The emit data of nodes, by node id. */
     emitNodes;
     lastLookup;
     lastEmitNode;
@@ -104,8 +107,8 @@ export class EmitContext extends NodeFactory {
         super();
         this.autoGenerate = new Map();
         this.textSource = new Map();
-        this.original = new Map();
-        this.emitNodes = new Map();
+        this.original = new ClusteredLinkTable();
+        this.emitNodes = new ClusteredLinkTable();
         this.lastLookup = undefined;
         this.lastEmitNode = undefined;
         this.assignedNames = new Map();
@@ -138,7 +141,7 @@ export class EmitContext extends NodeFactory {
         let emitNode = this.lookup(node);
         if (emitNode === undefined) {
             emitNode = new EmitNode();
-            this.emitNodes.set(node, emitNode);
+            this.emitNodes.set(node.id, emitNode);
             this.lastLookup = node;
             this.lastEmitNode = emitNode;
         }
@@ -148,7 +151,7 @@ export class EmitContext extends NodeFactory {
     lookup(node) {
         if (node === this.lastLookup)
             return this.lastEmitNode;
-        const emitNode = this.emitNodes.get(node);
+        const emitNode = this.emitNodes.get(node.id);
         this.lastLookup = node;
         this.lastEmitNode = emitNode;
         return emitNode;
@@ -158,30 +161,33 @@ export class EmitContext extends NodeFactory {
         this.setOriginalEx(node, original, false);
     }
     setOriginalEx(node, original, allowOverwrite) {
-        const existing = this.original.get(node);
+        const existing = this.original.get(node.id);
         if (existing === undefined) {
-            this.original.set(node, original);
+            this.original.set(node.id, original);
             const emitNode = this.lookup(original);
             if (emitNode !== undefined)
                 this.emitNode(node).copyFrom(emitNode);
         }
         else if (allowOverwrite)
-            this.original.set(node, original);
+            this.original.set(node.id, original);
         else if (existing !== original)
             throw new Error('Original node already set.');
     }
     unsetOriginal(node) {
-        return this.original.delete(node);
+        if (this.original.get(node.id) === undefined)
+            return false;
+        this.original.set(node.id, undefined);
+        return true;
     }
     getOriginal(node) {
-        return this.original.get(node);
+        return this.original.get(node.id);
     }
     /** The node at the end of the chain of original nodes. */
     mostOriginal(node) {
-        let original = this.original.get(node);
+        let original = this.original.get(node.id);
         while (original !== undefined) {
             node = original;
-            original = this.original.get(node);
+            original = this.original.get(node.id);
         }
         return node;
     }
@@ -204,7 +210,7 @@ export class EmitContext extends NodeFactory {
             return name;
         let node = info.node;
         const id = info.id;
-        let original = this.original.get(node);
+        let original = this.original.get(node.id);
         while (original !== undefined) {
             node = original;
             if (node instanceof Identifier || node instanceof PrivateIdentifier) {
@@ -217,7 +223,7 @@ export class EmitContext extends NodeFactory {
                     continue;
                 }
             }
-            original = this.original.get(node);
+            original = this.original.get(node.id);
         }
         return node;
     }

package/dist/api/compiler/printer/factory-base.js

@@ -1,5 +1,5 @@
 // Generated by scripts/generate-visitor.mjs; do not edit.
-import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, SwitchStatement, SyntaxList, SyntheticReferenceExpression, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, } from '../ast.js';
+import { ArrayLiteralExpression, ArrayTypeNode, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocDeprecatedTag, JSDocImplementsTag, JSDocImportTag, JSDocLink, JSDocLinkCode, JSDocLinkPlain, JSDocNameReference, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocOverloadTag, JSDocOverrideTag, JSDocParameterOrPropertyTag, JSDocPrivateTag, JSDocProtectedTag, JSDocPublicTag, JSDocReadonlyTag, JSDocReturnTag, JSDocSatisfiesTag, JSDocSeeTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocThrowsTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypeTag, JSDocTypedefTag, JSDocUnknownTag, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, MissingDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAccessExpression, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, SwitchStatement, SyntaxList, SyntheticReferenceExpression, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, propertyAssignmentPostfixToken, propertyAssignmentType, callQuestionDotToken, propertyAssignmentModifiers, callTypeArguments, newCallExpression, newPropertyAssignment, } from '../ast.js';
 /** `update*` functions: return the node if no child changed, else a copy with the node's flags, range and original. */
 export class NodeFactoryBase {
     updateArrayLiteralExpression(node, elements, multiLine) {
@@ -97,11 +97,11 @@ export class NodeFactoryBase {
     }
     updateCallExpression(node, expression, questionDotToken, typeArguments, args, flags) {
         if (expression !== node.expression ||
-            questionDotToken !== node.questionDotToken ||
-            typeArguments !== node.typeArguments ||
+            questionDotToken !== callQuestionDotToken(node) ||
+            typeArguments !== callTypeArguments(node) ||
             args !== node.arguments ||
             flags !== node.flags) {
-            const updated = new CallExpression(expression, questionDotToken, typeArguments, args, flags);
+            const updated = newCallExpression(expression, questionDotToken, typeArguments, args, flags, false);
             this.finishUpdate(updated, node);
             return updated;
         }
@@ -1154,12 +1154,12 @@ export class NodeFactoryBase {
         return node;
     }
     updatePropertyAssignment(node, modifiers, name, postfixToken, typeNode, initializer) {
-        if (modifiers !== node.modifiers ||
+        if (modifiers !== propertyAssignmentModifiers(node) ||
             name !== node.name ||
-            postfixToken !== node.postfixToken ||
-            typeNode !== node.type ||
+            postfixToken !== propertyAssignmentPostfixToken(node) ||
+            typeNode !== propertyAssignmentType(node) ||
             initializer !== node.initializer) {
-            const updated = new PropertyAssignment(modifiers, name, postfixToken, typeNode, initializer);
+            const updated = newPropertyAssignment(modifiers, name, postfixToken, typeNode, initializer, false);
             this.finishUpdate(updated, node);
             return updated;
         }

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

@@ -1,6 +1,6 @@
 // Creates synthesized nodes for transforms and the printer. Created nodes are flagged
 // `Synthesized` and have no range; updated nodes keep the original's flags, range and emit data.
-import { ArrowFunction, AsExpression, DeleteExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, SyntheticReferenceExpression, TypeAssertion, BinaryExpression, ElementAccessExpression, FunctionExpression, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, QualifiedName, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, Token, TypeOfExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, } from '../ast.js';
+import { ArrowFunction, AsExpression, DeleteExpression, ExpressionWithTypeArguments, NonNullExpression, PartiallyEmittedExpression, SatisfiesExpression, SyntheticReferenceExpression, TypeAssertion, BinaryExpression, ElementAccessExpression, FunctionExpression, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, QualifiedName, Block, CallExpression, ConditionalExpression, ExpressionStatement, Identifier, IfStatement, KeywordExpression, ModifierList, NodeList, NumericLiteral, ParenthesizedExpression, PrivateIdentifier, PropertyAccessExpression, ReturnStatement, SetAccessorDeclaration, SourceFile, StringLiteral, SyntaxList, Token, TypeOfExpression, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, newCallExpression, newPropertyAssignment, } from '../ast.js';
 import { modifierToFlag } from '../ast-utilities.js';
 import { getNameOfDeclaration, getNonAssignedNameOfDeclaration, hasSyntacticModifier } from '../binder-utilities.js';
 import { AutoGenerateInfo, newAutoGenerateId } from './auto-generate.js';
@@ -83,7 +83,7 @@ export class NodeFactory extends NodeFactoryBase {
         return this.created(new PropertyAccessExpression(expression, undefined, name, 0 /* NodeFlags.None */));
     }
     createCallExpression(expression, args) {
-        return this.created(new CallExpression(expression, undefined, undefined, this.createNodeList(args), 0 /* NodeFlags.None */));
+        return this.created(newCallExpression(expression, undefined, undefined, this.createNodeList(args), 0 /* NodeFlags.None */, false));
     }
     createBinaryExpression(left, operator, right) {
         return this.created(new BinaryExpression(undefined, left, undefined, this.createToken(operator), right));
@@ -146,7 +146,7 @@ export class NodeFactory extends NodeFactoryBase {
         return this.created(new ObjectLiteralExpression(this.createNodeList(properties), multiLine));
     }
     createPropertyAssignment(name, initializer) {
-        return this.created(new PropertyAssignment(undefined, name, undefined, undefined, initializer));
+        return this.created(newPropertyAssignment(undefined, name, undefined, undefined, initializer, false));
     }
     createParameter(name) {
         return this.created(new ParameterDeclaration(undefined, undefined, name, undefined, undefined, undefined));
@@ -362,7 +362,7 @@ export class NodeFactory extends NodeFactoryBase {
     createMethodCall(object, method, args) {
         const callee = this.createPropertyAccessExpression(object, this.createIdentifier(method));
         const flags = object instanceof CallExpression ? object.flags & 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */;
-        return this.created(new CallExpression(callee, undefined, undefined, this.createNodeList(args), flags));
+        return this.created(newCallExpression(callee, undefined, undefined, this.createNodeList(args), flags, false));
     }
     /** `Global.method(...args)`, such as `Math.pow(a, b)`. */
     createGlobalMethodCall(global, method, args) {

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

@@ -1,6 +1,6 @@
 // Prints syntax trees as source text the way tsgo's printer does: formatting, comments,
 // source maps, generated names and emit helpers.
-import { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, ArrayTypeNode, getName, getParameters, getTypeParameters, getTypeArguments, getArguments, getElements, getProperties, getStatements, getModifiers, } from '../ast.js';
+import { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BinaryExpression, BindingElement, BindingPattern, Block, BreakStatement, CallExpression, CallSignatureDeclaration, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConditionalExpression, ConditionalTypeNode, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ContinueStatement, DebuggerStatement, Decorator, DeleteExpression, DoStatement, ElementAccessExpression, EmptyStatement, EnumDeclaration, EnumMember, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExpressionWithTypeArguments, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, IfStatement, ImportAttribute, ImportAttributes, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, ImportTypeNode, IndexSignatureDeclaration, IndexedAccessTypeNode, InferTypeNode, InterfaceDeclaration, IntersectionTypeNode, JSDocNonNullableType, JSDocNullableType, JSDocOptionalType, JSDocVariadicType, JsxAttribute, JsxAttributes, JsxClosingElement, JsxElement, JsxExpression, JsxFragment, JsxNamespacedName, JsxOpeningElement, JsxSelfClosingElement, JsxSpreadAttribute, JsxText, LabeledStatement, LiteralTypeNode, MappedTypeNode, MetaProperty, MethodDeclaration, MethodSignatureDeclaration, ModuleBlock, ModuleDeclaration, NamedExports, NamedImports, NamedTupleMember, NamespaceExport, NamespaceExportDeclaration, NamespaceImport, NewExpression, NonNullExpression, NumericLiteral, ObjectLiteralExpression, OptionalTypeNode, ParameterDeclaration, ParenthesizedExpression, ParenthesizedTypeNode, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, RestTypeNode, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateLiteralTypeNode, TemplateLiteralTypeSpan, TemplateSpan, ThrowStatement, TryStatement, TupleTypeNode, TypeAliasDeclaration, TypeAssertion, TypeLiteralNode, TypeOfExpression, TypeOperatorNode, TypeParameterDeclaration, TypePredicateNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, YieldExpression, ArrayTypeNode, getName, getParameters, getTypeParameters, getTypeArguments, getArguments, getElements, getProperties, getStatements, getModifiers, callQuestionDotToken, callTypeArguments, } from '../ast.js';
 import { computeLineOfPosition, computeLineStarts, getLeadingCommentRanges, getShebang, getTrailingCommentRanges, skipTrivia, tokenToString, } from '../scanner.js';
 import { ScriptTarget } from '../options.js';
 import { fileExtensionIs } from '../path.js';
@@ -1728,8 +1728,8 @@ export class Printer extends NameGeneratorHost {
     emitCallExpression(node) {
         const state = this.enterNode(node);
         this.emitCallee(node.expression, node);
-        this.emitOptionalToken(node.questionDotToken);
-        this.emitTypeArguments(node, node.typeArguments);
+        this.emitOptionalToken(callQuestionDotToken(node));
+        this.emitTypeArguments(node, callTypeArguments(node));
         this.emitList(13 /* ListItem.Argument */, node, node.arguments, 2576 /* ListFormat.CallExpressionArguments */);
         this.exitNode(node, state);
         return true;
@@ -2094,7 +2094,7 @@ export class Printer extends NameGeneratorHost {
         if (node instanceof ElementAccessExpression)
             return factory.updateElementAccessExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.argumentExpression, node.flags);
         if (node instanceof CallExpression)
-            return factory.updateCallExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), node.questionDotToken, node.typeArguments, node.arguments, node.flags);
+            return factory.updateCallExpression(node, this.parenthesizeExpressionForNoAsi(node.expression), callQuestionDotToken(node), callTypeArguments(node), node.arguments, node.flags);
         if (node instanceof TaggedTemplateExpression)
             return factory.updateTaggedTemplateExpression(node, this.parenthesizeExpressionForNoAsi(node.tag), node.questionDotToken, node.typeArguments, node.template, node.flags);
         if (node instanceof PostfixUnaryExpression)
@@ -2339,8 +2339,8 @@ export class Printer extends NameGeneratorHost {
                 this.write1('(');
                 this.emitExpression(call.expression, 0 /* OperatorPrecedence.Lowest */);
                 this.write1(')');
-                this.emitOptionalToken(call.questionDotToken);
-                this.emitTypeArguments(call, call.typeArguments);
+                this.emitOptionalToken(callQuestionDotToken(call));
+                this.emitTypeArguments(call, callTypeArguments(call));
                 this.emitList(13 /* ListItem.Argument */, call, call.arguments, 2576 /* ListFormat.CallExpressionArguments */);
                 this.exitNode(call, callState);
             }

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

@@ -24,6 +24,11 @@ import { type SourceFileMetadata } from './program-utilities.js';
 export declare class ProgramCheckerHost extends CheckerHost {
     readonly program: Program;
     private specifierHost;
+    /**
+     * `getSourceFileForResolvedModule` by resolved file name (null when there is none): every import of
+     * a module asks again, and the program finds a file by its path, which it computes from the name.
+     */
+    private readonly resolvedSourceFiles;
     constructor(program: Program);
     getCompilerOptions(): CompilerOptions;
     getSourceFiles(): readonly SourceFile[];

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

@@ -9,6 +9,11 @@ import { computeLineOfPosition } from './scanner.js';
 export class ProgramCheckerHost extends CheckerHost {
     program;
     specifierHost = undefined;
+    /**
+     * `getSourceFileForResolvedModule` by resolved file name (null when there is none): every import of
+     * a module asks again, and the program finds a file by its path, which it computes from the name.
+     */
+    resolvedSourceFiles = new Map();
     constructor(program) {
         super();
         this.program = program;
@@ -26,7 +31,12 @@ export class ProgramCheckerHost extends CheckerHost {
         return this.program.getResolvedModule(file, moduleName, mode);
     }
     getSourceFileForResolvedModule(fileName) {
-        return this.program.getSourceFileForResolvedModule(fileName);
+        const known = this.resolvedSourceFiles.get(fileName);
+        if (known !== undefined)
+            return known ?? undefined;
+        const file = this.program.getSourceFileForResolvedModule(fileName);
+        this.resolvedSourceFiles.set(fileName, file ?? null);
+        return file;
     }
     getModeForUsageLocation(file, location) {
         return this.program.getModeForUsageLocation(file, location);
@@ -357,6 +367,9 @@ class Directives {
     byLine = new Map();
     constructor(file) {
         this.file = file;
+        // Most files have no directives, and need no line starts.
+        if (file.commentDirectives.length === 0)
+            return;
         const lineStarts = file.diagnosticFile().getLineStarts();
         for (const directive of file.commentDirectives) {
             const line = computeLineOfPosition(lineStarts, directive.pos);

package/dist/api/compiler/program.js

@@ -62,13 +62,21 @@ export class Program {
                 this.programDiagnosticsList.push(diagnostic);
             for (const path of previous.emitBlockingPaths)
                 this.emitBlockingPaths.add(path);
-            this.symlinks = previous.symlinks;
+            // The files and include reasons it takes from a program shared with checker threads are immutable, and
+            // so is that program's symlink cache: this one computes its own then (`getSymlinkCache`).
+            this.shared = previous.shared;
+            if (!previous.shared)
+                this.symlinks = previous.symlinks;
+            // The same files are emitted, so the common source directory is the same. Its diagnostics are those
+            // `previous` was created with (`IncludeProcessor.copy`).
+            this.commonSourceDirectoryValue = previous.commonSourceDirectoryValue;
         }
         else {
             this.processed = (loader ?? new FileLoader(host, commandLine)).load();
             this.includeProcessor = this.processed.includeProcessor;
             this.verifyCompilerOptions();
         }
+        this.includeProcessor.noteProgramCreated();
     }
     /**
      * The program with the file at `path` read again from `host` and everything else taken from this program,

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

@@ -1,12 +1,12 @@
 import { ModifierFlags, type Node } from './ast.js';
 import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
-import { type Symbol } from './symbol.js';
 import { type Checker } from './checker.js';
 import { type IndexInfo, type MappedType, type Signature, SignatureKind, Ternary, type Type, type UnionType, VarianceFlags } from './checker-types.js';
 import { typeListKey } from './checker-type-factory.js';
 import { findApplicableIndexInfo } from './checker-members.js';
 import { getMergedSymbol } from './checker-symbols.js';
 import { getPropertyNameFromType } from './checker-utilities.js';
+import { type Symbol } from './symbol.js';
 export declare const enum RelationComparisonResult {
     None = 0,
     Succeeded = 1,

package/dist/api/compiler/relations.js

@@ -5,13 +5,12 @@ import { getExpression, getName, getNodeId, getText, } from './ast.js';
 import { getSymbolNameForPrivateIdentifier } from './binder.js';
 import { getCombinedModifierFlags } from './binder-utilities.js';
 import { Diagnostic, messageElidedInCompatibilityPyramid } from './diagnostics.js';
-import { getSymbolId } from './symbol.js';
 import { isContextSensitive } from './checker-functions.js';
 import { createDiagnosticForNode } from './checker.js';
 import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, } from './checker-types.js';
 import { createInferenceContext, inferTypes } from './checker-inference.js';
 import { unionContainsSortedTypes, unionContainsType, createArrayTypeEx, compareTypes, containsMissingType, createTypeReference, everyType, filterType, getBaseTypeOfLiteralType, getBaseTypeOfEnumLikeType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getTargetType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, isArrayOrTupleType, isArrayType, isEmptyAnonymousObjectType, isEmptyObjectType, isErrorType, isFreshLiteralType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, isUnitType, someType, tupleTargetOf, typesOf, countTypes, getStartElementCount, getEndElementCount, createNormalizedTypeReference, typeListKey, getRegularTypeOfLiteralType, } from './checker-type-factory.js';
-import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, } from './checker-members.js';
+import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, positionsOfNamesFoundInSource, firstUnmatchedProperty, } from './checker-members.js';
 import { getParentOfSymbol, getMergedSymbol, getMembersOfSymbol, getSpellingSuggestionForName, } from './checker-symbols.js';
 import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
 import { getConstraintFromTypeParameter, getDeclaredTypeOfSymbol, getDefaultOrUnknownFromTypeParameter, fillMissingTypeArguments, getMinTypeArgumentCount, hasBaseType, hasNonCircularBaseConstraint, computeEnumMemberValues, getBaseTypes, getExtendsHeritageClauseElement, } from './checker-declared-types.js';
@@ -23,6 +22,7 @@ import { getConstraintOfDistributiveConditionalType, getDefaultConstraintOfCondi
 import { getCanonicalSignature, getErasedSignature, getMinArgumentCount, getNonArrayRestType, getNonCircularReturnTypeOfSignature, getParameterCount, getParameterNameAtPosition, getRestOrAnyTypeAtPosition, getReturnTypeOfSignature, getSingleCallSignature, getThisTypeOfSignature, getTypeAtPosition, getTypePredicateOfSignature, hasEffectiveRestParameter, instantiateSignatureInContextOf, isTopSignature, tryGetTypeAtPosition, } from './checker-signatures.js';
 import { getNonNullableType, getTypeFacts } from './checker-flow.js';
 import { getPropertyNameFromType, isLateBoundName, isNumericLiteralName, maybeTypeOfKind, } from './checker-utilities.js';
+import { declarationCount, getDeclarations, getSymbolId } from './symbol.js';
 /**
  * Cached results of one relation by numeric relation key (see getRelationKey): an open-addressing
  * table of keys and one-byte results. Keys are never 0 (packed keys are positive, interned ones
@@ -430,8 +430,8 @@ function isEnumTypeRelatedTo(c, source, target, reporter) {
             c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
             return false;
         }
-        const sourceDecl = sourceProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
-        const targetDecl = targetProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const sourceDecl = getDeclarations(sourceProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const targetDecl = getDeclarations(targetProperty).find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
         if (sourceDecl === undefined || targetDecl === undefined)
             continue;
         computeEnumMemberValues(c, sourceDecl.parent);
@@ -933,8 +933,8 @@ export class Relater extends TypeComparer {
                             ]);
                         return true;
                     }
-                    const objectLiteralDeclaration = source.symbol !== undefined && source.symbol.declarations.length !== 0
-                        ? source.symbol.declarations[0]
+                    const objectLiteralDeclaration = source.symbol !== undefined && declarationCount(source.symbol) !== 0
+                        ? source.symbol.declaration
                         : undefined;
                     const valueDeclaration = prop.valueDeclaration;
                     let suggestion = undefined;
@@ -2058,7 +2058,12 @@ export class Relater extends TypeComparer {
             !isObjectLiteralType(source) &&
             !isEmptyArrayLiteralType(c, source) &&
             !isTupleType(source);
-        const unmatchedProperty = getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
+        const targetProperties = getPropertiesOfType(c, target);
+        // Where it is known which target names the source has, nothing else is looked up by name.
+        const found = positionsOfNamesFoundInSource(c, source, target, targetProperties);
+        const unmatchedProperty = found !== undefined
+            ? firstUnmatchedProperty(c, targetProperties, found, requireOptionalProperties)
+            : getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
         if (unmatchedProperty !== undefined) {
             if (reportErrors && shouldReportUnmatchedPropertyError(c, source, target))
                 this.reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
@@ -2079,7 +2084,7 @@ export class Relater extends TypeComparer {
             }
         }
         const numericNamesOnly = isTupleType(source) && isTupleType(target);
-        for (const targetProp of getPropertiesOfType(c, target)) {
+        for (const targetProp of found !== undefined ? found.map((i) => targetProperties[i]) : targetProperties) {
             if (excludedProperties !== undefined && excludedProperties.has(targetProp.name))
                 continue;
             const name = targetProp.name;
@@ -2202,8 +2207,8 @@ export class Relater extends TypeComparer {
                 names[0],
                 names[1],
             ]);
-            if (unmatchedProperty.declarations.length !== 0)
-                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declarations[0], 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
+            if (declarationCount(unmatchedProperty) !== 0)
+                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declaration, 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
         }
         else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
             const names = getTypeNamesForErrorDisplay(c, source, target);
@@ -2547,12 +2552,12 @@ export class Relater extends TypeComparer {
         this.reportRelationError(headMessage, source, target);
         if ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
             source.symbol !== undefined &&
-            source.symbol.declarations.length !== 0 &&
+            declarationCount(source.symbol) !== 0 &&
             getConstraintOfType(c, source) === undefined) {
             const syntheticParam = cloneTypeParameter(c, source);
             syntheticParam.constraint = instantiateType(c, target, new SimpleTypeMapper(source, syntheticParam));
             if (hasNonCircularBaseConstraint(c, syntheticParam)) {
-                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declarations[0], 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
+                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declaration, 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
             }
         }
     }
@@ -3476,7 +3481,7 @@ import { getTypeAliasInstantiation } from './checker-type-nodes.js';
 export function getTypeParameterModifiers(tp) {
     let flags = 0;
     if (tp.symbol !== undefined)
-        for (const d of tp.symbol.declarations)
+        for (const d of getDeclarations(tp.symbol))
             flags |= getCombinedModifierFlags(d);
     return flags & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */ | 4096 /* ModifierFlags.Const */);
 }

package/dist/api/compiler/reparser.js

@@ -6,7 +6,7 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, } from './ast.js';
+import { ArrayTypeNode, ArrowFunction, AsExpression, BinaryExpression, CallSignatureDeclaration, ClassDeclaration, ClassExpression, ConstructSignatureDeclaration, ConstructorDeclaration, ConstructorTypeNode, ElementAccessExpression, ExportAssignment, ExpressionStatement, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, FunctionTypeNode, GetAccessorDeclaration, HeritageClause, Identifier, ImportDeclaration, IndexSignatureDeclaration, JSDoc, JSDocAugmentsTag, JSDocCallbackTag, JSDocImplementsTag, JSDocImportTag, JSDocOverloadTag, JSDocParameterOrPropertyTag, JSDocSatisfiesTag, JSDocSignature, JSDocTemplateTag, JSDocThisTag, JSDocTypeExpression, JSDocTypeLiteral, JSDocTypedefTag, JSDocVariadicType, JSDocOptionalType, KeywordTypeNode, MethodDeclaration, MethodSignatureDeclaration, ModifierList, ModuleBlock, ModuleDeclaration, NodeList, NodeVisitor, NumericLiteral, ParameterDeclaration, ParenthesizedExpression, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, PropertySignatureDeclaration, QualifiedName, ReturnStatement, SatisfiesExpression, SetAccessorDeclaration, ShorthandPropertyAssignment, StringLiteral, Token, TypeAliasDeclaration, TypeLiteralNode, TypeParameterDeclaration, VariableDeclaration, VariableStatement, getComment, getModifiers, getName, getParameters, getText, getType, getTypeExpression, getTypeParameters, FullPropertyAssignment, } from './ast.js';
 import { isAssignmentOperator, isFunctionLike, isInJSFile, isLeftHandSideExpression, isStringLiteralLike, } from './ast-utilities.js';
 import { isIdentifierPart, isIdentifierStart } from './character-codes.js';
 /** Sets the parent of every node in a subtree. */
@@ -652,10 +652,14 @@ export class Reparser {
             return false;
         const className = tag.className;
         const heritageClauses = getHeritageClauses(parent);
+        // Parsed lists may share their nodes array (empty ones do), so a longer list is a new list.
         if (heritageClauses !== undefined) {
             for (const clause of heritageClauses.nodes)
                 if (clause instanceof HeritageClause && clause.token === 118 /* SyntaxKind.ImplementsKeyword */) {
-                    clause.types.nodes.push(this.addDeepCloneReparse(className));
+                    const types = clause.types;
+                    const nodes = types.nodes.slice();
+                    nodes.push(this.addDeepCloneReparse(className));
+                    clause.types = this.p.newNodeList(types.pos, types.end, nodes);
                     this.finishMutatedNode(clause);
                     return true;
                 }
@@ -665,8 +669,11 @@ export class Reparser {
         this.finishReparsedNode(heritageClause, className);
         if (heritageClauses === undefined)
             setHeritageClauses(parent, this.p.newNodeList(className.pos, className.end, [heritageClause]));
-        else
-            heritageClauses.nodes.push(heritageClause);
+        else {
+            const nodes = heritageClauses.nodes.slice();
+            nodes.push(heritageClause);
+            setHeritageClauses(parent, this.p.newNodeList(heritageClauses.pos, heritageClauses.end, nodes));
+        }
         this.finishMutatedNode(parent);
         return true;
     }
@@ -1178,7 +1185,8 @@ function setType(node, value) {
         node.type = value;
         return true;
     }
-    if (node instanceof PropertyAssignment) {
+    // Property assignments in JavaScript files, which are the ones reparsed, are full ones.
+    if (node instanceof FullPropertyAssignment) {
         node.type = value;
         return true;
     }

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

@@ -1,7 +1,7 @@
 import { type Node, type SourceFile } from './ast.js';
 import { type Checker } from './checker.js';
-import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 import { SymbolAccessibilityResult } from './transformers/declarations-resolver.js';
+import { type Symbol, SymbolFlags, type SymbolTable } from './symbol.js';
 export declare function isTypeSymbolAccessible(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined): boolean;
 export declare function isValueSymbolAccessible(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined): boolean;
 export declare function isSymbolAccessibleByFlags(c: Checker, symbol: Symbol, enclosingDeclaration: Node | undefined, flags: SymbolFlags): boolean;