tsc-ts 0.0.5 → 0.0.7

package/README.md

@@ -33,7 +33,7 @@ npx tsc-ts --noEmit src/index.ts
 
 `tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`.
 
-`--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. 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.
+`--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.
 
 The native executable never frees syntax trees, types, signatures or symbols: it keeps them until it exits, which saves the cost of tracking them during a build. A one-shot build is unaffected, but a long-running process grows with each rebuild or project update. Native `--watch` (also with `--build`) runs in a child process, and when a change arrives while that process holds more than 2.5 times the memory it held after its first build, a new process replaces it and builds the change, reporting what the old process would have. `TSC_TS_WATCH_MEMORY` sets that limit in megabytes, and `TSC_TS_WATCH_MEMORY=0` turns the replacement off. A `--api` process grows with each project update; restart it to reclaim the memory.
 

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

@@ -243,13 +243,22 @@ export declare class Token extends Node {
 }
 export declare class Identifier extends Node {
     text: string;
-    flowNode: FlowNode | undefined;
     constructor(text: string);
     forEachChild(_v: NodeVisitor): boolean;
     setParentOfChildren(): void;
     deepClone(): Node;
     copy(): Identifier;
 }
+/**
+ * An identifier that can be read as a reference, such as an expression or a shorthand property
+ * name, and so holds the binder's flow node. The parser creates a plain `Identifier` for names
+ * whose flow node nothing reads: declaration names, property names and property access names.
+ */
+export declare class ReferenceIdentifier extends Identifier {
+    flowNode: FlowNode | undefined;
+    constructor(text: string);
+    copy(): Identifier;
+}
 export declare class PrivateIdentifier extends Node {
     text: string;
     constructor(text: string);
@@ -1174,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;
@@ -1286,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;
@@ -2211,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;
@@ -2218,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;
@@ -2236,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;
     /**
@@ -2262,20 +2310,14 @@ 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;
-    /**
-     * By name, the first property of the unions of the file's object literals that leave the name
-     * missing (checker-symbol-types.ts `scanSiblingProperties`), where a parse thread scanned the file
-     * and could resolve the enums the scan needed.
-     */
-    siblingProperties: Map<string, Node> | undefined;
     constructor(fileName: string, path: string, text: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, statements: NodeList, endOfFileToken: Token);
     forEachChild(v: NodeVisitor): boolean;
     setParentOfChildren(): void;
@@ -2287,8 +2329,6 @@ export declare class SourceFile extends Node {
      * never writes to the file (UTF-8 offsets are computed on first use, `DiagnosticFile.computeCaches`).
      */
     computeCaches(): void;
-    /** Like `computeCaches`, from the UTF-16 code units of the text (at least `text.length` of them). */
-    computeCachesFromUnits(units: Uint16Array): void;
     /** The file as diagnostics see it. */
     diagnosticFile(): DiagnosticFile;
     isJS(): boolean;

package/dist/api/compiler/ast.js

@@ -222,12 +222,9 @@ export class Token extends Node {
 }
 export class Identifier extends Node {
     text;
-    // Set by the binder.
-    flowNode;
     constructor(text) {
         super(79 /* SyntaxKind.Identifier */);
         this.text = text;
-        this.flowNode = undefined;
     }
     forEachChild(_v) {
         return false;
@@ -244,6 +241,26 @@ export class Identifier extends Node {
         return node;
     }
 }
+/**
+ * An identifier that can be read as a reference, such as an expression or a shorthand property
+ * name, and so holds the binder's flow node. The parser creates a plain `Identifier` for names
+ * whose flow node nothing reads: declaration names, property names and property access names.
+ */
+export class ReferenceIdentifier extends Identifier {
+    // Set by the binder.
+    flowNode;
+    constructor(text) {
+        super(text);
+        this.flowNode = undefined;
+    }
+    copy() {
+        const node = new ReferenceIdentifier(this.text);
+        node.flags = this.flags;
+        node.pos = this.pos;
+        node.end = this.end;
+        return node;
+    }
+}
 export class PrivateIdentifier extends Node {
     text;
     constructor(text) {
@@ -3213,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) {
@@ -3244,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;
@@ -3565,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;
@@ -3602,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;
@@ -6506,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;
@@ -6567,12 +6679,6 @@ export class SourceFile extends Node {
     patternAmbientModules;
     /** UMD exports from `export as namespace N`. */
     globalExports;
-    /**
-     * By name, the first property of the unions of the file's object literals that leave the name
-     * missing (checker-symbol-types.ts `scanSiblingProperties`), where a parse thread scanned the file
-     * and could resolve the enums the scan needed.
-     */
-    siblingProperties;
     constructor(fileName, path, text, externalModuleIndicatorOptions, statements, endOfFileToken) {
         super(307 /* SyntaxKind.SourceFile */);
         this.fileName = fileName;
@@ -6581,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;
@@ -6594,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;
@@ -6612,12 +6718,11 @@ 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;
-        this.siblingProperties = undefined;
     }
     forEachChild(v) {
         return v.visitList(this.statements) || v.visitNode(this.endOfFileToken);
@@ -6640,10 +6745,6 @@ export class SourceFile extends Node {
     computeCaches() {
         this.diagnosticFile().computeCaches();
     }
-    /** Like `computeCaches`, from the UTF-16 code units of the text (at least `text.length` of them). */
-    computeCachesFromUnits(units) {
-        this.diagnosticFile().computeCachesFromUnits(units);
-    }
     /** The file as diagnostics see it. */
     diagnosticFile() {
         let file = this.diagnosticFileCache;
@@ -7084,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;
             }
@@ -7455,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;
             }
@@ -7940,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;
             }
@@ -7957,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;
             }
@@ -9189,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;
             }
@@ -9520,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;
             }
@@ -10503,7 +10604,7 @@ export function setNextContainer(node, value) {
 export function getFlowNode(node) {
     switch (node.kind) {
         case 79 /* SyntaxKind.Identifier */:
-            if (node instanceof Identifier) {
+            if (node instanceof ReferenceIdentifier) {
                 const holder = node;
                 return holder.flowNode;
             }
@@ -10774,7 +10875,7 @@ export function getFlowNode(node) {
 export function setFlowNode(node, value) {
     switch (node.kind) {
         case 79 /* SyntaxKind.Identifier */:
-            if (node instanceof Identifier) {
+            if (node instanceof ReferenceIdentifier) {
                 const target = node;
                 target.flowNode = value;
             }

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

@@ -3,10 +3,11 @@
 //
 // 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';
+import { getDeclarations } from './symbol.js';
 // Modifiers and flags
 export function getModifierFlags(node) {
     const modifiers = getModifiers(node);
@@ -265,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;
@@ -861,7 +862,7 @@ export function moduleExportNameIsDefault(node) {
     return getText(node) === "default" /* InternalSymbolName.Default */;
 }
 export function getDeclarationOfKind(symbol, kind) {
-    for (const declaration of symbol.declarations)
+    for (const declaration of getDeclarations(symbol))
         if (declaration.kind === kind)
             return declaration;
     return undefined;