tsc-ts 0.0.5 → 0.0.7

package/dist/api/compiler/symbol-accessibility.js

@@ -4,7 +4,7 @@
 import { BinaryExpression, BindingElement, BindingPattern, ClassExpression, ExportDeclaration, ImportEqualsDeclaration, VariableDeclaration, getExpression, getInitializer, getLocals, getName, getNodeId, getText, getType, } from './ast.js';
 import { isAmbientModule, isInJSFile } from './ast-utilities.js';
 import { getCombinedModifierFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isAccessExpression, isEntityNameExpression, isExportsIdentifier, isExternalModule, isExternalOrCommonJSModule, isGlobalSourceFile, isModuleExportsAccessExpression, } from './binder-utilities.js';
-import { SymbolAccessibilityCaches } from './checker.js';
+import { ExternalModuleContainerIndex, SymbolAccessibilityCaches, fileIndexScale } from './checker.js';
 import { getEffectiveDeclarationFlags } from './checker-declarations.js';
 import { getDeclaredTypeOfSymbol } from './checker-declared-types.js';
 import { checkExpressionCached } from './checker-expressions.js';
@@ -12,11 +12,11 @@ import { resolveExternalModuleName, resolveExternalModuleSymbol } from './checke
 import { getExportsOfSymbol, getMergedSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, resolveAlias, resolveSymbol, } from './checker-symbols.js';
 import { getTypeOfSymbol } from './checker-symbol-types.js';
 import { compareSymbols } from './checker-type-factory.js';
-import { getSymbolId } from './symbol.js';
 import { SymbolAccessibilityResult, accessible } from './transformers/declarations-resolver.js';
 import { getAnyImportSyntax, getDeclarationContainer, isExternalModuleAugmentation, isLateVisibilityPaintedStatement, } from './transformers/declarations-syntactic.js';
 import { isImplicitlyExportedJSDocDeclaration } from './binder-utilities.js';
 import { symbolToString } from './type-printer.js';
