tsc-ts 0.0.6 → 0.0.8

package/README.md

@@ -31,7 +31,7 @@ npx tsc-ts -p tsconfig.json
 npx tsc-ts --noEmit src/index.ts
 ```
 
-`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`.
+`tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`. On Windows, `--api --pipe \\.\pipe\<name>` serves it over a named pipe it creates, as `tsc --api --pipe` does, for clients that connect to the pipe (such as scriptc under Node.js); only the native executable supports `--pipe`.
 
 `--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1`, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 

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

@@ -1183,16 +1183,30 @@ export declare class ElementAccessExpression extends Node {
 }
 export declare class CallExpression extends Node {
     expression: Expression;
+    arguments: NodeList;
+    constructor(expression: Expression, args: NodeList, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CallExpression;
+}
+/**
+ * A call with `?.` or type arguments, or in a JavaScript file, where the binder can declare a symbol
+ * for it (`Object.defineProperty`). Other calls are a plain `CallExpression`, without these fields.
+ */
+export declare class FullCallExpression extends CallExpression {
     questionDotToken: Token | undefined;
     typeArguments: NodeList | undefined;
-    arguments: NodeList;
     symbol: Symbol | undefined;
     constructor(expression: Expression, questionDotToken: Token | undefined, typeArguments: NodeList | undefined, args: NodeList, flags: NodeFlags);
     forEachChild(v: NodeVisitor): boolean;
     setParentOfChildren(): void;
-    deepClone(): Node;
     copy(): CallExpression;
 }
+/** A `FullCallExpression` when one of its fields is set or `inJavaScript`, else a `CallExpression`. */
+export declare function newCallExpression(expression: Expression, questionDotToken: Token | undefined, typeArguments: NodeList | undefined, args: NodeList, flags: NodeFlags, inJavaScript: boolean): CallExpression;
+export declare function callQuestionDotToken(node: CallExpression): Token | undefined;
+export declare function callTypeArguments(node: CallExpression): NodeList | undefined;
 export declare class NewExpression extends Node {
     expression: Expression;
     typeArguments: NodeList | undefined;
@@ -1295,18 +1309,34 @@ export declare class SpreadAssignment extends Node {
     copy(): SpreadAssignment;
 }
 export declare class PropertyAssignment extends Node {
-    modifiers: ModifierList | undefined;
     name: PropertyName;
-    postfixToken: Token | undefined;
-    type: TypeNode | undefined;
     initializer: Expression;
     symbol: Symbol | undefined;
-    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression);
+    constructor(name: PropertyName, initializer: Expression);
     forEachChild(v: NodeVisitor): boolean;
     setParentOfChildren(): void;
     deepClone(): Node;
     copy(): PropertyAssignment;
 }
+/**
+ * A property assignment with modifiers, a `?` or `!`, or a type annotation (which the grammar checker
+ * reports), or in a JavaScript file, where JSDoc can give it a type or modifiers. Other property
+ * assignments are a plain `PropertyAssignment`, without these fields.
+ */
+export declare class FullPropertyAssignment extends PropertyAssignment {
+    modifiers: ModifierList | undefined;
+    postfixToken: Token | undefined;
+    type: TypeNode | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    copy(): PropertyAssignment;
+}
+/** A `FullPropertyAssignment` when one of its fields is set or `inJavaScript`, else a `PropertyAssignment`. */
+export declare function newPropertyAssignment(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression, inJavaScript: boolean): PropertyAssignment;
+export declare function propertyAssignmentModifiers(node: PropertyAssignment): ModifierList | undefined;
+export declare function propertyAssignmentPostfixToken(node: PropertyAssignment): Token | undefined;
+export declare function propertyAssignmentType(node: PropertyAssignment): TypeNode | undefined;
 export declare class ShorthandPropertyAssignment extends Node {
     modifiers: ModifierList | undefined;
     name: PropertyName;
@@ -2220,6 +2250,15 @@ export declare class JSDocParameterOrPropertyTag extends Node {
     deepClone(): Node;
     copy(): JSDocParameterOrPropertyTag;
 }
+export declare const emptyDiagnostics: readonly Diagnostic[];
+export declare const emptyNodes: readonly Node[];
+export declare const emptyStrings: readonly string[];
+export declare const emptyCommentDirectives: readonly CommentDirective[];
+export declare const emptyPragmas: readonly Pragma[];
+export declare const emptyFileReferences: readonly FileReference[];
+export declare const emptyPatternAmbientModules: readonly PatternAmbientModule[];
+/** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
+export declare function appendToList<T>(list: readonly T[], item: T): readonly T[];
 export declare class SourceFile extends Node {
     readonly fileName: string;
     readonly path: string;
@@ -2227,10 +2266,10 @@ export declare class SourceFile extends Node {
     readonly externalModuleIndicatorOptions: ExternalModuleIndicatorOptions;
     statements: NodeList;
     endOfFileToken: Token;
-    diagnostics: Diagnostic[];
+    diagnostics: readonly Diagnostic[];
     /** Diagnostics for TypeScript-only syntax in JavaScript files. */
-    jsDiagnostics: Diagnostic[];
-    jsDocDiagnostics: Diagnostic[];
+    jsDiagnostics: readonly Diagnostic[];
+    jsDocDiagnostics: readonly Diagnostic[];
     languageVariant: LanguageVariant;
     scriptKind: ScriptKind;
     isDeclarationFile: boolean;
@@ -2245,20 +2284,20 @@ export declare class SourceFile extends Node {
     /** 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. */
-    moduleAugmentations: Node[];
-    ambientModuleNames: string[];
+    moduleAugmentations: readonly Node[];
+    ambientModuleNames: readonly string[];
     commentDirectives: readonly CommentDirective[];
-    pragmas: Pragma[];
-    referencedFiles: FileReference[];
-    typeReferenceDirectives: FileReference[];
-    libReferenceDirectives: FileReference[];
+    pragmas: readonly Pragma[];
+    referencedFiles: readonly FileReference[];
+    typeReferenceDirectives: readonly FileReference[];
+    libReferenceDirectives: readonly FileReference[];
     checkJsDirective: CheckJsDirective | undefined;
     /** The first CommonJS `module.exports`/`exports.x` use in a JavaScript file. */
     commonJSModuleIndicator: Node | undefined;
     /** What makes this file a module: an import or export statement, `import.meta`, a JSX tag, or the file itself when forced. */
     externalModuleIndicator: Node | undefined;
     /** Nodes cloned by JSDoc reparsing, sorted by position. */
-    reparsedClones: Node[];
+    reparsedClones: readonly Node[];
     /** Whether JSDoc of TypeScript files is parsed on first use. */
     hasLazyJSDoc: boolean;
     /**
@@ -2271,12 +2310,12 @@ export declare class SourceFile extends Node {
     locals: SymbolTable | undefined;
     nextContainer: Node | undefined;
     isBound: boolean;
-    bindDiagnostics: Diagnostic[];
+    bindDiagnostics: readonly Diagnostic[];
     /** The flow at the end of the file. */
     endFlowNode: FlowNode | undefined;
     symbolCount: number;
     /** Ambient modules with a `*` in their name, like `declare module "*.css"`. */
-    patternAmbientModules: PatternAmbientModule[];
+    patternAmbientModules: readonly PatternAmbientModule[];
     /** UMD exports from `export as namespace N`. */
     globalExports: SymbolTable | undefined;
     constructor(fileName: string, path: string, text: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, statements: NodeList, endOfFileToken: Token);

package/dist/api/compiler/ast.js

@@ -3230,18 +3230,46 @@ export class ElementAccessExpression extends Node {
 }
 export class CallExpression extends Node {
     expression;
+    arguments;
+    constructor(expression, args, flags) {
+        super(214 /* SyntaxKind.CallExpression */);
+        this.expression = expression;
+        this.arguments = args;
+        this.flags |= flags & 32 /* NodeFlags.OptionalChain */;
+    }
+    forEachChild(v) {
+        if (v.visitNode(this.expression))
+            return true;
+        return v.visitList(this.arguments);
+    }
+    setParentOfChildren() {
+        this.expression.parent = this;
+        setParents(this.arguments.nodes, this);
+    }
+    deepClone() {
+        return this.copy();
+    }
+    copy() {
+        const node = new CallExpression(this.expression.deepClone(), cloneList(this.arguments), this.flags);
+        node.flags = this.flags;
+        node.pos = this.pos;
+        node.end = this.end;
+        return node;
+    }
+}
+/**
+ * A call with `?.` or type arguments, or in a JavaScript file, where the binder can declare a symbol
+ * for it (`Object.defineProperty`). Other calls are a plain `CallExpression`, without these fields.
+ */
+export class FullCallExpression extends CallExpression {
     questionDotToken;
     typeArguments;
-    arguments;
     // Set by the binder.
     symbol;
     constructor(expression, questionDotToken, typeArguments, args, flags) {
-        super(214 /* SyntaxKind.CallExpression */);
-        this.expression = expression;
+        super(expression, args, flags);
         this.questionDotToken = questionDotToken;
         this.typeArguments = typeArguments;
-        this.arguments = args;
-        this.flags |= flags & 32 /* NodeFlags.OptionalChain */;
         this.symbol = undefined;
     }
     forEachChild(v) {
@@ -3261,17 +3289,26 @@ export class CallExpression extends Node {
             setParents(this.typeArguments.nodes, this);
         setParents(this.arguments.nodes, this);
     }
-    deepClone() {
-        return this.copy();
-    }
     copy() {
-        const node = new CallExpression(this.expression.deepClone(), this.questionDotToken === undefined ? undefined : this.questionDotToken.copy(), this.typeArguments === undefined ? undefined : cloneList(this.typeArguments), cloneList(this.arguments), this.flags);
+        const node = new FullCallExpression(this.expression.deepClone(), this.questionDotToken === undefined ? undefined : this.questionDotToken.copy(), this.typeArguments === undefined ? undefined : cloneList(this.typeArguments), cloneList(this.arguments), this.flags);
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
         return node;
     }
 }
+/** A `FullCallExpression` when one of its fields is set or `inJavaScript`, else a `CallExpression`. */
+export function newCallExpression(expression, questionDotToken, typeArguments, args, flags, inJavaScript) {
+    if (inJavaScript || questionDotToken !== undefined || typeArguments !== undefined)
+        return new FullCallExpression(expression, questionDotToken, typeArguments, args, flags);
+    return new CallExpression(expression, args, flags);
+}
+export function callQuestionDotToken(node) {
+    return node instanceof FullCallExpression ? node.questionDotToken : undefined;
+}
+export function callTypeArguments(node) {
+    return node instanceof FullCallExpression ? node.typeArguments : undefined;
+}
 export class NewExpression extends Node {
     expression;
     typeArguments;
@@ -3582,22 +3619,51 @@ export class SpreadAssignment extends Node {
     }
 }
 export class PropertyAssignment extends Node {
-    modifiers;
     name;
-    postfixToken;
-    type;
     initializer;
     // Set by the binder.
     symbol;
-    constructor(modifiers, name, postfixToken, type, initializer) {
+    constructor(name, initializer) {
         super(303 /* SyntaxKind.PropertyAssignment */);
-        this.modifiers = modifiers;
         this.name = name;
-        this.postfixToken = postfixToken;
-        this.type = type;
         this.initializer = initializer;
         this.symbol = undefined;
     }
+    forEachChild(v) {
+        if (v.visitNode(this.name))
+            return true;
+        return v.visitNode(this.initializer);
+    }
+    setParentOfChildren() {
+        this.name.parent = this;
+        this.initializer.parent = this;
+    }
+    deepClone() {
+        return this.copy();
+    }
+    copy() {
+        const node = new PropertyAssignment(this.name.deepClone(), this.initializer.deepClone());
+        node.flags = this.flags;
+        node.pos = this.pos;
+        node.end = this.end;
+        return node;
+    }
+}
+/**
+ * A property assignment with modifiers, a `?` or `!`, or a type annotation (which the grammar checker
+ * reports), or in a JavaScript file, where JSDoc can give it a type or modifiers. Other property
+ * assignments are a plain `PropertyAssignment`, without these fields.
+ */
+export class FullPropertyAssignment extends PropertyAssignment {
+    modifiers;
+    postfixToken;
+    type;
+    constructor(modifiers, name, postfixToken, type, initializer) {
+        super(name, initializer);
+        this.modifiers = modifiers;
+        this.postfixToken = postfixToken;
+        this.type = type;
+    }
     forEachChild(v) {
         if (this.modifiers !== undefined && v.visitModifiers(this.modifiers))
             return true;
@@ -3619,17 +3685,29 @@ export class PropertyAssignment extends Node {
             this.type.parent = this;
         this.initializer.parent = this;
     }
-    deepClone() {
-        return this.copy();
-    }
     copy() {
-        const node = new PropertyAssignment(this.modifiers === undefined ? undefined : cloneModifiers(this.modifiers), this.name.deepClone(), this.postfixToken === undefined ? undefined : this.postfixToken.copy(), this.type === undefined ? undefined : this.type.deepClone(), this.initializer.deepClone());
+        const node = new FullPropertyAssignment(this.modifiers === undefined ? undefined : cloneModifiers(this.modifiers), this.name.deepClone(), this.postfixToken === undefined ? undefined : this.postfixToken.copy(), this.type === undefined ? undefined : this.type.deepClone(), this.initializer.deepClone());
         node.flags = this.flags;
         node.pos = this.pos;
         node.end = this.end;
         return node;
     }
 }
+/** A `FullPropertyAssignment` when one of its fields is set or `inJavaScript`, else a `PropertyAssignment`. */
+export function newPropertyAssignment(modifiers, name, postfixToken, type, initializer, inJavaScript) {
+    if (inJavaScript || modifiers !== undefined || postfixToken !== undefined || type !== undefined)
+        return new FullPropertyAssignment(modifiers, name, postfixToken, type, initializer);
+    return new PropertyAssignment(name, initializer);
+}
+export function propertyAssignmentModifiers(node) {
+    return node instanceof FullPropertyAssignment ? node.modifiers : undefined;
+}
+export function propertyAssignmentPostfixToken(node) {
+    return node instanceof FullPropertyAssignment ? node.postfixToken : undefined;
+}
+export function propertyAssignmentType(node) {
+    return node instanceof FullPropertyAssignment ? node.type : undefined;
+}
 export class ShorthandPropertyAssignment extends Node {
     modifiers;
     name;
@@ -6523,6 +6601,23 @@ export class JSDocParameterOrPropertyTag extends Node {
         return node;
     }
 }
+// The lists of a source file that has none. Most files have no diagnostics, references, pragmas
+// or ambient modules, so they share these instead of holding empty arrays of their own. A list
+// that grows replaces an empty one rather than pushing to it (appendToList).
+export const emptyDiagnostics = [];
+export const emptyNodes = [];
+export const emptyStrings = [];
+export const emptyCommentDirectives = [];
+export const emptyPragmas = [];
+export const emptyFileReferences = [];
+export const emptyPatternAmbientModules = [];
+/** `list` with `item` appended: a new array when `list` is empty (it may be shared), else `list` itself. */
+export function appendToList(list, item) {
+    if (list.length === 0)
+        return [item];
+    list.push(item);
+    return list;
+}
 export class SourceFile extends Node {
     fileName;
     path;
@@ -6592,9 +6687,9 @@ export class SourceFile extends Node {
         this.externalModuleIndicatorOptions = externalModuleIndicatorOptions;
         this.statements = statements;
         this.endOfFileToken = endOfFileToken;
-        this.diagnostics = [];
-        this.jsDiagnostics = [];
-        this.jsDocDiagnostics = [];
+        this.diagnostics = emptyDiagnostics;
+        this.jsDiagnostics = emptyDiagnostics;
+        this.jsDocDiagnostics = emptyDiagnostics;
         this.languageVariant = 0;
         this.scriptKind = 0 /* ScriptKind.Unknown */;
         this.isDeclarationFile = false;
@@ -6605,17 +6700,17 @@ export class SourceFile extends Node {
         this.nodeCount = 0;
         this.textCount = 0;
         this.imports = [];
-        this.moduleAugmentations = [];
-        this.ambientModuleNames = [];
-        this.commentDirectives = [];
-        this.pragmas = [];
-        this.referencedFiles = [];
-        this.typeReferenceDirectives = [];
-        this.libReferenceDirectives = [];
+        this.moduleAugmentations = emptyNodes;
+        this.ambientModuleNames = emptyStrings;
+        this.commentDirectives = emptyCommentDirectives;
+        this.pragmas = emptyPragmas;
+        this.referencedFiles = emptyFileReferences;
+        this.typeReferenceDirectives = emptyFileReferences;
+        this.libReferenceDirectives = emptyFileReferences;
         this.checkJsDirective = undefined;
         this.commonJSModuleIndicator = undefined;
         this.externalModuleIndicator = undefined;
-        this.reparsedClones = [];
+        this.reparsedClones = emptyNodes;
         this.hasLazyJSDoc = false;
         this.jsDocs = undefined;
         this.diagnosticFileCache = undefined;
@@ -6623,10 +6718,10 @@ export class SourceFile extends Node {
         this.locals = undefined;
         this.nextContainer = undefined;
         this.isBound = false;
-        this.bindDiagnostics = [];
+        this.bindDiagnostics = emptyDiagnostics;
         this.endFlowNode = undefined;
         this.symbolCount = 0;
-        this.patternAmbientModules = [];
+        this.patternAmbientModules = emptyPatternAmbientModules;
         this.globalExports = undefined;
     }
     forEachChild(v) {
@@ -7090,7 +7185,7 @@ export function getModifiers(node) {
             }
             break;
         case 303 /* SyntaxKind.PropertyAssignment */:
-            if (node instanceof PropertyAssignment) {
+            if (node instanceof FullPropertyAssignment) {
                 const holder = node;
                 return holder.modifiers;
             }
@@ -7461,7 +7556,7 @@ export function getType(node) {
             }
             break;
         case 303 /* SyntaxKind.PropertyAssignment */:
-            if (node instanceof PropertyAssignment) {
+            if (node instanceof FullPropertyAssignment) {
                 const holder = node;
                 return holder.type;
             }
@@ -7946,7 +8041,7 @@ export function getPostfixToken(node) {
             }
             break;
         case 303 /* SyntaxKind.PropertyAssignment */:
-            if (node instanceof PropertyAssignment) {
+            if (node instanceof FullPropertyAssignment) {
                 const holder = node;
                 return holder.postfixToken;
             }
@@ -7963,7 +8058,7 @@ export function getPostfixToken(node) {
 export function getTypeArguments(node) {
     switch (node.kind) {
         case 214 /* SyntaxKind.CallExpression */:
-            if (node instanceof CallExpression) {
+            if (node instanceof FullCallExpression) {
                 const holder = node;
                 return holder.typeArguments;
             }
@@ -9195,7 +9290,7 @@ export function getSymbol(node) {
             }
             break;
         case 214 /* SyntaxKind.CallExpression */:
-            if (node instanceof CallExpression) {
+            if (node instanceof FullCallExpression) {
                 const holder = node;
                 return holder.symbol;
             }
@@ -9526,7 +9621,7 @@ export function setSymbol(node, value) {
             }
             break;
         case 214 /* SyntaxKind.CallExpression */:
-            if (node instanceof CallExpression) {
+            if (node instanceof FullCallExpression) {
                 const target = node;
                 target.symbol = value;
             }

package/dist/api/compiler/binder-utilities.js

@@ -3,7 +3,7 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { BinaryExpression, CallExpression, ElementAccessExpression, ExpressionStatement, Identifier, JSDoc, JSDocSatisfiesTag, JsxNamespacedName, MetaProperty, ModuleDeclaration, NodeVisitor, PrefixUnaryExpression, ParenthesizedExpression, PropertyAccessExpression, TaggedTemplateExpression, TypeReferenceNode, VariableDeclaration, VariableStatement, getArguments, getAsteriskToken, getBody, getElements, getExpression, getInitializer, getMembers, getModifiers, getName, getProperties, getPropertyName, getStatements, getTagName, getText, getType, } from './ast.js';
+import { BinaryExpression, CallExpression, ElementAccessExpression, ExpressionStatement, Identifier, JSDoc, JSDocSatisfiesTag, JsxNamespacedName, MetaProperty, ModuleDeclaration, NodeVisitor, PrefixUnaryExpression, ParenthesizedExpression, PropertyAccessExpression, TaggedTemplateExpression, TypeReferenceNode, VariableDeclaration, VariableStatement, getArguments, getAsteriskToken, getBody, getElements, getExpression, getInitializer, getMembers, getModifiers, getName, getProperties, getPropertyName, getStatements, getTagName, getText, getType, callQuestionDotToken, } from './ast.js';
 import { getJSDoc } from './parser.js';
 import { isAssignmentOperator, isLeftHandSideExpression, isStringLiteralLike, nodeIsMissing } from './ast-utilities.js';
 import { Scanner, computeLineOfPosition, skipTrivia } from './scanner.js';
@@ -266,7 +266,7 @@ function getQuestionDotToken(node) {
     if (node instanceof ElementAccessExpression)
         return node.questionDotToken;
     if (node instanceof CallExpression)
-        return node.questionDotToken;
+        return callQuestionDotToken(node);
     if (node instanceof TaggedTemplateExpression)
         return node.questionDotToken;
     return undefined;

package/dist/api/compiler/binder.js

@@ -3,7 +3,7 @@
 //
 // Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
 // statically, but reads fields of a narrowed value dynamically.
-import { BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, ReferenceIdentifier, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, } from './ast.js';
+import { appendToList, BinaryExpression, CallExpression, ConditionalTypeNode, ElementAccessExpression, ExportAssignment, FunctionExpression, KeywordExpression, ModuleDeclaration, NodeVisitor, PatternAmbientModule, PrefixUnaryExpression, PropertyAccessExpression, ReferenceIdentifier, TypeAliasDeclaration, VariableDeclaration, getArguments, getBody, getElements, getExpression, getInitializer, getLabel, getLocals, getModifiers, getName, getParameters, getPostfixToken, getProperties, getStatements, getSymbol, getText, isDeclarationNode, isLocalsContainer, setEndFlowNode, setFlowNode, setLocalSymbol, setLocals, setNextContainer, setReturnFlowNode, setSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { isAmbientModule, isAssignmentOperator, isFunctionLike, isGlobalScopeAugmentation, isInJSFile, isLeftHandSideExpression, isRequireCall, isStringLiteralLike, nodeIsMissing, nodeIsPresent, } from './ast-utilities.js';
 import { declarationNameToString, expressionIsAlias, getAssignmentDeclarationKind, getCombinedModifierFlags, getContainingClass, getElementOrPropertyAccessName, getErrorRangeForNode, getImmediatelyInvokedFunctionExpression, getModuleInstanceState, StatementsByName, getNameOfDeclaration, getRangeOfTokenAtPosition, getSourceTextOfNode, hasDynamicName, hasSyntacticModifier, isAssignmentTarget, isAsyncFunction, isAutoAccessorPropertyDeclaration, isBlockOrCatchScoped, isBooleanLiteral, isDeclarationStatementKind, isDestructuringAssignment, isDottedName, isEntityNameExpression, isEnumConst, isExpandoInitializer, isExpressionOfOptionalChainRoot, isExternalModule, isExternalOrCommonJSModule, isIdentifierName, isImplicitlyExportedJSDocDeclaration, isInTopLevelContext, isJsonSourceFile, isLogicalExpression, isLogicalOrCoalescingAssignmentExpression, isLogicalOrCoalescingAssignmentOperator, isLogicalOrCoalescingBinaryOperator, isModuleAugmentationExternal, isNullishCoalesce, isObjectLiteralMethod, isObjectLiteralOrClassExpressionMethodOrAccessor, isOptionalChain, isOptionalChainRoot, isOutermostOptionalChain, isParameterPropertyDeclaration, isPartOfParameterDeclaration, isPartOfTypeQuery, isPotentiallyExecutableNode, isPrologueDirective, isPropertyNameLiteral, isPushOrUnshiftIdentifier, isSignedNumericLiteral, isStatic, isStringOrNumericLiteralLike, isVariableDeclarationInitializedToRequire, moduleExportNameIsDefault, nodeText, skipParentheses, } from './binder-utilities.js';
 import { Diagnostic } from './diagnostics.js';
@@ -541,7 +541,7 @@ class Binder extends NodeVisitor {
         this.addDiagnostic(new Diagnostic(this.file.diagnosticFile(), range.pos, range.end, message, args));
     }
     addDiagnostic(diagnostic) {
-        this.file.bindDiagnostics.push(diagnostic);
+        this.file.bindDiagnostics = appendToList(this.file.bindDiagnostics, diagnostic);
     }
     // Traversal
     bindOptional(node) {
@@ -1619,8 +1619,8 @@ class Binder extends NodeVisitor {
             this.bind(node.argumentExpression);
         }
         else if (node instanceof CallExpression) {
-            this.bindOptional(node.questionDotToken);
-            this.bindNodes(node.typeArguments);
+            this.bindOptional(callQuestionDotToken(node));
+            this.bindNodes(callTypeArguments(node));
             this.bindNodes(node.arguments);
         }
     }
@@ -1631,7 +1631,7 @@ class Binder extends NodeVisitor {
             // An IIFE's flow node includes the evaluation of its arguments.
             const callee = skipParentheses(node.expression);
             if (callee.kind === 219 /* SyntaxKind.FunctionExpression */ || callee.kind === 220 /* SyntaxKind.ArrowFunction */) {
-                this.bindNodes(node.typeArguments);
+                this.bindNodes(callTypeArguments(node));
                 this.bindNodes(node.arguments);
                 this.bind(node.expression);
             }
@@ -1697,7 +1697,7 @@ class Binder extends NodeVisitor {
                 if (starIndex >= 0 && text.indexOf('*', starIndex + 1) >= 0)
                     this.errorOnFirstToken(name, 1136 /* Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character */, [text]);
                 else if (starIndex >= 0)
-                    this.file.patternAmbientModules.push(new PatternAmbientModule(text, starIndex, symbol));
+                    this.file.patternAmbientModules = appendToList(this.file.patternAmbientModules, new PatternAmbientModule(text, starIndex, symbol));
             }
             return;
         }

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

@@ -1,7 +1,7 @@
 // Calls, `new` and tagged templates: signature resolution with type argument inference and overload
 // selection, argument checks and resolution errors.
 import { checkDeprecatedSignature } from './checker-deprecation.js';
-import { Node, getArguments as getArgumentList, getExpression, getName, getParameters, getText, getTypeArguments as getTypeArgumentList, getNodeId, getBody, getSymbol, } from './ast.js';
+import { Node, getArguments as getArgumentList, getExpression, getName, getParameters, getText, getTypeArguments as getTypeArgumentList, getNodeId, getBody, getSymbol, callQuestionDotToken, callTypeArguments, } from './ast.js';
 import { canHaveDecorators, getEffectiveCheckNode, isFunctionLikeDeclarationKind, isImportCall, nodeIsPresent, } from './ast-utilities.js';
 import { getContainingClass, getSourceFileOfNode, isAccessExpression, isExpressionOfOptionalChainRoot, isOptionalChain, isOutermostOptionalChain, isDottedName, } from './binder-utilities.js';
 import { Diagnostic, chainDiagnostic } from './diagnostics.js';
@@ -72,7 +72,7 @@ export function checkCallExpression(c, node, checkMode) {
     if ((returnType.flags & 16896 /* TypeFlags.ESSymbolLike */) !== 0 && isSymbolOrSymbolForCall(c, call))
         return getESSymbolLikeTypeForNode(c, walkUpParenthesizedExpressions(node.parent));
     // An assertion call must name its target through explicitly typed declarations.
-    if (call.questionDotToken === undefined &&
+    if (callQuestionDotToken(call) === undefined &&
         node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */ &&
         (returnType.flags & 16 /* TypeFlags.Void */) !== 0 &&
         getTypePredicateOfSignature(c, signature) !== undefined) {
@@ -196,7 +196,7 @@ function resolveCallExpression(c, node, checkMode) {
     const callSignatures = getSignaturesOfType(c, apparentType, 0 /* SignatureKind.Call */);
     const numConstructSignatures = getSignaturesOfType(c, apparentType, 1 /* SignatureKind.Construct */).length;
     if (isUntypedFunctionCall(c, funcType, apparentType, callSignatures.length, numConstructSignatures)) {
-        if (!isErrorType(c, funcType) && node.typeArguments !== undefined)
+        if (!isErrorType(c, funcType) && callTypeArguments(node) !== undefined)
             c.error(node, 523 /* Diagnostics.Untyped_function_calls_may_not_accept_type_arguments */);
         return resolveUntypedCall(c, node);
     }
@@ -210,7 +210,7 @@ function resolveCallExpression(c, node, checkMode) {
     // An inner generic call returning a function is deferred while an outer call infers, so that
     // inferences can flow through function composition.
     if ((checkMode & 8 /* CheckMode.SkipGenericFunctions */) !== 0 &&
-        node.typeArguments === undefined &&
+        callTypeArguments(node) === undefined &&
         someGenericFunctionReturningFunction(c, callSignatures)) {
         skippedGenericFunction(c, node, checkMode);
         return c.resolvingSignature;

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

@@ -110,7 +110,7 @@ export function checkExpressionWithContextualType(c, node, contextualType, infer
     let t = checkExpressionEx(c, node, checkMode | 1 /* CheckMode.Contextual */ | (inferenceContext !== undefined ? 2 /* CheckMode.Inferential */ : 0));
     // Intra-expression inference sites only matter during this check.
     if (inferenceContext !== undefined)
-        inferenceContext.intraExpressionInferenceSites = [];
+        inferenceContext.intraExpressionInferenceSites = undefined;
     // Contextually typed literals keep their literal types rather than widening during inference.
     if (maybeTypeOfKind(t, 15360 /* TypeFlags.Literal */) &&
         isLiteralOfContextualType(c, t, instantiateContextualType(c, contextualType, node, 0 /* ContextFlags.None */)))

package/dist/api/compiler/checker-declaration-order.js

@@ -12,7 +12,7 @@ import { getExportSymbolOfValueSymbolIfExported } from './checker-symbols.js';
 import { getBaseTypes, getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { getPropertyOfType } from './checker-members.js';
 import { getFunctionFlags } from './checker-utilities.js';
-import { getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount } from './symbol.js';
 /** Reports a block-scoped variable, class or enum resolved at `errorLocation` before its declaration. */
 export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     const result = getExportSymbolOfValueSymbolIfExported(c, resolved);
@@ -23,7 +23,8 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
         (result.flags & 32 /* SymbolFlags.Class */) !== 0)
         return;
     let declaration;
-    for (const d of getDeclarations(result)) {
+    for (let i = 0; i < declarationCount(result); i++) {
+        const d = declarationAt(result, i);
         if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
             declaration = d;
             break;

package/dist/api/compiler/checker-declared-types.js

@@ -20,7 +20,7 @@ import { getIndexedAccessType, isGenericMappedType } from './checker-type-operat
 import { getSignatureInstantiation } from './checker-signatures.js';
 import { evaluateEnumMember } from './checker-evaluator.js';
 import { checkTypeAssignableTo, isTypeIdenticalTo } from './relations.js';
-import { getDeclarations } from './symbol.js';
+import { declarationAt, declarationCount, getDeclarations } from './symbol.js';
 export { getParentOfSymbol };
 export function getDeclaredTypeOfSymbol(c, symbol) {
     return tryGetDeclaredTypeOfSymbol(c, symbol) ?? c.errorType;
@@ -752,11 +752,14 @@ export function getMinTypeArgumentCount(c, typeParameters) {
 }
 /** Whether a type parameter is declared with a default, without resolving it. */
 function hasTypeParameterDefault(t) {
-    if (t.symbol === undefined)
+    const symbol = t.symbol;
+    if (symbol === undefined)
         return false;
-    for (const d of getDeclarations(t.symbol))
+    for (let i = 0; i < declarationCount(symbol); i++) {
+        const d = declarationAt(symbol, i);
         if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
+    }
     return false;
 }
 export function fillMissingTypeArguments(c, typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {