tsc-ts 0.0.5 → 0.0.6

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

@@ -3,31 +3,30 @@
 import { checkJsxAttribute } from './checker-jsx.js';
 import { getTargetOfAliasDeclaration, resolveExternalModuleSymbol } from './checker-modules.js';
 import { cachedTypeKey } from './checker-types.js';
-import { NodeVisitor, getArguments, getInitializer, getName, getParameters, getType, getBody, getSymbol, getMembers, getDotDotDotToken, getElements, getExpression, getLocals, getPostfixToken, getQuestionToken, getText, } from './ast.js';
-import { declarationNameToString, findConstructorDeclaration, getCombinedModifierFlags, getCombinedNodeFlags, getNameOfDeclaration, getRootDeclaration, getSourceFileOfNode, hasStaticModifier, hasSyntacticModifier, isCatchClauseVariableDeclarationOrBindingElement, isExternalModule, isJsonSourceFile, isTypeNodeKind, skipParentheses, } from './binder-utilities.js';
+import { getArguments, getInitializer, getName, getParameters, getType, getBody, getSymbol, getMembers, getDotDotDotToken, getElements, getExpression, getPostfixToken, getQuestionToken, getText, } from './ast.js';
+import { declarationNameToString, findConstructorDeclaration, getCombinedModifierFlags, getCombinedNodeFlags, getNameOfDeclaration, getRootDeclaration, getSourceFileOfNode, hasStaticModifier, hasSyntacticModifier, isCatchClauseVariableDeclarationOrBindingElement, isJsonSourceFile, isTypeNodeKind, } from './binder-utilities.js';
 import { identifierToKeywordKind } from './scanner.js';
-import { tsgoCheckerSlots } from './symbol-accessibility.js';
-import { getSymbolId } from './symbol.js';
 import { createDiagnosticForNode } from './checker.js';
 import { IndexInfo, } from './checker-types.js';
 import { createAnonymousType, createTypeReference, getIntersectionType, getUnionType, getUnionTypeEx, getWidenedLiteralType, isArrayOrTupleType, isEmptyObjectType, newObjectType, removeType, filterType, typesOf, getTypeArguments, } from './checker-type-factory.js';
-import { getDeclarationOfAliasSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, reportCircularityError, resolveAlias, getMergedSymbol, getGlobalTypeAliasSymbol, resolveName, getGlobalSymbol, } from './checker-symbols.js';
+import { getDeclarationOfAliasSymbol, getParentOfSymbol, getSymbolFlags, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, reportCircularityError, resolveAlias, getGlobalTypeAliasSymbol, resolveName, getGlobalSymbol, } from './checker-symbols.js';
 import { getBaseConstructorTypeOfClass, getDeclaredTypeOfClassOrInterface, getDeclaredTypeOfEnumMember, getDeclaredTypeOfSymbol, } from './checker-declared-types.js';
 import { getESSymbolLikeTypeForNode, getTypeFromTypeNode, getTypeAliasInstantiation } from './checker-type-nodes.js';
 import { getFlowTypeInConstructor, getFlowTypeInStaticBlocks, getTypeOfPropertyInBaseClass, } from './checker-classes.js';
 import { instantiateType } from './instantiation.js';
-import { getIndexInfosOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertyOfObjectType, isObjectLiteralType, } from './checker-members.js';
+import { getIndexInfosOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertyOfObjectType, isObjectLiteralType, keepPropertiesOnly, scannedLiteralPropertiesLimit, } from './checker-members.js';
 import { typeToString, symbolToString } from './type-printer.js';
 import { getTypeOfMappedSymbol, getIndexType } from './checker-type-operators.js';
 import { getReturnTypeOfSignature, getSignatureFromDeclaration, getTypeOfParameter as getTypeOfParameterOfSignature, } from './checker-signatures.js';
-import { getReturnTypeFromBody, getTypeOfObjectLiteralMethod, ReturnCollector, shouldReportErrorsFromWideningWithContextualSignature, } from './checker-functions.js';
+import { getReturnTypeFromBody, getTypeOfObjectLiteralMethod, shouldReportErrorsFromWideningWithContextualSignature, } from './checker-functions.js';
 import { getTypeOfReverseMappedSymbol } from './checker-inference.js';
-import { checkDeclarationInitializer, getContextuallyTypedParameterType, getContextualThisParameterType, checkExpressionCached, checkExpressionEx, isConstTypeReference, } from './checker-expressions.js';
+import { checkDeclarationInitializer, getContextuallyTypedParameterType, getContextualThisParameterType, checkExpressionCached, checkExpressionEx, } from './checker-expressions.js';
 import { checkPropertyAssignment, checkShorthandPropertyAssignment } from './checker-object-literals.js';
 import { getTypeForBindingElement, getTypeFromBindingPattern } from './checker-destructuring.js';
 import { checkRightHandSideOfForOf } from './checker-statements.js';
 import { getTypeWithFacts, hasTypeFacts, getNonNullableType } from './checker-flow.js';
 import { getTypeOfModuleExportsSymbol, getWidenedTypeForAssignmentDeclaration } from './checker-javascript.js';