+import { declarationCount, getDeclarations, getSymbolId, } from './symbol.js';
 const tableKindScale = 2 ** 44;
 function tableId(kind, id) {
     return kind * tableKindScale + id;
@@ -61,7 +61,7 @@ function isSymbolAccessibleWorker(c, symbol, enclosingDeclaration, meaning, shou
         return result;
     // A symbol not exported from its module, or from another module without an alias, can't be named.
     let symbolExternalModule = undefined;
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         symbolExternalModule = getExternalModuleContainer(c, d);
         if (symbolExternalModule !== undefined)
             break;
@@ -109,7 +109,7 @@ function isAnySymbolAccessible(c, symbols, enclosingDeclaration, initialSymbol,
     return undefined;
 }
 export function hasNonGlobalAugmentationExternalModuleDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (hasNonGlobalAugmentationExternalModuleSymbol(d))
             return true;
     return false;
@@ -128,18 +128,22 @@ function isModuleWithStringLiteralName(node) {
 export function getQualifiedLeftMeaning(rightMeaning) {
     return rightMeaning === 111551 /* SymbolFlags.Value */ ? 111551 /* SymbolFlags.Value */ : 1920 /* SymbolFlags.Namespace */;
 }
+/** The merged symbol `symbol` resolves to through aliases. */
+function getResolvedTarget(c, symbol) {
+    const resolved = resolveSymbol(c, getMergedSymbol(c, symbol));
+    return resolved !== undefined ? getMergedSymbol(c, resolved) : undefined;
+}
 /** `s1` if both symbols resolve to the same symbol, else undefined. */
 export function getSymbolIfSameReference(c, s1, s2) {
-    const r1 = resolveSymbol(c, getMergedSymbol(c, s1));
-    const r2 = resolveSymbol(c, getMergedSymbol(c, s2));
-    if (r1 !== undefined && r2 !== undefined && getMergedSymbol(c, r1) === getMergedSymbol(c, r2))
+    const r1 = getResolvedTarget(c, s1);
+    if (r1 !== undefined && r1 === getResolvedTarget(c, s2))
         return s1;
     return undefined;
 }
 // ---- Containers
 function getWithAlternativeContainers(c, container, symbol, enclosingDeclaration, meaning) {
     const additionalContainers = [];
-    for (const d of container.declarations) {
+    for (const d of getDeclarations(container)) {
         const fileSymbol = getFileSymbolIfFileSymbolExportEqualsContainer(c, d, container);
         if (fileSymbol !== undefined)
             additionalContainers.push(fileSymbol);
@@ -225,24 +229,117 @@ function getAlternativeContainingModules(c, symbol, enclosingDeclaration) {
     const cached = cache.containers.get(symbolId);
     if (cached !== undefined)
         return cached;
-    // Search every module; expensive, but independent of the location.
+    // Search every module; independent of the location.
+    const containers = getExternalModuleContainers(c, symbol);
+    cache.containers.set(symbolId, containers);
+    return containers;
+}
+/** The modules that export `symbol`, and its parent module, in program order. */
+function getExternalModuleContainers(c, symbol) {
+    const cache = caches(c);
+    if (cache.externalModuleContainers === undefined)
+        buildExternalModuleContainerIndex(c);
+    const index = cache.externalModuleContainers;
+    // Re-entered from an alias resolved while building the index, or too many files to index.
+    if (!index.complete)
+        return scanExternalModuleContainers(c, symbol);
+    // The parent module contains the symbol even when the symbol is absent from its exports.
+    const parent = getParentOfSymbol(c, symbol);
+    let parentIndex = externalModuleFileIndex(c, parent);
+    const result = [];
+    const target = getResolvedTarget(c, symbol);
+    if (target !== undefined) {
+        const keys = index.keys;
+        const first = getSymbolId(target) * fileIndexScale;
+        let low = 0;
+        let high = keys.length;
+        while (low < high) {
+            const mid = (low + high) >>> 1;
+            if (keys[mid] < first)
+                low = mid + 1;
+            else
+                high = mid;
+        }
+        for (let i = low; i < keys.length && keys[i] < first + fileIndexScale; i++) {
+            const fileIndex = keys[i] - first;
+            if (parentIndex >= 0 && parentIndex <= fileIndex) {
+                if (parentIndex < fileIndex)
+                    result.push(parent);
+                parentIndex = -1;
+            }
+            // `as`: scriptc passes an element of a subclass array only as that class.
+            result.push(getSymbolOfDeclaration(c, c.files[fileIndex]));
+        }
+    }
+    if (parentIndex >= 0)
+        result.push(parent);
+    return result;
+}
+/** The position in `Checker.files` of the external module `symbol`, or -1 for any other symbol. */
+function externalModuleFileIndex(c, symbol) {
+    if (symbol === undefined || (symbol.flags & 512 /* SymbolFlags.ValueModule */) === 0)
+        return -1;
+    for (const declaration of getDeclarations(symbol)) {
+        if (declaration.kind !== 307 /* SyntaxKind.SourceFile */)
+            continue;
+        const file = declaration;
+        if (isExternalModule(file) && getSymbolOfDeclaration(c, declaration) === symbol)
+            return c.fileIndex.get(file) ?? -1;
+    }
+    return -1;
+}
+function buildExternalModuleContainerIndex(c) {
+    const index = new ExternalModuleContainerIndex();
+    caches(c).externalModuleContainers = index;
+    if (c.files.length > fileIndexScale)
+        return;
+    const keys = [];
+    for (let fileIndex = 0; fileIndex < c.files.length; fileIndex++) {
+        const file = c.files[fileIndex];
+        if (!isExternalModule(file))
+            continue;
+        // `as`: scriptc passes an element of a subclass array only as that class.
+        const container = getSymbolOfDeclaration(c, file);
+        if (container === undefined)
+            continue;
+        for (const exported of getExportsOfSymbol(c, container).values()) {
+            const target = getResolvedTarget(c, exported);
+            if (target !== undefined)
+                keys.push(getSymbolId(target) * fileIndexScale + fileIndex);
+        }
+        const exportEquals = container.exports?.get("export=" /* InternalSymbolName.ExportEquals */);
+        const target = exportEquals !== undefined ? getResolvedTarget(c, exportEquals) : undefined;
+        if (target !== undefined)
+            keys.push(getSymbolId(target) * fileIndexScale + fileIndex);
+    }
+    keys.sort((a, b) => a - b);
+    // A module that exports a symbol under several names gives it one key.
+    let kept = 0;
+    for (let i = 0; i < keys.length; i++)
+        if (kept === 0 || keys[i] !== keys[kept - 1])
+            keys[kept++] = keys[i];
+    // An exact-size copy: each checker keeps its own index for the rest of the compilation.
+    index.keys = keys.slice(0, kept);
+    index.complete = true;
+}
+/** The modules that export `symbol`, found by checking every module. */
+function scanExternalModuleContainers(c, symbol) {
+    const containers = [];
     for (const file of c.host.getSourceFiles()) {
         if (!isExternalModule(file))
             continue;
         // `as`: scriptc passes a for-of element of a subclass array only as that class.
-        const fileSymbol = getSymbolOfDeclaration(c, file);
-        if (fileSymbol === undefined || getAliasForSymbolInContainer(c, fileSymbol, symbol) === undefined)
-            continue;
-        results.push(fileSymbol);
+        const container = getSymbolOfDeclaration(c, file);
+        if (container !== undefined && getAliasForSymbolInContainer(c, container, symbol) !== undefined)
+            containers.push(container);
     }
-    cache.containers.set(symbolId, results);
-    return results;
+    return containers;
 }
 /** The variable `var a = { x: 1 }` declares, for the anonymous `__object` symbol of its literal. */
 function getVariableDeclarationOfObjectLiteral(c, symbol, meaning) {
-    if ((meaning & 111551 /* SymbolFlags.Value */) === 0 || symbol.declarations.length === 0)
+    if ((meaning & 111551 /* SymbolFlags.Value */) === 0 || declarationCount(symbol) === 0)
         return undefined;
-    const firstDecl = symbol.declarations[0];
+    const firstDecl = symbol.declaration;
     const parent = firstDecl.parent;
     if (parent === undefined || !(parent instanceof VariableDeclaration))
         return undefined;
@@ -282,7 +379,7 @@ export function getContainersOfSymbol(c, symbol, enclosingDeclaration, meaning)
         if (s !== undefined && candidates.indexOf(s) < 0)
             candidates.push(s);
     };
-    for (const d of symbol.declarations) {
+    for (const d of getDeclarations(symbol)) {
         const parent = d.parent;
         if (!isAmbientModule(d) && parent !== undefined) {
             // A direct child of a module.
@@ -448,7 +545,7 @@ class ChainSearch {
                 (this.useOnlyExternalAliasing && !hasExternalModuleImportEqualsDeclaration(fromTable)) ||
                 (isLocalNameLookup && hasNamespaceReexportDeclaration(fromTable)) ||
                 // Exports are in scope, but export specifiers aren't.
-                (!ignoreQualification && fromTable.declarations.some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */)))
+                (!ignoreQualification && getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */)))
                 continue;
             const resolved = resolveAlias(c, fromTable);
             const candidate = this.candidateListForSymbol(fromTable, resolved, ignoreQualification);
@@ -542,10 +639,10 @@ function compareSymbolChains(c, a, b) {
     return 0;
 }
 function isUMDExportSymbol(symbol) {
-    return symbol.declarations.length > 0 && symbol.declarations[0].kind === 271 /* SyntaxKind.NamespaceExportDeclaration */;
+    return declarationCount(symbol) > 0 && symbol.declaration.kind === 271 /* SyntaxKind.NamespaceExportDeclaration */;
 }
 function hasNamespaceReexportDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isNamespaceReexportDeclaration(d))
             return true;
     return false;
@@ -556,7 +653,7 @@ function isNamespaceReexportDeclaration(node) {
         node.parent.moduleSpecifier !== undefined);
 }
 function hasExternalModuleImportEqualsDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (isExternalModuleImportEqualsDeclaration(d))
             return true;
     return false;
@@ -576,7 +673,7 @@ export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
             return true;
         // Qualify if the symbol of this name has the meaning sought.
         const shouldResolveAlias = (fromTable.flags & 2097152 /* SymbolFlags.Alias */) !== 0 &&
-            !fromTable.declarations.some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */);
+            !getDeclarations(fromTable).some((d) => d.kind === 282 /* SyntaxKind.ExportSpecifier */);
         if (shouldResolveAlias)
             fromTable = resolveAlias(c, fromTable);
         const flags = shouldResolveAlias ? getSymbolFlags(c, fromTable) : fromTable.flags;
@@ -589,9 +686,9 @@ export function needsQualification(c, symbol, enclosingDeclaration, meaning) {
     return qualify;
 }
 function isPropertyOrMethodDeclarationSymbol(symbol) {
-    if (symbol.declarations.length === 0)
+    if (declarationCount(symbol) === 0)
         return false;
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         switch (declaration.kind) {
             case 173 /* SyntaxKind.PropertyDeclaration */:
             case 175 /* SyntaxKind.MethodDeclaration */:
@@ -834,7 +931,7 @@ export function hasVisibleDeclarations(c, symbol, shouldComputeAliasesToMakeVisi
         if (aliases.indexOf(statement) < 0)
             aliases.push(statement);
     };
-    for (const declaration of symbol.declarations) {
+    for (const declaration of getDeclarations(symbol)) {
         if (declaration.kind === 79 /* SyntaxKind.Identifier */ || isDeclarationVisible(c, declaration))
             continue;
         // Unexported imports can name types if their parent is visible.

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

@@ -132,19 +132,46 @@ export declare class SymbolRareFields implements ProgramLifetime {
     members: SymbolTable | undefined;
     exports: SymbolTable | undefined;
     exportSymbol: Symbol | undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations: Node[] | undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration: Node | undefined;
 }
 export declare class Symbol implements ProgramLifetime {
     flags: SymbolFlags;
-    checkFlags: CheckFlags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    private bits;
     readonly name: string;
-    declarations: Node[];
-    valueDeclaration: Node | undefined;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration: Node | undefined;
     parent: Symbol | undefined;
     private rareFields;
     /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
     id: number;
     constructor(flags: SymbolFlags, name: string);
+    get checkFlags(): CheckFlags;
+    set checkFlags(flags: CheckFlags);
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node: Node | undefined): void;
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration(): Node | undefined;
+    set valueDeclaration(node: Node | undefined);
     private rareFieldsOrNew;
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations(): readonly Node[];
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations(): Node[] | undefined;
+    set moreDeclarations(value: Node[] | undefined);
     get members(): SymbolTable | undefined;
     set members(value: SymbolTable | undefined);
     get exports(): SymbolTable | undefined;
@@ -182,6 +209,21 @@ export declare function lastSymbolIdValue(): number;
 export declare function reserveSymbolIds(last: number): void;
 /** Appends `node` to the declarations of `symbol`. */
 export declare function addDeclaration(symbol: Symbol, node: Node): void;
+/** The number of declarations of `symbol`. */
+export declare function declarationCount(symbol: Symbol): number;
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export declare function declarationAt(symbol: Symbol, index: number): Node;
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export declare function getDeclarations(symbol: Symbol): readonly Node[];
+/** Whether `node` is a declaration of `symbol`. */
+export declare function hasDeclaration(symbol: Symbol, node: Node): boolean;
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export declare function copyDeclarations(target: Symbol, source: Symbol): void;
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export declare function setDeclarations(symbol: Symbol, declarations: readonly Node[]): void;
 /** A program-wide id, assigned to each symbol when first requested. */
 export declare function getSymbolId(symbol: Symbol): number;
 /** The exports table of `symbol`, created if missing. */

package/dist/api/compiler/symbol.js

@@ -3,27 +3,74 @@ export class SymbolRareFields {
     members = undefined;
     exports = undefined;
     exportSymbol = undefined;
+    /** All declarations of a symbol that has more than one (`getDeclarations`). */
+    declarations = undefined;
+    /** The value declaration where it is not the first declaration (`Symbol.valueDeclaration`). */
+    valueDeclaration = undefined;
 }
+/** In `Symbol.bits`, above the check flags: the value declaration is the first declaration. */
+const valueDeclarationIsFirst = 1 << 30;
 export class Symbol {
     flags;
-    checkFlags;
+    /** The check flags, and `valueDeclarationIsFirst`. */
+    bits;
     name;
-    declarations;
-    valueDeclaration;
+    /**
+     * The first declaration. A symbol with more keeps all of them in its rare fields; read them with
+     * `declarationCount`, `declarationAt` and `getDeclarations`. Written only through `setFirst`,
+     * which keeps the value declaration.
+     */
+    declaration;
     parent;
     rareFields;
     /** Assigned on first use by `getSymbolId`, or at creation while threads share the program; 0 until then. */
     id;
     constructor(flags, name) {
         this.flags = flags;
-        this.checkFlags = 0 /* CheckFlags.None */;
+        this.bits = 0;
         this.name = name;
-        this.declarations = noDeclarations;
-        this.valueDeclaration = undefined;
+        this.declaration = undefined;
         this.parent = undefined;
         this.rareFields = undefined;
         this.id = idsAtCreation ? takeSymbolId() : 0;
     }
+    get checkFlags() {
+        return (this.bits & ~valueDeclarationIsFirst);
+    }
+    set checkFlags(flags) {
+        this.bits = (this.bits & valueDeclarationIsFirst) | flags;
+    }
+    /** Makes `node` the first declaration, keeping the value declaration. */
+    setFirst(node) {
+        if ((this.bits & valueDeclarationIsFirst) !== 0 && node !== this.declaration) {
+            // The value declaration stays what it was.
+            this.rareFieldsOrNew().valueDeclaration = this.declaration;
+            this.bits &= ~valueDeclarationIsFirst;
+        }
+        this.declaration = node;
+    }
+    /**
+     * The declaration of the symbol's value. Almost always the first declaration, which a bit of `bits`
+     * says; any other is kept in the rare fields.
+     */
+    get valueDeclaration() {
+        if ((this.bits & valueDeclarationIsFirst) !== 0)
+            return this.declaration;
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.valueDeclaration;
+    }
+    set valueDeclaration(node) {
+        const group = this.rareFields;
+        if (node !== undefined && node === this.declaration) {
+            this.bits |= valueDeclarationIsFirst;
+            if (group !== undefined)
+                group.valueDeclaration = undefined;
+            return;
+        }
+        this.bits &= ~valueDeclarationIsFirst;
+        if (node !== undefined || group !== undefined)
+            this.rareFieldsOrNew().valueDeclaration = node;
+    }
     rareFieldsOrNew() {
         let group = this.rareFields;
         if (group === undefined) {
@@ -32,6 +79,23 @@ export class Symbol {
         }
         return group;
     }
+    /**
+     * The declarations, for tsc-ts/api's `Symbol.declarations`. The compiler reads `declaration`,
+     * `declarationCount` and `declarationAt`: for a single declaration this builds a list on each read.
+     */
+    get declarations() {
+        return getDeclarations(this);
+    }
+    /** All declarations where there are more than one, else undefined. */
+    get moreDeclarations() {
+        const group = this.rareFields;
+        return group === undefined ? undefined : group.declarations;
+    }
+    set moreDeclarations(value) {
+        if (value === undefined && this.rareFields === undefined)
+            return;
+        this.rareFieldsOrNew().declarations = value;
+    }
     get members() {
         const group = this.rareFields;
         return group === undefined ? undefined : group.members;
@@ -156,11 +220,58 @@ export function reserveSymbolIds(last) {
 const noDeclarations = [];
 /** Appends `node` to the declarations of `symbol`. */
 export function addDeclaration(symbol, node) {
-    const declarations = symbol.declarations;
-    if (declarations.length === 0)
-        symbol.declarations = [node];
+    const first = symbol.declaration;
+    if (first === undefined) {
+        symbol.setFirst(node);
+        return;
+    }
+    const more = symbol.moreDeclarations;
+    if (more !== undefined)
+        more.push(node);
     else
-        declarations.push(node);
+        symbol.moreDeclarations = [first, node];
+}
+/** The number of declarations of `symbol`. */
+export function declarationCount(symbol) {
+    if (symbol.declaration === undefined)
+        return 0;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more.length : 1;
+}
+/** The declaration of `symbol` at `index`, which is below `declarationCount(symbol)`. */
+export function declarationAt(symbol, index) {
+    return index === 0 ? symbol.declaration : symbol.moreDeclarations[index];
+}
+/**
+ * The declarations of `symbol`, in order. A symbol with one declaration gets a new list each call;
+ * hot paths read `declaration`, `declarationCount` and `declarationAt` instead.
+ */
+export function getDeclarations(symbol) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return noDeclarations;
+    const more = symbol.moreDeclarations;
+    return more !== undefined ? more : [first];
+}
+/** Whether `node` is a declaration of `symbol`. */
+export function hasDeclaration(symbol, node) {
+    const first = symbol.declaration;
+    if (first === undefined)
+        return false;
+    if (first === node)
+        return true;
+    const more = symbol.moreDeclarations;
+    return more !== undefined && more.indexOf(node) >= 0;
+}
+/** Gives `target` the declarations of `source`; a list of several is shared, as the list was before. */
+export function copyDeclarations(target, source) {
+    target.setFirst(source.declaration);
+    target.moreDeclarations = source.moreDeclarations;
+}
+/** Replaces the declarations of `symbol` with `declarations`, which it keeps when they are more than one. */
+export function setDeclarations(symbol, declarations) {
+    symbol.setFirst(declarations.length !== 0 ? declarations[0] : undefined);
+    symbol.moreDeclarations = declarations.length > 1 ? declarations : undefined;
 }
 /**
  * The symbols of `table` by escaped name, with their ids assigned, as tsc-ts's public API types them: the map's

package/dist/api/compiler/transformers/alias-references.d.ts

@@ -1,7 +1,7 @@
 import { type Node, NodeVisitor, type SourceFile } from '../ast.js';
 import { type CompilerOptions } from '../options.js';
-import { type Symbol } from '../symbol.js';
 import { type ReferenceResolver } from './reference-resolver.js';
+import { type Symbol } from '../symbol.js';
 export declare class AliasReferences extends NodeVisitor {
     readonly options: CompilerOptions;
     readonly resolver: ReferenceResolver;

package/dist/api/compiler/transformers/alias-references.js

@@ -9,6 +9,7 @@ import { JsxEmit, getIsolatedModules, getStrictOptionValue, shouldPreserveConstE
 import { getDeclarationOfAliasSymbol } from './reference-resolver.js';
 import { getFirstConstructorWithBody, getRestParameterElementType, getSetAccessorValueParameter, nodeCanBeDecorated, } from './decorator-utilities.js';
 import { hasDecorators, hasSyntacticModifier } from './utilities.js';
+import { getDeclarations } from '../symbol.js';
 export class AliasReferences extends NodeVisitor {
     options;
     resolver;
@@ -149,7 +150,7 @@ export class AliasReferences extends NodeVisitor {
         if (symbol === undefined)
             return undefined;
         const kind = node.kind === 179 /* SyntaxKind.SetAccessor */ ? 178 /* SyntaxKind.GetAccessor */ : 179 /* SyntaxKind.SetAccessor */;
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (declaration.kind === kind)
                 return declaration;
         return undefined;

package/dist/api/compiler/transformers/class-fields.js

@@ -1,7 +1,7 @@
 // Lowers class fields, private names, static blocks and `accessor` fields: initializers move to
 // the constructor (useDefineForClassFields: false, or targets before ES2022), private members
 // become WeakMaps, WeakSets and hoisted functions, and static `this` and `super` refer to the class.
-import { ArrayLiteralExpression, BinaryExpression, Block, CallExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, ElementAccessExpression, ExportAssignment, ExpressionWithTypeArguments, GetAccessorDeclaration, HeritageClause, Identifier, NodeList, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, TryStatement, NewExpression, ArrowFunction, CatchClause, FunctionExpression, MethodDeclaration, NodeVisitor, VoidExpression, getBody, getParameters, getInitializer, getMembers, getModifiers, getName, } from '../ast.js';
+import { ArrayLiteralExpression, BinaryExpression, Block, CallExpression, ClassDeclaration, ClassExpression, ClassStaticBlockDeclaration, ComputedPropertyName, ConstructorDeclaration, ElementAccessExpression, ExportAssignment, ExpressionWithTypeArguments, GetAccessorDeclaration, HeritageClause, Identifier, NodeList, ObjectLiteralExpression, ParameterDeclaration, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertyAssignment, PropertyDeclaration, SetAccessorDeclaration, ShorthandPropertyAssignment, SpreadAssignment, SpreadElement, StringLiteral, TryStatement, NewExpression, ArrowFunction, CatchClause, FunctionExpression, MethodDeclaration, NodeVisitor, VoidExpression, getBody, getParameters, getInitializer, getMembers, getModifiers, getName, callQuestionDotToken, callTypeArguments, newCallExpression, } from '../ast.js';
 import { isLeftHandSideExpression } from '../ast-utilities.js';
 import { getNameOfDeclaration, hasStaticModifier, isAssignmentExpression, isAutoAccessorPropertyDeclaration, isClassLike, isDestructuringAssignment, isMethodOrAccessor, isPrivateIdentifierClassElementDeclaration, isStatic, skipParentheses, } from '../binder-utilities.js';
 import { isIdentifierText } from '../scanner.js';
@@ -963,7 +963,7 @@ export class ClassFieldsTransformer extends Transformer {
         if (node instanceof ParenthesizedExpression)
             return factory.cloneNode(node, new ParenthesizedExpression(node.expression));
         if (node instanceof CallExpression)
-            return factory.cloneNode(node, new CallExpression(node.expression, node.questionDotToken, node.typeArguments, node.arguments, node.flags));
+            return factory.cloneNode(node, newCallExpression(node.expression, callQuestionDotToken(node), callTypeArguments(node), node.arguments, node.flags, false));
         return factory.cloneNode(node, node.deepClone());
     }
     visitCallExpression(node) {
@@ -980,7 +980,7 @@ export class ClassFieldsTransformer extends Transformer {
             for (let i = 0; i < visitedArgs.length; i++)
                 args.push(visitedArgs[i]);
             const optional = (node.flags & 32 /* NodeFlags.OptionalChain */) !== 0;
-            const call = factory.created(new PropertyAccessExpression(target, optional ? node.questionDotToken : undefined, factory.createIdentifier('call'), optional ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */));
+            const call = factory.created(new PropertyAccessExpression(target, optional ? callQuestionDotToken(node) : undefined, factory.createIdentifier('call'), optional ? 32 /* NodeFlags.OptionalChain */ : 0 /* NodeFlags.None */));
             return factory.updateCallExpression(node, call, undefined, undefined, factory.createNodeList(args), node.flags);
         }
         const data = this.staticSuperData(callee);

package/dist/api/compiler/transformers/commonjs-module.js

@@ -1,5 +1,5 @@
 // CommonJS module output: imports become `require` calls, exports assignments to `exports`.
-import { ArrowFunction, BinaryExpression, BindingPattern, Block, CallExpression, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, DoStatement, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, LabeledStatement, NamedExports, NamespaceExport, NodeList, NodeVisitor, ObjectLiteralExpression, ArrayLiteralExpression, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateSpan, TemplateTail, TryStatement, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, EmptyStatement, getElements, getName, } from '../ast.js';
+import { ArrowFunction, BinaryExpression, BindingPattern, Block, CallExpression, CaseBlock, CaseOrDefaultClause, CatchClause, ClassDeclaration, ClassExpression, DoStatement, ExportAssignment, ExportDeclaration, ExportSpecifier, ExpressionStatement, ExternalModuleReference, ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportClause, ImportDeclaration, ImportEqualsDeclaration, ImportSpecifier, LabeledStatement, NamedExports, NamespaceExport, NodeList, NodeVisitor, ObjectLiteralExpression, ArrayLiteralExpression, ParenthesizedExpression, PartiallyEmittedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, SwitchStatement, TaggedTemplateExpression, TemplateExpression, TemplateHead, TemplateSpan, TemplateTail, TryStatement, VariableDeclaration, VariableDeclarationList, VariableStatement, VoidExpression, WhileStatement, WithStatement, EmptyStatement, getElements, getName, callQuestionDotToken, } from '../ast.js';
 import { getExternalModuleName, isImportCall, isInJSFile, isRequireCall } from '../ast-utilities.js';
 import { isAssignmentExpression, isDestructuringAssignment } from '../binder-utilities.js';
 import { JsxEmit, ModuleKind, ScriptTarget, getEmitModuleKind, getEmitScriptTarget, } from '../options.js';
@@ -869,7 +869,7 @@ export class CommonJSModuleTransformer extends Transformer {
         const callee = node.expression;
         if (callee instanceof Identifier) {
             const expression = this.visitExpressionIdentifier(callee);
-            const updated = this.factory.updateCallExpression(node, expression, node.questionDotToken, undefined, this.visitNodes(node.arguments), node.flags);
+            const updated = this.factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, this.visitNodes(node.arguments), node.flags);
             if (!(expression instanceof Identifier) && (this.context.getEmitFlags(callee) & 1024 /* EmitFlags.HelperName */) === 0)
                 this.context.addEmitFlags(updated, 1048576 /* EmitFlags.IndirectCall */);
             return updated;
@@ -938,7 +938,7 @@ export class CommonJSModuleTransformer extends Transformer {
             if (rewritten !== first || visitedRest !== rest)
                 args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
         }
-        return factory.updateCallExpression(node, expression, node.questionDotToken, undefined, args, node.flags);
+        return factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, args, node.flags);
     }
     visitTaggedTemplateExpression(node) {
         const tag = node.tag;

package/dist/api/compiler/transformers/declarations-diagnostics.js

@@ -6,6 +6,7 @@ import { isFunctionLikeDeclarationKind } from '../ast-utilities.js';
 import { Diagnostic } from '../diagnostics.js';
 import { isStatement } from '../printer/utilities.js';
 import { isParameterPropertyDeclaration } from './utilities.js';
+import { getDeclarations } from '../symbol.js';
 export function createDiagnosticForNode(node, message, args) {
     const file = getSourceFileOfNode(node);
     const range = getErrorRangeForNode(file, node);
@@ -527,7 +528,7 @@ export function getAllAccessorDeclarations(accessor) {
     let other = undefined;
     const symbol = getSymbol(accessor);
     if (symbol !== undefined)
-        for (const declaration of symbol.declarations)
+        for (const declaration of getDeclarations(symbol))
             if (declaration.kind === otherKind) {
                 other = declaration;
                 break;

package/dist/api/compiler/transformers/declarations-pseudo.js

@@ -2,10 +2,11 @@
 // pseudochecker and the isolatedDeclarations rules. Annotations, literals, `as const` values
 // and function expressions with annotated returns have pseudo-types; everything else is
 // "inferred" and needs the checker.
-import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclaration, GetAccessorDeclaration, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, PropertyDeclaration, ReturnStatement, SetAccessorDeclaration, TypeReferenceNode, VariableDeclaration, UnionTypeNode, IntersectionTypeNode, getAsteriskToken, getBody, getExpression, getName, getParameters, getPostfixToken, getSymbol, getType, getTypeParameters, } from '../ast.js';
+import { ArrayLiteralExpression, ArrowFunction, FunctionExpression, MethodDeclaration, GetAccessorDeclaration, NodeVisitor, ObjectLiteralExpression, ParameterDeclaration, PrefixUnaryExpression, PropertyAssignment, PropertyDeclaration, ReturnStatement, SetAccessorDeclaration, TypeReferenceNode, VariableDeclaration, UnionTypeNode, IntersectionTypeNode, getAsteriskToken, getBody, getExpression, getName, getParameters, getPostfixToken, getSymbol, getType, getTypeParameters, propertyAssignmentPostfixToken, } from '../ast.js';
 import { isFunctionLike, nodeIsMissing } from '../ast-utilities.js';
 import { getCombinedNodeFlags, hasSyntacticModifier, isIdentifierNamed } from '../binder-utilities.js';
 import { getAllAccessorDeclarations } from './declarations-diagnostics.js';
+import { declarationCount, getDeclarations } from '../symbol.js';
 export class PseudoType {
     kind;
     constructor(kind) {
@@ -249,7 +250,7 @@ export class PseudoChecker {
         // A property declared more than once has the type of its first declaration; only the checker
         // knows which, so the type is still written from this one but counted as uncertain.
         const symbol = getSymbol(node);
-        if (symbol !== undefined && symbol.declarations.length > 1)
+        if (symbol !== undefined && declarationCount(symbol) > 1)
             this.uncertain++;
         if (node instanceof PropertyDeclaration) {
             const initializer = node.initializer;
@@ -277,7 +278,8 @@ export class PseudoChecker {
         const initializer = declaration.initializer;
         // As tsgo, the file's own declarations; merged ones are left to the checker's type comparison.
         const symbol = declaration.symbol;
-        if (initializer !== undefined && (symbol === undefined || countVariableDeclarations(symbol.declarations) === 1)) {
+        if (initializer !== undefined &&
+            (symbol === undefined || countVariableDeclarations(getDeclarations(symbol)) === 1)) {
             if (!isContextuallyTyped(declaration)) {
                 // Const template literals may become literal types, so they aren't inferred.
                 if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) !== 0 &&
@@ -414,7 +416,7 @@ export class PseudoChecker {
                 }
                 case 303 /* SyntaxKind.PropertyAssignment */: {
                     const assignment = property;
-                    const postfix = assignment.postfixToken;
+                    const postfix = propertyAssignmentPostfixToken(assignment);
                     members.push(new PseudoMember(1 /* PseudoMemberKind.Property */, assignment.name, postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */, false, undefined, [], [], this.typeFromExpression(assignment.initializer)));
                     break;
                 }