+import { copyDeclarations, getDeclarations, getSymbolId } from './symbol.js';
 export function getTypeOfSymbol(c, symbol) {
     const checkFlags = symbol.checkFlags;
     if ((checkFlags & 65536 /* CheckFlags.DeferredType */) !== 0)
@@ -277,7 +276,7 @@ export function getTypeForVariableLikeDeclaration(c, declaration, includeOptiona
         // A set accessor parameter takes the getter's type.
         if (fn.kind === 179 /* SyntaxKind.SetAccessor */) {
             const fnSymbol = getSymbolOfDeclaration(c, fn);
-            const getter = fnSymbol?.declarations.find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */);
+            const getter = fnSymbol !== undefined ? getDeclarations(fnSymbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */) : undefined;
             if (getter !== undefined) {
                 const getterSignature = getSignatureFromDeclaration(c, getter);
                 // An unannotated `this` of a setter takes the getter's `this` type.
@@ -436,7 +435,7 @@ function reportWideningErrorsInType(c, t) {
                 continue;
             // Property types can come from object literal normalization in unions.
             let valueDeclaration;
-            for (const d of p.declarations) {
+            for (const d of getDeclarations(p)) {
                 const v = getSymbol(d)?.valueDeclaration;
                 if (v !== undefined && v.parent === t.symbol?.valueDeclaration) {
                     valueDeclaration = d;
@@ -623,6 +622,7 @@ function getWidenedTypeOfObjectLiteral(c, t, context) {
                 members.set(prop.name, getUndefinedProperty(c, prop));
     const infos = getIndexInfosOfType(c, t).map((info) => new IndexInfo(info.keyType, getWidenedType(c, info.valueType), info.isReadonly, info.declaration, info.components));
     const result = createAnonymousType(c, t.symbol, members, [], [], infos);
+    keepPropertiesOnly(c, result, members, scannedLiteralPropertiesLimit);
     result.objectFlags |= t.objectFlags & (4096 /* ObjectFlags.JSLiteral */ | 262144 /* ObjectFlags.NonInferrableType */);
     // The root context widens each object literal once; a property's context may widen one literal
     // for several siblings.
@@ -644,7 +644,7 @@ function getWidenedProperty(c, prop, context) {
 }
 function createSymbolWithWidenedType(c, prop, t) {
     const result = c.newSymbolWithCheckFlags(prop.flags, prop.name, prop.checkFlags & 8 /* CheckFlags.Readonly */);
-    result.declarations = prop.declarations;
+    copyDeclarations(result, prop);
     result.parent = prop.parent;
     result.valueDeclaration = prop.valueDeclaration;
     const id = getSymbolId(result);
@@ -654,950 +654,20 @@ function createSymbolWithWidenedType(c, prop, t) {
     return result;
 }
 /**
- * An optional `undefined` property standing in for `prop`, the last property of that name among the
- * sibling object literals (getPropertiesOfContext). It carries the declarations of the property it is
- * created from, which order it among the members when they are printed.
- *
- * tsgo caches one such symbol per name and checker, so the declarations come from the first literal
- * its checker widened with that name missing in a sibling. Its checkers check the program's files
- * round robin, each file from the top. tsc-ts's checkers take files in another order, and a checker
- * can infer a file's functions for an importer before it checks the file, so the first union is found
- * in the sources of the files tsgo checks with the checker of the property's file, up to that file
- * (`firstSiblingProperty`), which doesn't depend on the order of checking. Without one, the property
- * is cached per sibling property. The order differs from tsgo's where tsgo's checker first infers a
- * function of a file of another checker, or a later function of the file.
+ * An optional `undefined` property standing in for `prop`, a property of a sibling object literal
+ * (getPropertiesOfContext), one per property. It carries the declarations of `prop`, which order it
+ * among the members when they are printed.
  */
 function getUndefinedProperty(c, prop) {
-    const member = prop.declarations.length > 0 ? firstSiblingProperty(c, prop.declarations[0], prop.name) : undefined;
-    const first = member !== undefined ? getSymbol(member) : undefined;
-    const source = first ?? prop;
-    const key = getSymbolId(source);
+    const key = getSymbolId(prop);
     const cached = c.undefinedProperties.get(key);
     if (cached !== undefined)
         return cached;
-    const result = createSymbolWithWidenedType(c, source, c.undefinedOrMissingType);
+    const result = createSymbolWithWidenedType(c, prop, c.undefinedOrMissingType);
     result.flags |= 16777216 /* SymbolFlags.Optional */;
-    // The properties of a literal in an `as const` assertion are readonly.
-    if (first !== undefined && isInConstAssertion(member.parent))
-        result.checkFlags |= 8 /* CheckFlags.Readonly */;
     c.undefinedProperties.set(key, result);
     return result;
 }
-/**
- * The property of `name` in the first union of object literals that leaves `name` missing in one of
- * them, among the files tsgo checks with the checker of the declaration's file, up to that file: the
- * last literal's property of that name. tsgo's checker `k` checks files `k`, `k + n`, `k + 2n`, ...
- * in order (`tsgoCheckerSlots`). Unions are those of the returned expressions of a function without
- * a return type, and of the alternatives of an initializer without a type (`?:`, `||`, `??`, array
- * elements, an element access of an array literal, and the values of a property across the literals),
- * of the variables of a `for...of`, of the object of a method call and of the expression of a type
- * assertion. In a file, they are taken in the order a checker checking the file from the top widens
- * them (`SiblingPropertyScan`).
- */
-function firstSiblingProperty(c, declaration, name) {
-    const file = getSourceFileOfNode(declaration);
-    const index = c.fileIndex.get(file);
-    if (index === undefined)
-        return siblingPropertiesOfFile(c, file).get(name);
-    const slots = tsgoCheckerSlots(c);
-    let slot = c.slotSiblingProperties.get(index % slots);
-    if (slot === undefined) {
-        slot = new SlotSiblingProperties(index % slots);
-        c.slotSiblingProperties.set(index % slots, slot);
-    }
-    for (; slot.next <= index; slot.next += slots)
-        for (const [n, member] of siblingPropertiesOfFile(c, c.files[slot.next]))
-            if (!slot.members.has(n)) {
-                slot.members.set(n, member);
-                slot.fileIndexes.set(n, slot.next);
-            }
-    const found = slot.fileIndexes.get(name);
-    return found !== undefined && found <= index ? slot.members.get(name) : undefined;
-}
-/**
- * By name, the first property of the unions of `file` that leave the name missing: what a parse thread
- * found (`SourceFile.siblingProperties`), or else the checker's own scan.
- */
-function siblingPropertiesOfFile(c, file) {
-    // A parse thread's scan takes array literals to have the global Array type.
-    if (file.siblingProperties !== undefined && c.globalArrayType !== c.emptyGenericType)
-        return file.siblingProperties;
-    let first = c.firstSiblingProperties.get(file);
-    if (first === undefined) {
-        first = scanSiblingProperties(file, c);
-        c.firstSiblingProperties.set(file, first);
-    }
-    return first;
-}
-/**
- * By name, the first property of the unions of `file`'s object literals that leave the name missing.
- * Without a checker, as on a parse thread, array literals are taken to have the global Array type, and
- * the result is undefined where an enum the scan can't resolve decides which literals subtype reduction
- * leaves out (`enumKeyOfMemberAccess`); the checker then scans the file itself.
- */
-export function scanSiblingProperties(file, c) {
-    if (file.isDeclarationFile)
-        return new Map();
-    const scan = new SiblingPropertyScan(c);
-    file.forEachChild(scan);
-    scan.widenAll();
-    return scan.unresolved ? undefined : scan.members;
-}
-/** The first property of each name among the files of one of tsgo's checkers, scanned in order. */
-export class SlotSiblingProperties {
-    members = new Map();
-    /** The index of the file of each name's property. */
-    fileIndexes = new Map();
-    /** The index of the next file of the checker to scan. */
-    next;
-    constructor(first) {
-        this.next = first;
-    }
-}
-/** Whether an object literal is in an `as const` assertion, through arrays, spreads and properties. */
-function isInConstAssertion(literal) {
-    for (let node = literal; node.parent !== undefined; node = node.parent) {
-        switch (node.parent.kind) {
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
-            case 231 /* SyntaxKind.SpreadElement */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
-                continue;
-            case 235 /* SyntaxKind.AsExpression */:
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
-                return isConstTypeReference(getType(node.parent));
-        }
-        return false;
-    }
-    return false;
-}
-/** An expression whose type is widened, at the position where a checker widens it. */
-class WideningRoot {
-    position;
-    func;
-    alternatives;
-    sources;
-    calls;
-    constructor(position, 
-    /** The function whose returned expressions these are, widened once. */
-    func, 
-    /** The expressions whose types are unioned and widened. */
-    alternatives, 
-    /** The expressions whose calls, innermost first, infer their functions' return types before. */
-    sources, 
-    /** The calls of `sources` that may call a function of the file (`SiblingPropertyScan.callees`). */
-    calls = undefined) {
-        this.position = position;
-        this.func = func;
-        this.alternatives = alternatives;
-        this.sources = sources;
-        this.calls = calls;
-    }
-}
-/**
- * The unions a checker widens while checking the file's statements or the body of one deferred function, and
- * the deferred functions it queues there.
- */
-class CheckScope {
-    position;
-    roots = [];
-    deferred = [];
-    /** The calls by a name (`calleeName`), which infer where they end. */
-    calls = [];
-    constructor(position) {
-        this.position = position;
-    }
-}
-/**
- * Whether a checker checks `node`'s body only as a deferred node: a function expression, arrow
- * function or object literal method or accessor whose return type is written. Without one, the
- * checker infers the return type where it reaches the function, from the returned expressions and
- * what they refer to.
- */
-function isDeferredCheck(node) {
-    switch (node.kind) {
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
-            return getType(node) !== undefined;
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-            return node.parent?.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ && getType(node) !== undefined;
-        case 179 /* SyntaxKind.SetAccessor */:
-            return node.parent?.kind === 211 /* SyntaxKind.ObjectLiteralExpression */;
-    }
-    return false;
-}
-/**
- * Finds the unions of a file's object literals in the order a checker widens them: an initializer
- * where it is, and a function's returned expressions at its first `return`, where the checker
- * infers its return type. A call of a function of the file, by a name that resolves to it or as
- * `this.name(...)` in a class, infers that function's return type where the call is, and before the
- * union of the expression the call is in. The bodies of function expressions, arrow functions and
- * object literal methods and accessors with a written return type are checked after the file's
- * statements, so their unions widen then.
- */
-class SiblingPropertyScan extends NodeVisitor {
-    /** The checker that resolves imported enums, or undefined on a parse thread. */
-    c;
-    /** By name, the property of the first union that leaves the name missing in a literal. */
-    members = new Map();
-    /**
-     * Whether array literals have an array type, whose elements are widened as one union. Without the
-     * global Array type (--noLib) an array literal is an empty object type.
-     */
-    arrays;
-    /** Whether an enum the scan can't resolve without a checker decided which literals were left out. */
-    unresolved = false;
-    /** The enums of the members that values refer to, numbered in the order the scan meets them. */
-    enums = new Map();
-    fileScope = new CheckScope(0);
-    /** The scope of the innermost deferred function around the node being visited. */
-    scope = this.fileScope;
-    /** The returned expressions of each function without a return type. */
-    returned = new Map();
-    /** The names a call can call those functions by (`functionName`). */
-    callees = new Set();
-    widened = new Set();
-    /** The functions and methods of each class, by name. */
-    classFunctions = new Map();
-    constructor(c) {
-        super();
-        this.c = c;
-        this.arrays = c === undefined || c.globalArrayType !== c.emptyGenericType;
-    }
-    /** The key of the values that are members of `symbol`, an enum, in this scan. */
-    enumKey(symbol) {
-        let id = this.enums.get(symbol);
-        if (id === undefined) {
-            id = this.enums.size;
-            this.enums.set(symbol, id);
-        }
-        return 'enum ' + id;
-    }
-    visitNode(node) {
-        switch (node.kind) {
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */: {
-                const body = getBody(node);
-                if (body === undefined || getType(node) !== undefined)
-                    break;
-                const returned = [];
-                const sources = [];
-                let position = body.pos;
-                if (body.kind === 242 /* SyntaxKind.Block */) {
-                    const collector = new ReturnCollector();
-                    collector.visitStatements(body);
-                    if (collector.returns.length > 0)
-                        position = collector.returns[0].pos;
-                    for (const r of collector.returns)
-                        if (r.expression !== undefined) {
-                            addAlternatives(r.expression, returned, this.arrays);
-                            sources.push(r.expression);
-                        }
-                }
-                else {
-                    addAlternatives(body, returned, this.arrays);
-                    sources.push(body);
-                }
-                if (returned.length === 0)
-                    break;
-                const root = new WideningRoot(position, node, returned, sources);
-                this.returned.set(node, root);
-                this.addRoot(root);
-                if (node.kind === 175 /* SyntaxKind.MethodDeclaration */ || node.kind === 178 /* SyntaxKind.GetAccessor */)
-                    this.addClassFunction(node, node);
-                break;
-            }
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 170 /* SyntaxKind.Parameter */: {
-                const initializer = getInitializer(node);
-                if (initializer === undefined || getType(node) !== undefined)
-                    break;
-                this.addRoot(new WideningRoot(initializer.pos, undefined, addAlternatives(initializer, [], this.arrays), [initializer]));
-                const value = skipParentheses(initializer);
-                if (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
-                    (value.kind === 220 /* SyntaxKind.ArrowFunction */ || value.kind === 219 /* SyntaxKind.FunctionExpression */))
-                    this.addClassFunction(node, value);
-                break;
-            }
-            case 278 /* SyntaxKind.ExportAssignment */:
-                if (getType(node) === undefined) {
-                    const expression = getExpression(node);
-                    this.addRoot(new WideningRoot(node.pos, undefined, addAlternatives(expression, [], this.arrays), [expression]));
-                }
-                break;
-            case 251 /* SyntaxKind.ForOfStatement */: {
-                // The variable of `for (const x of e)` has the widened type of e's elements, and each element
-                // of a binding pattern the widened type of its part of them.
-                const statement = node;
-                if (statement.initializer.kind !== 262 /* SyntaxKind.VariableDeclarationList */)
-                    break;
-                const declaration = statement.initializer.declarations.nodes[0];
-                if (declaration === undefined || getType(declaration) !== undefined || !this.arrays)
-                    break;
-                const elements = [];
-                for (const array of iteratedArrayLiterals(statement.expression))
-                    addArrayElements(array, elements);
-                if (elements.length === 0)
-                    break;
-                for (const alternatives of bindingAlternatives(getName(declaration), elements))
-                    this.addRoot(new WideningRoot(statement.expression.pos, undefined, alternatives, [statement.expression]));
-                break;
-            }
-            case 214 /* SyntaxKind.CallExpression */: {
-                // The object of a method call is widened before the call is resolved.
-                const callee = skipParentheses(getExpression(node));
-                if ((callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || callee.kind === 213 /* SyntaxKind.ElementAccessExpression */) &&
-                    mayHoldLiterals(getExpression(callee)))
-                    this.addExpressionRoot(callee.pos, getExpression(callee));
-                // Calls elsewhere, as in statements, infer where they end.
-                if (calleeName(node) !== undefined)
-                    this.scope.calls.push(node);
-                break;
-            }
-        }
-        if (isTypeNodeKind(node.kind))
-            return false;
-        if ((node.kind === 235 /* SyntaxKind.AsExpression */ || node.kind === 217 /* SyntaxKind.TypeAssertionExpression */) &&
-            !isConstTypeReference(getType(node))) {
-            // An assertion widens its expression's type in a deferred check, queued after the expression's.
-            node.forEachChild(this);
-            const inner = new CheckScope(node.end);
-            this.scope.deferred.push(inner);
-            const saveScope = this.scope;
-            this.scope = inner;
-            this.addExpressionRoot(node.end, getExpression(node));
-            this.scope = saveScope;
-            return false;
-        }
-        if (isDeferredCheck(node)) {
-            const inner = new CheckScope(node.pos);
-            this.scope.deferred.push(inner);
-            const saveScope = this.scope;
-            this.scope = inner;
-            node.forEachChild(this);
-            this.scope = saveScope;
-        }
-        else
-            node.forEachChild(this);
-        return false;
-    }
-    addRoot(root) {
-        this.scope.roots.push(root);
-    }
-    /** Adds a root for the widened type of `expression` where it holds object or array literals. */
-    addExpressionRoot(position, expression) {
-        const alternatives = addAlternatives(expression, [], this.arrays);
-        if (alternatives.some((a) => a.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || a.kind === 210 /* SyntaxKind.ArrayLiteralExpression */))
-            this.addRoot(new WideningRoot(position, undefined, alternatives, [expression]));
-    }
-    /** Names `func` in its class by `member`, a method or a property it initializes. */
-    addClassFunction(member, func) {
-        const name = getName(member);
-        const parent = member.parent;
-        if (name === undefined || name.kind !== 79 /* SyntaxKind.Identifier */)
-            return;
-        if (parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ && parent.kind !== 232 /* SyntaxKind.ClassExpression */)
-            return;
-        let functions = this.classFunctions.get(parent);
-        if (functions === undefined)
-            this.classFunctions.set(parent, (functions = new Map()));
-        if (!functions.has(getText(name)))
-            functions.set(getText(name), func);
-    }
-    /**
-     * Widens the unions of the file's statements in order, then those of each deferred node in the
-     * order the checker queues them, which includes the deferred nodes queued while checking one.
-     */
-    widenAll() {
-        for (const func of this.returned.keys()) {
-            const name = functionName(func);
-            if (name !== undefined)
-                this.callees.add(name);
-        }
-        const queue = [this.fileScope];
-        for (let i = 0; i < queue.length; i++) {
-            const scope = queue[i];
-            if (this.callees.size !== 0)
-                for (const call of scope.calls)
-                    if (this.callees.has(calleeName(call)))
-                        scope.roots.push(new WideningRoot(call.end, undefined, [], [], [call]));
-            scope.roots.sort((a, b) => a.position - b.position);
-            scope.deferred.sort((a, b) => a.position - b.position);
-            let next = 0;
-            for (const root of scope.roots) {
-                while (next < scope.deferred.length && scope.deferred[next].position < root.position)
-                    queue.push(scope.deferred[next++]);
-                this.widenRoot(root);
-            }
-            while (next < scope.deferred.length)
-                queue.push(scope.deferred[next++]);
-        }
-    }
-    /** Widens a root's unions, after the returned expressions of the functions its calls infer. */
-    widenRoot(root) {
-        if (root.func !== undefined) {
-            if (this.widened.has(root.func))
-                return;
-            this.widened.add(root.func);
-        }
-        if (this.callees.size === 0) {
-            this.widen(root.alternatives, true);
-            return;
-        }
-        if (root.calls === undefined) {
-            const collector = new CallCollector(this.callees);
-            for (const source of root.sources)
-                collector.visitNode(source);
-            root.calls = collector.calls;
-        }
-        for (const call of root.calls) {
-            const callee = this.calledFunction(call);
-            const returned = callee !== undefined ? this.returned.get(callee) : undefined;
-            if (returned !== undefined)
-                this.widenRoot(returned);
-        }
-        this.widen(root.alternatives, true);
-    }
-    /**
-     * The function a call calls: a function declaration or a variable initialized with a function that
-     * the callee's name resolves to (`getLocals` of the scopes around the call), or a method or property
-     * of the class for `this.name(...)` in a class member.
-     */
-    calledFunction(call) {
-        const callee = skipParentheses(getExpression(call));
-        if (callee.kind === 79 /* SyntaxKind.Identifier */) {
-            const name = getText(callee);
-            for (let scope = call.parent; scope !== undefined; scope = scope.parent) {
-                const symbol = getLocals(scope)?.get(name);
-                // A type alias, interface or type parameter of the name doesn't hide a value of an outer scope.
-                if (symbol === undefined || (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) === 0)
-                    continue;
-                // An exported declaration's local symbol has no value declaration of its own.
-                const declaration = symbol.valueDeclaration ??
-                    symbol.declarations.find((d) => d.kind === 263 /* SyntaxKind.FunctionDeclaration */ || d.kind === 261 /* SyntaxKind.VariableDeclaration */);
-                if (declaration === undefined)
-                    return undefined;
-                if (declaration.kind === 263 /* SyntaxKind.FunctionDeclaration */)
-                    return declaration;
-                const initializer = declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ ? getInitializer(declaration) : undefined;
-                const value = initializer !== undefined ? skipParentheses(initializer) : undefined;
-                return value !== undefined &&
-                    (value.kind === 220 /* SyntaxKind.ArrowFunction */ || value.kind === 219 /* SyntaxKind.FunctionExpression */)
-                    ? value
-                    : undefined;
-            }
-            return undefined;
-        }
-        if (callee.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ || getExpression(callee).kind !== 109 /* SyntaxKind.ThisKeyword */)
-            return undefined;
-        const name = getName(callee);
-        const container = thisClass(call);
-        const functions = container !== undefined ? this.classFunctions.get(container) : undefined;
-        return functions !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ ? functions.get(getText(name)) : undefined;
-    }
-    /**
-     * Records the unions of the alternatives of one widened expression, and of their nested values.
-     * With `reduced`, the alternatives make up one union with subtype reduction (the alternatives of an
-     * expression, the elements of an array literal), which drops a literal whose widened type is the
-     * type of an earlier one (`removeSubtypes` removes the later of two identical types). The values of
-     * a property across literals are not reduced: their union is one of each literal's value.
-     */
-    widen(alternatives, reduced) {
-        let literals = [];
-        for (const a of alternatives)
-            if (a.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
-                literals.push(a);
-            // The elements of a tuple, an array literal in an `as const` assertion, widen separately.
-            else if (this.arrays && a.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && !isInConstAssertion(a))
-                this.widen(addArrayElements(a, []), true);
-        if (literals.length === 0)
-            return;
-        if (reduced)
-            literals = withoutRepeatedLiterals(this, literals);
-        if (literals.length > 1)
-            this.record(literals);
-        const values = new Map();
-        for (const literal of literals)
-            for (const member of literal.properties.nodes) {
-                if (member.kind !== 303 /* SyntaxKind.PropertyAssignment */)
-                    continue;
-                const name = staticPropertyName(member);
-                if (name === undefined)
-                    continue;
-                let list = values.get(name);
-                if (list === undefined)
-                    values.set(name, (list = []));
-                // A value's own alternatives make up one reduced union, one member of the property's values.
-                const own = addAlternatives(member.initializer, [], this.arrays);
-                for (const value of withoutRepeatedLiterals(this, own))
-                    list.push(value);
-            }
-        for (const list of values.values())
-            this.widen(list, false);
-    }
-    /**
-     * Records, for each name that some literal without a spread lacks, the last such literal's property
-     * of that name, unless an earlier union has the name.
-     */
-    record(literals) {
-        const plain = [];
-        for (const literal of literals) {
-            let members = new Map();
-            for (const member of literal.properties.nodes) {
-                if (member.kind === 305 /* SyntaxKind.SpreadAssignment */) {
-                    members = undefined;
-                    break;
-                }
-                const name = staticPropertyName(member);
-                if (name !== undefined)
-                    members.set(name, member);
-            }
-            if (members !== undefined)
-                plain.push(members);
-        }
-        const last = new Map();
-        for (const members of plain)
-            for (const [name, member] of members)
-                last.set(name, member);
-        for (const [name, member] of last) {
-            // A method's or accessor's symbol has other flags than the property checkObjectLiteral makes of it.
-            if (member.kind !== 303 /* SyntaxKind.PropertyAssignment */ && member.kind !== 304 /* SyntaxKind.ShorthandPropertyAssignment */)
-                continue;
-            if (this.members.has(name) || plain.every((members) => members.has(name)))
-                continue;
-            this.members.set(name, member);
-        }
-    }
-}
-/**
- * `nodes` without the object literals whose widened types are certainly those of an earlier one:
- * the same property names, each with a value of the same widened type (`widenedTypeKey`). Literals
- * that can have a contextual type are kept: it can keep their properties' literal types.
- */
-function withoutRepeatedLiterals(scan, nodes) {
-    let keys;
-    let result;
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        const key = node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ && !mayHaveContextualType(node)
-            ? widenedTypeKey(scan, node)
-            : undefined;
-        if (key !== undefined) {
-            if (keys === undefined)
-                keys = [];
-            else if (keys.includes(key)) {
-                // Without a checker, an enum the scan can't resolve may or may not make the types the same.
-                if (key.includes(pendingEnumKey))
-                    scan.unresolved = true;
-                if (result === undefined)
-                    result = nodes.slice(0, i);
-                continue;
-            }
-            keys.push(key);
-        }
-        result?.push(node);
-    }
-    return result ?? nodes;
-}
-/**
- * A key that two expressions of one file share only when their types widen to the same type, or
- * undefined where that isn't known from the syntax: literals by their widened type, members of an
- * enum by the enum, and object literals by their properties' names and keys. Other references can
- * name different symbols or be narrowed differently.
- */
-function widenedTypeKey(scan, node) {
-    switch (node.kind) {
-        case 10 /* SyntaxKind.StringLiteral */:
-        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
-            return 'string';
-        case 8 /* SyntaxKind.NumericLiteral */:
-            return 'number';
-        case 9 /* SyntaxKind.BigIntLiteral */:
-            return 'bigint';
-        case 111 /* SyntaxKind.TrueKeyword */:
-        case 96 /* SyntaxKind.FalseKeyword */:
-            return 'boolean';
-        case 13 /* SyntaxKind.RegularExpressionLiteral */:
-            return 'RegExp';
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
-            const unary = node;
-            const operand = unary.operand.kind;
-            if (unary.operator === 40 /* SyntaxKind.MinusToken */ || unary.operator === 39 /* SyntaxKind.PlusToken */) {
-                if (operand === 8 /* SyntaxKind.NumericLiteral */)
-                    return 'number';
-                if (operand === 9 /* SyntaxKind.BigIntLiteral */ && unary.operator === 40 /* SyntaxKind.MinusToken */)
-                    return 'bigint';
-            }
-            return undefined;
-        }
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-            return enumKeyOfMemberAccess(scan, node);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */: {
-            const members = [];
-            for (const member of node.properties.nodes) {
-                if (member.kind !== 303 /* SyntaxKind.PropertyAssignment */)
-                    return undefined;
-                const name = staticPropertyName(member);
-                const value = widenedTypeKey(scan, member.initializer);
-                if (name === undefined || value === undefined)
-                    return undefined;
-                members.push(JSON.stringify(name) + ': ' + value);
-            }
-            members.sort();
-            return '{' + members.join(', ') + '}';
-        }
-    }
-    return undefined;
-}
-/** The key of a member of an enum that the scan can't resolve without a checker. */
-const pendingEnumKey = 'enum ?';
-/**
- * The key of `E.Member` where `E` names an enum in the scopes around the access (`getLocals`, as
- * `calledFunction` finds names) and `Member` is one of its members, not an export of a namespace merged
- * with it: the key of the enum. With a checker, `E` can be imported. Without one, an import, and a
- * global of a script file (whose enum other files can extend), give `pendingEnumKey`.
- */
-function enumKeyOfMemberAccess(scan, node) {
-    const target = getExpression(node);
-    const member = getName(node);
-    if (target.kind !== 79 /* SyntaxKind.Identifier */ || member.kind !== 79 /* SyntaxKind.Identifier */)
-        return undefined;
-    const name = getText(target);
-    const c = scan.c;
-    for (let scope = node.parent; scope !== undefined; scope = scope.parent) {
-        let symbol = getLocals(scope)?.get(name);
-        if (symbol === undefined ||
-            (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */)) === 0)
-            continue;
-        if (c === undefined) {
-            if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
-                return pendingEnumKey;
-            if ((symbol.flags & (384 /* SymbolFlags.Enum */ | 1536 /* SymbolFlags.Module */)) !== 0 &&
-                !isExternalModule(getSourceFileOfNode(node)))
-                return pendingEnumKey;
-        }
-        if (symbol.exportSymbol !== undefined)
-            symbol = symbol.exportSymbol;
-        if (c !== undefined) {
-            symbol = getMergedSymbol(c, symbol);
-            if ((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
-                symbol = resolveAlias(c, symbol);
-        }
-        if ((symbol.flags & 384 /* SymbolFlags.Enum */) === 0)
-            return undefined;
-        // An enum merged with a namespace also exports the namespace's values.
-        const memberSymbol = symbol.exports?.get(getText(member));
-        return memberSymbol !== undefined && (memberSymbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0
-            ? scan.enumKey(symbol)
-            : undefined;
-    }
-    return undefined;
-}
-/**
- * Whether an object literal of a widened expression can have a contextual type: under `satisfies`,
- * an assertion or an argument, as a parameter's default, or returned from a function that can have
- * a contextual signature (a function expression that doesn't initialize an untyped declaration, or a
- * method of an object literal). Initializers of untyped declarations, the returns of function
- * declarations and class members, and the objects of property and element accesses have none.
- */
-function mayHaveContextualType(node) {
-    for (let current = node.parent; current !== undefined; current = current.parent) {
-        switch (current.kind) {
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
-            case 236 /* SyntaxKind.NonNullExpression */:
-            case 224 /* SyntaxKind.AwaitExpression */:
-            case 228 /* SyntaxKind.ConditionalExpression */:
-            case 227 /* SyntaxKind.BinaryExpression */:
-            case 210 /* SyntaxKind.ArrayLiteralExpression */:
-            case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 254 /* SyntaxKind.ReturnStatement */:
-            case 242 /* SyntaxKind.Block */:
-            case 246 /* SyntaxKind.IfStatement */:
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
-            case 249 /* SyntaxKind.ForStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 256 /* SyntaxKind.SwitchStatement */:
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 297 /* SyntaxKind.CaseClause */:
-            case 298 /* SyntaxKind.DefaultClause */:
-            case 257 /* SyntaxKind.LabeledStatement */:
-            case 259 /* SyntaxKind.TryStatement */:
-            case 300 /* SyntaxKind.CatchClause */:
-                continue;
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 278 /* SyntaxKind.ExportAssignment */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            // The object of a property access, as in a method call, has no contextual type.
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
-            case 213 /* SyntaxKind.ElementAccessExpression */:
-                return false;
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */: {
-                const parent = current.parent.kind;
-                return parent !== 264 /* SyntaxKind.ClassDeclaration */ && parent !== 232 /* SyntaxKind.ClassExpression */;
-            }
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 219 /* SyntaxKind.FunctionExpression */: {
-                let outer = current.parent;
-                while (outer.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
-                    outer = outer.parent;
-                return ((outer.kind !== 261 /* SyntaxKind.VariableDeclaration */ && outer.kind !== 173 /* SyntaxKind.PropertyDeclaration */) ||
-                    getType(outer) !== undefined);
-            }
-            default:
-                return true;
-        }
-    }
-    return true;
-}
-/** Collects the calls by one of `names` in an expression, innermost first, outside the functions in it. */
-class CallCollector extends NodeVisitor {
-    names;
-    calls = [];
-    constructor(names) {
-        super();
-        this.names = names;
-    }
-    visitNode(node) {
-        if (isFunctionLike(node) || node.kind === 232 /* SyntaxKind.ClassExpression */)
-            return false;
-        node.forEachChild(this);
-        if (node.kind === 214 /* SyntaxKind.CallExpression */) {
-            const name = calleeName(node);
-            if (name !== undefined && this.names.has(name))
-                this.calls.push(node);
-        }
-        return false;
-    }
-}
-/** The name a call calls its function by, `f` in `f(...)` and `this.f(...)`, if the scan can resolve it. */
-function calleeName(call) {
-    const callee = skipParentheses(getExpression(call));
-    if (callee.kind === 79 /* SyntaxKind.Identifier */)
-        return getText(callee);
-    if (callee.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ || getExpression(callee).kind !== 109 /* SyntaxKind.ThisKeyword */)
-        return undefined;
-    const name = getName(callee);
-    return name.kind === 79 /* SyntaxKind.Identifier */ ? getText(name) : undefined;
-}
-/**
- * The name calls can call a function without a return type by: a function declaration's, a method's or
- * accessor's, or that of the variable or property a function expression initializes.
- */
-function functionName(func) {
-    let node = func;
-    if (func.kind === 219 /* SyntaxKind.FunctionExpression */ || func.kind === 220 /* SyntaxKind.ArrowFunction */) {
-        while (node.parent?.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
-            node = node.parent;
-        if (node.parent?.kind !== 261 /* SyntaxKind.VariableDeclaration */ && node.parent?.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
-            return undefined;
-        node = node.parent;
-    }
-    const name = getName(node);
-    return name?.kind === 79 /* SyntaxKind.Identifier */ ? getText(name) : undefined;
-}
-/** Whether an expression's alternatives (`addAlternatives`) can hold object or array literals. */
-function mayHoldLiterals(node) {
-    switch (skipParentheses(node).kind) {
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 228 /* SyntaxKind.ConditionalExpression */:
-        case 227 /* SyntaxKind.BinaryExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-            return true;
-    }
-    return false;
-}
-/** The class whose instance `this` is at `node`, through arrow functions, in a member or property initializer. */
-function thisClass(node) {
-    for (let current = node.parent; current !== undefined; current = current.parent) {
-        if (current.kind === 220 /* SyntaxKind.ArrowFunction */)
-            continue;
-        if (current.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-            current.kind === 178 /* SyntaxKind.GetAccessor */ ||
-            current.kind === 179 /* SyntaxKind.SetAccessor */ ||
-            current.kind === 177 /* SyntaxKind.Constructor */ ||
-            current.kind === 173 /* SyntaxKind.PropertyDeclaration */) {
-            const parent = current.parent;
-            return parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.kind === 232 /* SyntaxKind.ClassExpression */
-                ? parent
-                : undefined;
-        }
-        if (isFunctionLike(current) || current.kind === 307 /* SyntaxKind.SourceFile */)
-            return undefined;
-    }
-    return undefined;
-}
-/**
- * Adds the expressions whose types make up the type of `node`: both sides of `?:`, `||` and `??`,
- * and the elements of an array literal that `node` indexes when `arrays` (see SiblingPropertyScan).
- */
-function addAlternatives(node, out, arrays) {
-    switch (node.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
-        case 239 /* SyntaxKind.SatisfiesExpression */:
-        case 224 /* SyntaxKind.AwaitExpression */:
-            return addAlternatives(getExpression(node), out, arrays);
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-            // An object literal in an `as const` assertion is still an object literal type, with readonly
-            // properties; an array literal in one is a tuple, whose elements widen separately.
-            if (isConstAssertion(node) && skipParentheses(getExpression(node)).kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
-                return addAlternatives(getExpression(node), out, arrays);
-            break;
-        case 228 /* SyntaxKind.ConditionalExpression */:
-            addAlternatives(node.whenTrue, out, arrays);
-            return addAlternatives(node.whenFalse, out, arrays);
-        case 227 /* SyntaxKind.BinaryExpression */: {
-            const binary = node;
-            switch (binary.operatorToken.kind) {
-                case 56 /* SyntaxKind.BarBarToken */:
-                case 60 /* SyntaxKind.QuestionQuestionToken */:
-                    addAlternatives(binary.left, out, arrays);
-                    return addAlternatives(binary.right, out, arrays);
-                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
-                case 27 /* SyntaxKind.CommaToken */:
-                    return addAlternatives(binary.right, out, arrays);
-            }
-            break;
-        }
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
-            // `[a, b][i]` has the type of the array's elements, which the declaration widens as one union.
-            const array = skipParentheses(getExpression(node));
-            if (!arrays || array.kind !== 210 /* SyntaxKind.ArrayLiteralExpression */)
-                break;
-            for (const e of array.elements.nodes)
-                if (e.kind !== 231 /* SyntaxKind.SpreadElement */)
-                    addAlternatives(e, out, arrays);
-            return out;
-        }
-    }
-    out.push(node);
-    return out;
-}
-/**
- * The alternatives of the elements of an array literal, whose types make its element type, with those
- * of the array literals that its spread elements spread. Used where array literals have an array type
- * (`SiblingPropertyScan.arrays`), as are `iteratedArrayLiterals` and `bindingAlternatives`.
- */
-function addArrayElements(array, out) {
-    for (const e of array.elements.nodes)
-        if (e.kind !== 231 /* SyntaxKind.SpreadElement */)
-            addAlternatives(e, out, true);
-        else
-            for (const spread of addAlternatives(getExpression(e), [], true))
-                if (spread.kind === 210 /* SyntaxKind.ArrayLiteralExpression */)
-                    addArrayElements(spread, out);
-    return out;
-}
-/** The array literals whose elements a `for...of` over `expression` iterates, through `as const`. */
-function iteratedArrayLiterals(expression) {
-    const arrays = [];
-    for (const a of addAlternatives(expression, [], true)) {
-        const value = isConstAssertion(a) ? skipParentheses(getExpression(a)) : a;
-        if (value.kind === 210 /* SyntaxKind.ArrayLiteralExpression */)
-            arrays.push(value);
-    }
-    return arrays;
-}
-function isConstAssertion(node) {
-    return ((node.kind === 235 /* SyntaxKind.AsExpression */ || node.kind === 217 /* SyntaxKind.TypeAssertionExpression */) &&
-        isConstTypeReference(getType(node)));
-}
-/**
- * The alternatives whose union each variable of a binding name is widened from, given the alternatives
- * of the iterated elements: all of them for an identifier; for an element of an array pattern, its
- * element of each `as const` array literal, or every element of another array literal; for an element
- * of an object pattern, the values of its property in each object literal.
- */
-function bindingAlternatives(name, elements) {
-    if (name.kind === 79 /* SyntaxKind.Identifier */)
-        return [elements];
-    const result = [];
-    const isArrayPattern = name.kind === 208 /* SyntaxKind.ArrayBindingPattern */;
-    const bindings = name.elements.nodes;
-    for (let k = 0; k < bindings.length; k++) {
-        const binding = bindings[k];
-        if (binding.kind !== 209 /* SyntaxKind.BindingElement */)
-            continue;
-        const element = binding;
-        if (element.dotDotDotToken !== undefined || element.initializer !== undefined)
-            continue;
-        if (element.name?.kind !== 79 /* SyntaxKind.Identifier */)
-            continue;
-        const alternatives = [];
-        if (isArrayPattern) {
-            for (const e of elements) {
-                const value = isConstAssertion(e) ? skipParentheses(getExpression(e)) : e;
-                if (value.kind !== 210 /* SyntaxKind.ArrayLiteralExpression */)
-                    continue;
-                const array = value;
-                if (value !== e || isInConstAssertion(array)) {
-                    const item = array.elements.nodes[k];
-                    if (item !== undefined && item.kind !== 231 /* SyntaxKind.SpreadElement */)
-                        addAlternatives(item, alternatives, true);
-                }
-                else
-                    addArrayElements(array, alternatives);
-            }
-        }
-        else {
-            const property = element.propertyName ?? element.name;
-            const propertyName = property.kind === 79 /* SyntaxKind.Identifier */ ? getText(property) : undefined;
-            if (propertyName === undefined)
-                continue;
-            for (const e of elements) {
-                if (e.kind !== 211 /* SyntaxKind.ObjectLiteralExpression */)
-                    continue;
-                for (const member of e.properties.nodes)
-                    if (member.kind === 303 /* SyntaxKind.PropertyAssignment */ && staticPropertyName(member) === propertyName)
-                        addAlternatives(member.initializer, alternatives, true);
-            }
-        }
-        if (alternatives.length !== 0)
-            result.push(alternatives);
-    }
-    return result;
-}
-/** The name of an object literal member with a literal name. */
-function staticPropertyName(member) {
-    switch (member.kind) {
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-            break;
-        default:
-            return undefined;
-    }
-    const name = getName(member);
-    switch (name.kind) {
-        case 79 /* SyntaxKind.Identifier */:
-        case 10 /* SyntaxKind.StringLiteral */:
-        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-            return getText(name);
-        case 8 /* SyntaxKind.NumericLiteral */:
-            return String(Number(getText(name)));
-    }
-    return undefined;
-}
 function getPropertiesOfContext(c, context) {
     if (context.resolvedProperties === undefined) {
         const names = new Map();
@@ -1678,7 +748,7 @@ export function isReadonlySymbol(c, symbol) {
             (getDeclarationNodeFlagsFromSymbol(symbol) & 6 /* NodeFlags.Constant */) !== 0) ||
         ((symbol.flags & 98304 /* SymbolFlags.Accessor */) !== 0 && (symbol.flags & 65536 /* SymbolFlags.SetAccessor */) === 0) ||
         (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ||
-        someReadonlyAssignmentDeclaration(c, symbol.declarations));
+        someReadonlyAssignmentDeclaration(c, getDeclarations(symbol)));
 }
 function someReadonlyAssignmentDeclaration(c, declarations) {
     for (const d of declarations)
@@ -1709,7 +779,7 @@ function isReadonlyAssignmentDeclaration(c, node) {
 import { getDeclarationModifierFlagsFromSymbol, getPropertyOfType, getTypeOfPropertyOfType, } from './checker-members.js';
 import { checkExpression } from './checker-expressions.js';
 import { getParameterTypeOfFullSignature } from './checker-jsdoc.js';
-import { isFunctionLike, isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
+import { isFunctionLikeDeclarationKind, isInJSFile } from './ast-utilities.js';
 import { isEmptyArrayLiteralType } from './relations.js';
 import { isCheckJsEnabledForFile } from './program-utilities.js';
 function getDeclarationModifierFlags(c, symbol) {
@@ -1738,7 +808,7 @@ function getAnnotatedAccessorType(c, accessor) {
 }
 /** The `accessor` property declaration of `symbol`, if any. */
 function getAutoAccessorDeclaration(symbol) {
-    for (const d of symbol.declarations)
+    for (const d of getDeclarations(symbol))
         if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && (getCombinedModifierFlags(d) & 512 /* ModifierFlags.Accessor */) !== 0)
             return d;
     return undefined;
@@ -1750,8 +820,8 @@ function getTypeOfAccessors(c, symbol) {
         return type;
     if (!pushTypeResolution(c, symbol, 0 /* TypeSystemPropertyName.Type */))
         return c.errorType;
-    const getter = symbol.declarations.find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */);
-    const setter = symbol.declarations.find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
+    const getter = getDeclarations(symbol).find((d) => d.kind === 178 /* SyntaxKind.GetAccessor */);
+    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */);
     const accessor = getAutoAccessorDeclaration(symbol);
     // Getter annotation, setter annotation, accessor annotation, then getter body.
     let t = getAnnotatedAccessorType(c, getter) ?? getAnnotatedAccessorType(c, setter) ?? getAnnotatedAccessorType(c, accessor);
@@ -1788,7 +858,7 @@ export function getWriteTypeOfAccessors(c, symbol) {
         return links.writeType;
     if (!pushTypeResolution(c, symbol, 7 /* TypeSystemPropertyName.WriteType */))
         return c.errorType;
-    const setter = symbol.declarations.find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */) ?? getAutoAccessorDeclaration(symbol);
+    const setter = getDeclarations(symbol).find((d) => d.kind === 179 /* SyntaxKind.SetAccessor */) ?? getAutoAccessorDeclaration(symbol);
     let writeType = getAnnotatedAccessorType(c, setter);
     if (!popTypeResolution(c)) {
         if (getAnnotatedAccessorTypeNode(setter) !== undefined)