tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,2797 @@
+// Control flow analysis: the type of a reference at a position, walking the binder's flow graph
+// backwards from the reference through assignments, conditions, calls and labels.
+import { sideOf } from './side-state.js';
+import { getName, getExpression, getFlowNode, getInitializer, getText, NodeVisitor, getArguments, getDotDotDotToken, getParameters, getElements, getType, getStatements, } from './ast.js';
+import { cachedTypeKey, cachedTypePairKey, } from './checker-types.js';
+import { getSymbolId } from './symbol.js';
+import { getNodeId } from './ast.js';
+import { getAdjustedTypeWithFacts, getNonNullableType, getTypeFacts, getTypeWithFacts, hasTypeFacts, } from './checker-flow.js';
+import { everyType, filterType, getBaseTypeOfLiteralType, getFreshTypeOfLiteralType, getIntersectionType, getRegularTypeOfLiteralType, getUnionType, getUnionTypeEx, getWidenedLiteralType, isEmptyAnonymousObjectType, isFreshLiteralType, isLiteralType, isPatternLiteralType, isUnitType, mapType, removeType, someType, typesOf, containsMissingType, getNumberLiteralType, createArrayType, isTupleType, newObjectType, } from './checker-type-factory.js';
+import { areTypesComparable, isDiscriminantProperty, isTypeAssignableTo, isTypeDerivedFrom, isTypeRelatedTo, isTypeStrictSubtypeOf, isTypeSubsetOf, isTypeSubtypeOf, } from './relations.js';
+import { checkExpression, checkExpressionCached, checkExpressionEx, checkNonNullExpression, checkNonNullType, getNarrowableTypeForReference, someTypeIsGenericWithUnionConstraint, getResolvedSymbol, getTypeOfExpression, isThisInTypeQuery, isTupleLikeType, } from './checker-expressions.js';
+import { isBlockScopedNameDeclaredBeforeUse } from './checker-declaration-order.js';
+import { getContextualSignature, getInferenceContext, isContextSensitiveFunctionOrObjectLiteralMethod, } from './checker-contextual.js';
+import { instantiateType } from './instantiation.js';
+import { checkIteratedTypeOrElementType } from './checker-iteration.js';
+import { checkSuperExpression } from './checker-super.js';
+import { getSymbolNameForPrivateIdentifier } from './binder.js';
+import { isTypeAssignableToKindEx } from './checker-type-operators.js';
+import { getRegularTypeOfObjectLiteral } from './checker-literals.js';
+import { checkRightHandSideOfForOf } from './checker-statements.js';
+import { getApparentType, getApplicableIndexInfoForName, getBaseConstraintOfType, getPropertiesOfType, getPropertyOfType, getReducedApparentType, getSignaturesOfType, getTypeOfPropertyOfType, mapToBaseConstraintOrType, } from './checker-members.js';
+import { getAssignmentTarget, isAssignmentTarget, isPushOrUnshiftIdentifier, getCombinedModifierFlags, hasStaticModifier, getCombinedNodeFlags, getImmediatelyInvokedFunctionExpression, getRootDeclaration, getThisContainer, isAssignmentExpression, isClassLike, isEntityNameExpression, isObjectLiteralMethod, isExpressionOfOptionalChainRoot, isGlobalSourceFile, isLogicalOrCoalescingAssignmentOperator, isOptionalChain, isStatic, skipParentheses, getRangeOfTokenAtPosition, getSourceFileOfNode, } from './binder-utilities.js';
+import { getDeclaredTypeOfSymbol, isConstructorType } from './checker-declared-types.js';
+import { getErasedSignature, getReturnTypeFromAnnotation, getReturnTypeOfSignature, getSignatureFromDeclaration, getTypePredicateOfSignature, } from './checker-signatures.js';
+import { getExportSymbolOfValueSymbolIfExported, getSymbolOfDeclaration, resolveEntityName, resolveSymbol, getGlobalTypeAliasSymbol, } from './checker-symbols.js';
+import { getOptionalType, getTypeOfSymbol, isReadonlySymbol } from './checker-symbol-types.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
+import { getTypeFromTypeNode, getTypeAliasInstantiation } from './checker-type-nodes.js';
+import { isFunctionLike, isInJSFile } from './ast-utilities.js';
+import { Diagnostic } from './diagnostics.js';
+import { getOptionalExpressionType, getResolvedSignature } from './checker-calls.js';
+import { getSymbolHasInstanceMethodOfObjectType } from './checker-operators.js';
+import { getSymbolForPrivateIdentifierExpression } from './checker-property-access.js';
+import { getIndexedAccessType, getLiteralTypeFromPropertyName, getTupleElementTypeOutOfStartCount, } from './checker-type-operators.js';
+import { getBindingElementTypeFromParentType, getNonUndefinedType, getTypeForBindingElementParent, } from './checker-destructuring.js';
+/**
+ * The number of shared nodes a walk caches before it indexes them. A walk through many consecutive
+ * conditions on one reference caches a node for each, and searching them all for each node made
+ * such walks cubic in the number of conditions. A walk's own entries stay in the cache until it
+ * ends, so a walk with at least this many is indexed.
+ */
+const sharedFlowIndexThreshold = 128;
+/** Indexes the entries of walk `f` in the shared flow cache by their first occurrence. */
+function indexSharedFlows(c, f, walkDepth) {
+    while (c.sharedFlowIndexes.length <= walkDepth)
+        c.sharedFlowIndexes.push(new Map());
+    const index = c.sharedFlowIndexes[walkDepth];
+    index.clear();
+    for (let i = f.sharedFlowStart; i < c.sharedFlowCount; i++) {
+        const node = c.sharedFlowNodes[i];
+        if (!index.has(node))
+            index.set(node, i);
+    }
+}
+/** The state of one `getFlowTypeOfReference` walk. `incomplete` describes the last returned type. */
+export class FlowState {
+    reference;
+    declaredType;
+    initialType;
+    flowContainer;
+    refKey = undefined;
+    depth = 0;
+    sharedFlowStart = 0;
+    incomplete = false;
+    /** The flow nodes visited, and the deepest nesting of the walk. */
+    steps = 0;
+    maxDepth = 0;
+    /** Whether this walk may be kept and end on a kept one (`FlowWalk`), and whether it looked one up. */
+    keepsWalk = false;
+    lookedUp = false;
+    /** The reference's last long walk, which this walk may end on. */
+    walk = undefined;
+    /** The node where this walk would be kept from: see `flowWalkAnchorSteps`. */
+    anchor = undefined;
+    /** Whether the result depends on where the reference is, not only on its key. */
+    positional = false;
+    constructor(reference, declaredType, initialType, flowContainer) {
+        this.reference = reference;
+        this.declaredType = declaredType;
+        this.initialType = initialType;
+        this.flowContainer = flowContainer;
+    }
+    /** Prepares a free flow state for another walk. */
+    reset(reference, declaredType, initialType, flowContainer) {
+        this.reference = reference;
+        this.declaredType = declaredType;
+        this.initialType = initialType;
+        this.flowContainer = flowContainer;
+        this.refKey = undefined;
+        this.depth = 0;
+        this.sharedFlowStart = 0;
+        this.incomplete = false;
+        this.steps = 0;
+        this.maxDepth = 0;
+        this.keepsWalk = false;
+        this.lookedUp = false;
+        this.walk = undefined;
+        this.anchor = undefined;
+        this.positional = false;
+    }
+}
+/**
+ * A node of a reference's last long walk, and the walk's result. Without loops or reduce labels in
+ * effect, the type of a reference at a flow node doesn't change, so a later walk that reaches `start`
+ * ends there. In a long list of top-level declarations, each reference otherwise walks back over
+ * every one before it.
+ */
+export class FlowWalk {
+    start;
+    type;
+    /** The deepest nesting of a walk from `start`, which reaches the depth limit the same way. */
+    depth;
+    constructor(start, type, depth) {
+        this.start = start;
+        this.type = type;
+        this.depth = depth;
+    }
+}
+/** Walks shorter than this aren't kept. */
+const minFlowWalkSteps = 32;
+/**
+ * The step of a frame of a walk at which the walk looks up the reference's kept walk; in the first
+ * frame, also the node it would be kept from. Every node a frame passes before the last one leaves
+ * the type unchanged, so the type there is the walk's result. Shorter walks don't compute the
+ * reference's key. A later walk that passes this walk's start reaches the node after this many steps
+ * or more, once it has looked.
+ */
+const flowWalkAnchorSteps = 16;
+/**
+ * Whether `node` is an identifier, `this`, or property and element accesses on one. Walks of such
+ * references with the same key (`getFlowReferenceKey`) go the same way; with parentheses or a
+ * non-null assertion in between, a reference has the key of the one without, but not its walk.
+ */
+function isDottedReference(node) {
+    let n = node;
+    for (;;) {
+        switch (n.kind) {
+            case 79 /* SyntaxKind.Identifier */:
+                return !isThisInTypeQuery(n);
+            case 109 /* SyntaxKind.ThisKeyword */:
+                return true;
+            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.ElementAccessExpression */:
+                n = getExpression(n);
+                break;
+            default:
+                return false;
+        }
+    }
+}
+/**
+ * Whether an element access in `node` names a property with a character that keys use as a
+ * separator (`.`, `@`, `#`). Its key can then be another reference's, as `o["a.b"]` has the key of
+ * `o.a.b`, so its walks aren't kept.
+ */
+function hasKeyCharacterInName(c, node) {
+    let n = node;
+    while (n.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || n.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+        if (n.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+            const name = getAccessedPropertyName(c, n);
+            if (name !== undefined && /[.@#]/.test(name))
+                return true;
+        }
+        n = getExpression(n);
+    }
+    return false;
+}
+/** A loop junction being analyzed for a reference, with the types seen on its paths so far. */
+export class FlowLoopInfo {
+    flow;
+    refKey;
+    types;
+    constructor(flow, refKey, types) {
+        this.flow = flow;
+        this.refKey = refKey;
+        this.types = types;
+    }
+}
+/** The type of `reference` at its flow position, narrowed from `declaredType` starting at `initialType`. */
+export function getFlowTypeOfReference(c, reference, declaredType, initialType, flowContainer) {
+    return getFlowTypeOfReferenceAt(c, reference, declaredType, initialType, flowContainer, getFlowNode(reference));
+}
+/** `getFlowTypeOfReference` at `flowNode`, for pseudo-references such as binding patterns. */
+export function getFlowTypeOfReferenceAt(c, reference, declaredType, initialType, flowContainer, flowNode) {
+    if (c.flowAnalysisDisabled)
+        return c.errorType;
+    if (flowNode === undefined)
+        return declaredType;
+    let f;
+    const stateDepth = c.flowStateDepth;
+    if (stateDepth < c.flowStates.length) {
+        f = c.flowStates[stateDepth];
+        f.reset(reference, declaredType, initialType, flowContainer);
+    }
+    else {
+        f = new FlowState(reference, declaredType, initialType, flowContainer);
+        c.flowStates.push(f);
+    }
+    c.flowStateDepth = stateDepth + 1;
+    f.sharedFlowStart = c.sharedFlowCount;
+    c.flowInvocationCount++;
+    f.keepsWalk =
+        c.flowLoopStack.length === 0 &&
+            c.flowReduceLabels.length === 0 &&
+            c.inlineLevel === 0 &&
+            isDottedReference(reference);
+    const cycles = c.resolutionCycleCount;
+    const evolvedType = getTypeAtFlowNode(c, f, flowNode);
+    const anchor = f.anchor;
+    if (anchor !== undefined &&
+        f.steps >= minFlowWalkSteps &&
+        !f.incomplete &&
+        !f.positional &&
+        !c.flowAnalysisDisabled &&
+        c.resolutionCycleCount === cycles) {
+        const walk = f.walk;
+        if (walk !== undefined) {
+            walk.start = anchor;
+            walk.type = evolvedType;
+            walk.depth = f.maxDepth;
+        }
+        else
+            c.flowWalks.set(f.refKey, new FlowWalk(anchor, evolvedType, f.maxDepth));
+    }
+    c.sharedFlowCount = f.sharedFlowStart;
+    c.flowStateDepth = stateDepth;
+    // `x` in `x.length`, `x.push(v)`, `x.unshift(v)` or `x[n] = v` stays `any[]` so empty arrays may be
+    // operated on and new element types inferred without implicit any or mismatch errors.
+    const resultType = (evolvedType.objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0 && isEvolvingArrayOperationTarget(c, reference)
+        ? c.autoArrayType
+        : finalizeEvolvingArrayType(c, evolvedType);
+    if (resultType === c.unreachableNeverType ||
+        (reference.parent !== undefined &&
+            reference.parent.kind === 236 /* SyntaxKind.NonNullExpression */ &&
+            (resultType.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            (getTypeWithFacts(c, resultType, 2097152 /* TypeFacts.NEUndefinedOrNull */).flags & 262144 /* TypeFlags.Never */) !== 0))
+        return declaredType;
+    return resultType;
+}
+function newFlowType(c, f, t, incomplete) {
+    f.incomplete = incomplete;
+    return incomplete && (t.flags & 262144 /* TypeFlags.Never */) !== 0 ? c.silentNeverType : t;
+}
+function complete(f, t) {
+    f.incomplete = false;
+    return t;
+}
+export function getTypeAtFlowNode(c, f, start) {
+    if (f.depth === 2000) {
+        c.flowAnalysisDisabled = true;
+        reportFlowControlError(c, f.reference);
+        return complete(f, c.errorType);
+    }
+    f.depth++;
+    if (f.depth > f.maxDepth)
+        f.maxDepth = f.depth;
+    let flow = start;
+    let sharedFlow = undefined;
+    let frameSteps = 0;
+    for (;;) {
+        f.steps++;
+        if (++frameSteps === flowWalkAnchorSteps && f.keepsWalk && !f.lookedUp) {
+            f.lookedUp = true;
+            if (f.refKey === undefined)
+                f.refKey = getFlowReferenceKey(c, f);
+            if (f.refKey !== '' && !hasKeyCharacterInName(c, f.reference)) {
+                f.walk = c.flowWalks.get(f.refKey);
+                // Only the first frame's nodes have the walk's result as their type.
+                if (f.depth === 1)
+                    f.anchor = flow;
+            }
+        }
+        const walk = f.walk;
+        const flags = flow.flags;
+        if ((flags & 4096 /* FlowFlags.Shared */) !== 0) {
+            // Shared nodes are cached for the duration of one walk.
+            if (c.sharedFlowCount - f.sharedFlowStart >= sharedFlowIndexThreshold) {
+                const i = c.sharedFlowIndexes[c.flowStateDepth - 1].get(flow);
+                if (i !== undefined) {
+                    f.depth--;
+                    f.incomplete = c.sharedFlowIncomplete[i];
+                    return c.sharedFlowTypes[i];
+                }
+            }
+            else
+                for (let i = f.sharedFlowStart; i < c.sharedFlowCount; i++) {
+                    if (c.sharedFlowNodes[i] === flow) {
+                        f.depth--;
+                        f.incomplete = c.sharedFlowIncomplete[i];
+                        return c.sharedFlowTypes[i];
+                    }
+                }
+            sharedFlow = flow;
+        }
+        let t;
+        if (walk !== undefined &&
+            flow === walk.start &&
+            c.flowLoopStack.length === 0 &&
+            c.flowReduceLabels.length === 0 &&
+            c.inlineLevel === 0 &&
+            f.depth + walk.depth - 1 <= 2000) {
+            if (f.depth + walk.depth - 1 > f.maxDepth)
+                f.maxDepth = f.depth + walk.depth - 1;
+            t = complete(f, walk.type);
+        }
+        else if ((flags & 16 /* FlowFlags.Assignment */) !== 0) {
+            const assigned = getTypeAtFlowAssignment(c, f, flow);
+            if (assigned === undefined) {
+                flow = flow.antecedent;
+                continue;
+            }
+            t = assigned;
+        }
+        else if ((flags & 512 /* FlowFlags.Call */) !== 0) {
+            const narrowed = getTypeAtFlowCall(c, f, flow);
+            if (narrowed === undefined) {
+                flow = flow.antecedent;
+                continue;
+            }
+            t = narrowed;
+        }
+        else if ((flags & 96 /* FlowFlags.Condition */) !== 0)
+            t = getTypeAtFlowCondition(c, f, flow);
+        else if ((flags & 128 /* FlowFlags.SwitchClause */) !== 0)
+            t = getTypeAtSwitchClause(c, f, flow);
+        else if ((flags & 4 /* FlowFlags.BranchLabel */) !== 0) {
+            const antecedents = getBranchLabelAntecedents(c, flow);
+            if (antecedents.length === 1) {
+                flow = antecedents[0];
+                continue;
+            }
+            t = getTypeAtFlowBranchLabel(c, f, antecedents);
+        }
+        else if ((flags & 8 /* FlowFlags.LoopLabel */) !== 0) {
+            const antecedents = flow.antecedents;
+            if (antecedents.length === 1) {
+                flow = antecedents[0];
+                continue;
+            }
+            t = getTypeAtFlowLoopLabel(c, f, flow);
+        }
+        else if ((flags & 256 /* FlowFlags.ArrayMutation */) !== 0) {
+            const mutated = getTypeAtFlowArrayMutation(c, f, flow);
+            if (mutated === undefined) {
+                flow = flow.antecedent;
+                continue;
+            }
+            t = mutated;
+        }
+        else if ((flags & 1024 /* FlowFlags.ReduceLabel */) !== 0) {
+            c.flowReduceLabels.push(flow);
+            t = getTypeAtFlowNode(c, f, flow.antecedent);
+            c.flowReduceLabels.pop();
+        }
+        else if ((flags & 2 /* FlowFlags.Start */) !== 0) {
+            // Continue with the containing function's flow when the reference is captured.
+            const container = flow.node;
+            if (container !== undefined &&
+                container !== f.flowContainer &&
+                f.reference.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ &&
+                f.reference.kind !== 213 /* SyntaxKind.ElementAccessExpression */ &&
+                !(f.reference.kind === 109 /* SyntaxKind.ThisKeyword */ && container.kind !== 220 /* SyntaxKind.ArrowFunction */)) {
+                const outer = getFlowNode(container);
+                if (outer !== undefined) {
+                    flow = outer;
+                    continue;
+                }
+            }
+            t = complete(f, f.initialType);
+        }
+        else {
+            // Unreachable code; errors are reported by the binder.
+            t = complete(f, convertAutoToAny(c, f.declaredType));
+        }
+        if (sharedFlow !== undefined) {
+            const count = c.sharedFlowCount;
+            if (count < c.sharedFlowNodes.length) {
+                c.sharedFlowNodes[count] = sharedFlow;
+                c.sharedFlowTypes[count] = t;
+                c.sharedFlowIncomplete[count] = f.incomplete;
+            }
+            else {
+                c.sharedFlowNodes.push(sharedFlow);
+                c.sharedFlowTypes.push(t);
+                c.sharedFlowIncomplete.push(f.incomplete);
+            }
+            c.sharedFlowCount = count + 1;
+            const own = count + 1 - f.sharedFlowStart;
+            if (own > sharedFlowIndexThreshold) {
+                const index = c.sharedFlowIndexes[c.flowStateDepth - 1];
+                if (!index.has(sharedFlow))
+                    index.set(sharedFlow, count);
+            }
+            else if (own === sharedFlowIndexThreshold)
+                indexSharedFlows(c, f, c.flowStateDepth - 1);
+        }
+        f.depth--;
+        return t;
+    }
+}
+export function convertAutoToAny(c, t) {
+    if (t === c.autoType)
+        return c.anyType;
+    if (t === c.autoArrayType)
+        return c.anyArrayType;
+    return t;
+}
+/** A branch label's antecedents, as limited by the innermost reduce label being passed that targets it. */
+export function getBranchLabelAntecedents(c, flow) {
+    const reduceLabels = c.flowReduceLabels;
+    for (let i = reduceLabels.length - 1; i >= 0; i--)
+        if (reduceLabels[i].target === flow)
+            return reduceLabels[i].antecedents;
+    return flow.antecedents;
+}
+// ---- Assignments and calls
+function getTypeAtFlowAssignment(c, f, flow) {
+    const node = flow.node;
+    if (isMatchingReference(c, f.reference, node)) {
+        if (!isReachableFlowNode(c, flow))
+            return complete(f, c.unreachableNeverType);
+        if (getAssignmentTargetKind(node) === 2 /* AssignmentKind.Compound */) {
+            const flowType = getTypeAtFlowNode(c, f, flow.antecedent);
+            return newFlowType(c, f, getBaseTypeOfLiteralType(c, flowType), f.incomplete);
+        }
+        if (f.declaredType === c.autoType || f.declaredType === c.autoArrayType) {
+            if (isEmptyArrayAssignment(node))
+                return complete(f, getEvolvingArrayType(c, c.neverType));
+            const assignedType = getWidenedLiteralType(c, getInitialOrAssignedType(c, f, flow));
+            return complete(f, isTypeAssignableTo(c, assignedType, f.declaredType) ? assignedType : c.anyArrayType);
+        }
+        let t = f.declaredType;
+        if (isInCompoundLikeAssignment(node))
+            t = getBaseTypeOfLiteralType(c, t);
+        if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0)
+            return complete(f, getAssignmentReducedType(c, t, getInitialOrAssignedType(c, f, flow)));
+        return complete(f, t);
+    }
+    // An assignment to a prefix of a dotted name resets it to the declared type.
+    if (containsMatchingReference(c, f.reference, node)) {
+        if (!isReachableFlowNode(c, flow))
+            return complete(f, c.unreachableNeverType);
+        // The dotted name may be an expando property of a function expression; its flow continues
+        // back past the function's declaration.
+        if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+            const blockScope = getCombinedNodeFlags(node) & 7 /* NodeFlags.BlockScoped */;
+            const initializer = getInitializer(node);
+            if ((isInJSFile(node) ||
+                blockScope === 2 /* NodeFlags.Const */ ||
+                blockScope === 4 /* NodeFlags.Using */ ||
+                blockScope === 6 /* NodeFlags.AwaitUsing */) &&
+                initializer !== undefined &&
+                (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */))
+                return getTypeAtFlowNode(c, f, flow.antecedent);
+        }
+        return complete(f, f.declaredType);
+    }
+    // `for (const _ in ref)` acts as a non-null check of `ref`.
+    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */ && node.parent.parent.kind === 250 /* SyntaxKind.ForInStatement */) {
+        const statementExpression = getExpression(node.parent.parent);
+        if (isMatchingReference(c, f.reference, statementExpression) ||
+            optionalChainContainsReference(c, statementExpression, f.reference)) {
+            const antecedentType = getTypeAtFlowNode(c, f, flow.antecedent);
+            const finalType = finalizeEvolvingArrayType(c, antecedentType);
+            return complete(f, hasTypeFacts(c, finalType, 50331648 /* TypeFacts.IsUndefinedOrNull */) ? getNonNullableType(c, finalType) : finalType);
+        }
+    }
+    return undefined;
+}
+function isEmptyArrayAssignment(node) {
+    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+        const initializer = getInitializer(node);
+        return initializer !== undefined && isEmptyArrayLiteral(initializer);
+    }
+    const parent = node.parent;
+    return (node.kind !== 209 /* SyntaxKind.BindingElement */ &&
+        parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        isEmptyArrayLiteral(parent.right));
+}
+function isEmptyArrayLiteral(node) {
+    return node.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && getElements(node).nodes.length === 0;
+}
+function getInitialOrAssignedType(c, f, flow) {
+    const node = flow.node;
+    const t = node.kind === 261 /* SyntaxKind.VariableDeclaration */ || node.kind === 209 /* SyntaxKind.BindingElement */
+        ? getInitialType(c, node)
+        : getAssignedType(c, node);
+    // getNarrowableTypeForReference looks at the reference's position for these.
+    if (someTypeIsGenericWithUnionConstraint(c, t))
+        f.positional = true;
+    return getNarrowableTypeForReference(c, t, f.reference);
+}
+function getInitialType(c, node) {
+    if (node.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+        const initializer = getInitializer(node);
+        if (initializer !== undefined)
+            return getTypeOfInitializer(c, initializer);
+        const statement = node.parent.parent;
+        if (statement.kind === 250 /* SyntaxKind.ForInStatement */)
+            return c.stringType;
+        if (statement.kind === 251 /* SyntaxKind.ForOfStatement */)
+            return checkRightHandSideOfForOf(c, statement);
+        return c.errorType;
+    }
+    return getInitialTypeOfBindingElement(c, node);
+}
+/** The type of an initializer: the type a variable was inferred from, else computed without caching. */
+export function getTypeOfInitializer(c, node) {
+    return c.resolvedTypes.get(node.id) ?? getTypeOfExpression(c, node);
+}
+function getInitialTypeOfBindingElement(c, node) {
+    const pattern = node.parent;
+    const parentType = getInitialType(c, pattern.parent);
+    let t;
+    if (pattern.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+        t = getTypeOfDestructuredProperty(c, parentType, (node.propertyName ?? node.name));
+    else if (node.dotDotDotToken === undefined)
+        t = getTypeOfDestructuredArrayElement(c, parentType, getElements(pattern).nodes.indexOf(node));
+    else
+        t = getTypeOfDestructuredSpreadExpression(c, parentType);
+    return getTypeWithDefault(c, t, node.initializer);
+}
+function getAssignedType(c, node) {
+    const parent = node.parent;
+    switch (parent.kind) {
+        case 250 /* SyntaxKind.ForInStatement */:
+            return c.stringType;
+        case 251 /* SyntaxKind.ForOfStatement */:
+            return checkRightHandSideOfForOf(c, parent);
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return getAssignedTypeOfBinaryExpression(c, parent);
+        case 221 /* SyntaxKind.DeleteExpression */:
+            return c.undefinedType;
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return getTypeOfDestructuredArrayElement(c, getAssignedType(c, parent), getElements(parent).nodes.indexOf(node));
+        case 231 /* SyntaxKind.SpreadElement */:
+            return getTypeOfDestructuredSpreadExpression(c, getAssignedType(c, parent.parent));
+        case 303 /* SyntaxKind.PropertyAssignment */:
+            return getAssignedTypeOfPropertyAssignment(c, parent);
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return getTypeWithDefault(c, getAssignedTypeOfPropertyAssignment(c, parent), parent.objectAssignmentInitializer);
+    }
+    return c.errorType;
+}
+function getAssignedTypeOfBinaryExpression(c, node) {
+    const parent = node.parent;
+    const isDestructuringDefaultAssignment = (parent.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ && isDestructuringAssignmentTarget(parent)) ||
+        (parent.kind === 303 /* SyntaxKind.PropertyAssignment */ && isDestructuringAssignmentTarget(parent.parent));
+    if (isDestructuringDefaultAssignment)
+        return getTypeWithDefault(c, getAssignedType(c, node), node.right);
+    return getTypeOfExpression(c, node.right);
+}
+function isDestructuringAssignmentTarget(parent) {
+    const grandparent = parent.parent;
+    return ((grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ && grandparent.left === parent) ||
+        (grandparent.kind === 251 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === parent));
+}
+function getAssignedTypeOfPropertyAssignment(c, node) {
+    return getTypeOfDestructuredProperty(c, getAssignedType(c, node.parent), getName(node));
+}
+function getTypeOfDestructuredArrayElement(c, t, index) {
+    if (everyType(t, (u) => isTupleLikeType(c, u))) {
+        const elementType = getTupleElementType(c, t, index);
+        if (elementType !== undefined)
+            return elementType;
+    }
+    return includeUndefinedInIndexSignature(c, checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, t, c.undefinedType, undefined));
+}
+function getTupleElementType(c, t, index) {
+    const propType = getTypeOfPropertyOfType(c, t, String(index));
+    if (propType !== undefined)
+        return propType;
+    if (everyType(t, isTupleType))
+        return getTupleElementTypeOutOfStartCount(c, t, index, c.noUncheckedIndexedAccess ? c.undefinedType : undefined);
+    return undefined;
+}
+function includeUndefinedInIndexSignature(c, t) {
+    return c.noUncheckedIndexedAccess ? getUnionType(c, [t, c.missingType]) : t;
+}
+function getTypeOfDestructuredSpreadExpression(c, t) {
+    return createArrayType(c, checkIteratedTypeOrElementType(c, 65 /* IterationUse.Destructuring */, t, c.undefinedType, undefined));
+}
+function getTypeOfDestructuredProperty(c, t, name) {
+    const nameType = getLiteralTypeFromPropertyName(c, name);
+    if (nameType === undefined || !isTypeUsableAsPropertyName(nameType))
+        return c.errorType;
+    const text = getPropertyNameFromType(nameType);
+    const propType = getTypeOfPropertyOfType(c, t, text);
+    if (propType !== undefined)
+        return propType;
+    const indexInfo = getApplicableIndexInfoForName(c, t, text);
+    if (indexInfo !== undefined)
+        return includeUndefinedInIndexSignature(c, indexInfo.valueType);
+    return c.errorType;
+}
+function getTypeWithDefault(c, t, defaultExpression) {
+    return defaultExpression !== undefined
+        ? getUnionType(c, [getNonUndefinedType(c, t), getTypeOfExpression(c, defaultExpression)])
+        : t;
+}
+/** The constituents of `declaredType` that some constituent of `assignedType` is assignable to. */
+export function getAssignmentReducedType(c, declaredType, assignedType) {
+    if (declaredType === assignedType)
+        return declaredType;
+    if ((assignedType.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return assignedType;
+    const pair = cachedTypePairKey(declaredType.id, assignedType.id, 0);
+    const key = pair < 0 ? 'assignmentReduced' + declaredType.id + ',' + assignedType.id : '';
+    let result = pair < 0 ? c.cachedTypes.get(key) : c.cachedTypesByPair.get(pair);
+    if (result === undefined) {
+        const filteredType = filterType(c, declaredType, (t) => typeMaybeAssignableTo(c, assignedType, t));
+        let reducedType = filteredType;
+        if ((assignedType.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0 && isFreshLiteralType(assignedType))
+            reducedType = mapType(c, filteredType, (t) => getFreshTypeOfLiteralType(c, t));
+        result = isTypeAssignableTo(c, assignedType, reducedType) ? reducedType : declaredType;
+        if (pair < 0)
+            c.cachedTypes.set(key, result);
+        else
+            c.cachedTypesByPair.set(pair, result);
+    }
+    return result;
+}
+function typeMaybeAssignableTo(c, source, target) {
+    if ((source.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return isTypeAssignableTo(c, source, target);
+    for (const t of typesOf(source))
+        if (isTypeAssignableTo(c, t, target))
+            return true;
+    return false;
+}
+function getTypeAtFlowCall(c, f, flow) {
+    const call = flow.node;
+    const signature = getEffectsSignature(c, call);
+    if (signature === undefined)
+        return undefined;
+    const predicate = getTypePredicateOfSignature(c, signature);
+    if (predicate !== undefined &&
+        (predicate.kind === 2 /* TypePredicateKind.AssertsThis */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */)) {
+        const flowType = getTypeAtFlowNode(c, f, flow.antecedent);
+        const incomplete = f.incomplete;
+        const t = finalizeEvolvingArrayType(c, flowType);
+        let narrowedType = t;
+        const args = getArguments(call).nodes;
+        if (predicate.type !== undefined)
+            narrowedType = narrowTypeByTypePredicate(c, f, t, predicate, call, true);
+        else if (predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ &&
+            predicate.parameterIndex >= 0 &&
+            predicate.parameterIndex < args.length)
+            narrowedType = narrowTypeByAssertion(c, f, t, args[predicate.parameterIndex]);
+        if (narrowedType === t)
+            return newFlowType(c, f, flowType, incomplete);
+        return newFlowType(c, f, narrowedType, incomplete);
+    }
+    if ((getReturnTypeOfSignature(c, signature).flags & 262144 /* TypeFlags.Never */) !== 0)
+        return complete(f, c.unreachableNeverType);
+    return undefined;
+}
+function narrowTypeByAssertion(c, f, t, expr) {
+    const node = skipParentheses(expr);
+    if (node.kind === 96 /* SyntaxKind.FalseKeyword */)
+        return c.unreachableNeverType;
+    if (node.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const binary = node;
+        if (binary.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)
+            return narrowTypeByAssertion(c, f, narrowTypeByAssertion(c, f, t, binary.left), binary.right);
+        if (binary.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */)
+            return getUnionType(c, [
+                narrowTypeByAssertion(c, f, t, binary.left),
+                narrowTypeByAssertion(c, f, t, binary.right),
+            ]);
+    }
+    return narrowType(c, f, t, node, true);
+}
+/** The signature of a call whose effects (type predicates, `never` returns) apply to control flow. */
+export function getEffectsSignature(c, node) {
+    const links = c.nodeLinks(node);
+    let signature = links.effectsSignature;
+    if (signature === undefined) {
+        // Assertion calls resolve their target with getTypeOfDottedName to avoid circularities.
+        let funcType = undefined;
+        if (node.kind === 227 /* SyntaxKind.BinaryExpression */)
+            funcType = getSymbolHasInstanceMethodOfObjectType(c, checkNonNullExpression(c, node.right));
+        else {
+            const callee = getExpression(node);
+            // Assertions resolve their target without inference, to avoid circularities in flow analysis.
+            if (node.parent.kind === 245 /* SyntaxKind.ExpressionStatement */)
+                funcType = getTypeOfDottedName(c, callee);
+            else if (callee.kind !== 107 /* SyntaxKind.SuperKeyword */)
+                funcType = isOptionalChain(node)
+                    ? checkNonNullType(c, getOptionalExpressionType(c, checkExpression(c, callee), callee), callee)
+                    : checkNonNullExpression(c, callee);
+        }
+        const signatures = getSignaturesOfType(c, funcType !== undefined ? getApparentType(c, funcType) : c.unknownType, 0 /* SignatureKind.Call */);
+        let candidate = undefined;
+        if (signatures.length === 1 && signatures[0].typeParameters.length === 0)
+            candidate = signatures[0];
+        // Generic or overloaded predicates and assertions take effect through the resolved signature.
+        else if (someSignatureHasTypePredicateOrNeverReturnType(c, signatures))
+            candidate = getResolvedSignature(c, node, 0 /* CheckMode.Normal */);
+        signature =
+            candidate !== undefined && hasTypePredicateOrNeverReturnType(c, candidate) ? candidate : c.unknownSignature;
+        links.effectsSignature = signature;
+    }
+    return signature === c.unknownSignature ? undefined : signature;
+}
+function someSignatureHasTypePredicateOrNeverReturnType(c, signatures) {
+    for (const sig of signatures)
+        if (hasTypePredicateOrNeverReturnType(c, sig))
+            return true;
+    return false;
+}
+function hasTypePredicateOrNeverReturnType(c, sig) {
+    if (getTypePredicateOfSignature(c, sig) !== undefined)
+        return true;
+    if (sig.declaration === undefined)
+        return false;
+    const returnType = getReturnTypeFromAnnotation(c, sig.declaration);
+    return returnType !== undefined && (returnType.flags & 262144 /* TypeFlags.Never */) !== 0;
+}
+/** The declared type of a dotted name, without inference, for assertion calls. */
+function getTypeOfDottedName(c, node) {
+    if ((node.flags & 16777216 /* NodeFlags.InWithStatement */) !== 0)
+        return undefined;
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+            return getExplicitTypeOfSymbol(c, getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, node)));
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return getExplicitThisType(c, node);
+        case 107 /* SyntaxKind.SuperKeyword */:
+            return checkSuperExpression(c, node);
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const t = getTypeOfDottedName(c, getExpression(node));
+            if (t === undefined)
+                return undefined;
+            const name = node.name;
+            let prop;
+            if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+                prop =
+                    t.symbol !== undefined
+                        ? getPropertyOfType(c, t, getSymbolNameForPrivateIdentifier(t.symbol, getText(name)))
+                        : undefined;
+            else
+                prop = getPropertyOfType(c, t, getText(name));
+            return prop !== undefined ? getExplicitTypeOfSymbol(c, prop) : undefined;
+        }
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return getTypeOfDottedName(c, getExpression(node));
+    }
+    return undefined;
+}
+function getExplicitTypeOfSymbol(c, original) {
+    const symbol = resolveSymbol(c, original) ?? original;
+    if ((symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) !== 0)
+        return getTypeOfSymbol(c, symbol);
+    if ((symbol.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */)) !== 0) {
+        if ((symbol.checkFlags & 262144 /* CheckFlags.Mapped */) !== 0) {
+            const origin = c.symbolSyntheticOrigins.get(getSymbolId(symbol));
+            if (origin !== undefined && getExplicitTypeOfSymbol(c, origin) !== undefined)
+                return getTypeOfSymbol(c, symbol);
+        }
+        const declaration = symbol.valueDeclaration;
+        if (declaration !== undefined) {
+            if (isDeclarationWithExplicitTypeAnnotation(declaration))
+                return getTypeOfSymbol(c, symbol);
+            // `for (const x of xs)` where `xs` has an explicit type.
+            if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                declaration.parent.parent.kind === 251 /* SyntaxKind.ForOfStatement */) {
+                const statement = declaration.parent.parent;
+                const expressionType = getTypeOfDottedName(c, statement.expression);
+                if (expressionType !== undefined)
+                    return checkIteratedTypeOrElementType(c, statement.awaitModifier !== undefined ? 15 /* IterationUse.ForAwaitOf */ : 13 /* IterationUse.ForOf */, expressionType, c.undefinedType, undefined);
+            }
+        }
+    }
+    return undefined;
+}
+function isDeclarationWithExplicitTypeAnnotation(node) {
+    switch (node.kind) {
+        case 261 /* SyntaxKind.VariableDeclaration */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 172 /* SyntaxKind.PropertySignature */:
+        case 170 /* SyntaxKind.Parameter */:
+            return getType(node) !== undefined;
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            // An expando property assigned a function with a return type annotation.
+            const right = node.right;
+            return isFunctionLike(right) && getType(right) !== undefined;
+        }
+    }
+    return false;
+}
+function getExplicitThisType(c, node) {
+    const container = getThisContainer(node, false, false);
+    if (isFunctionLike(container)) {
+        const signature = getSignatureFromDeclaration(c, container);
+        if (signature.thisParameter !== undefined)
+            return getExplicitTypeOfSymbol(c, signature.thisParameter);
+    }
+    const parent = container.parent;
+    if (parent !== undefined && isClassLike(parent)) {
+        const symbol = getSymbolOfDeclaration(c, parent);
+        if (symbol === undefined)
+            return undefined;
+        return isStatic(container)
+            ? getTypeOfSymbol(c, symbol)
+            : getDeclaredTypeOfSymbol(c, symbol).thisType;
+    }
+    return undefined;
+}
+// ---- Conditions
+function getTypeAtFlowCondition(c, f, flow) {
+    const flowType = getTypeAtFlowNode(c, f, flow.antecedent);
+    const incomplete = f.incomplete;
+    if ((flowType.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return newFlowType(c, f, flowType, incomplete);
+    const assumeTrue = (flow.flags & 32 /* FlowFlags.TrueCondition */) !== 0;
+    const nonEvolvingType = finalizeEvolvingArrayType(c, flowType);
+    const narrowedType = narrowType(c, f, nonEvolvingType, flow.node, assumeTrue);
+    if (narrowedType === nonEvolvingType) {
+        f.incomplete = incomplete;
+        return flowType;
+    }
+    return newFlowType(c, f, narrowedType, incomplete);
+}
+function getTypeAtFlowBranchLabel(c, f, antecedents) {
+    const types = [];
+    let subtypeReduction = false;
+    let seenIncomplete = false;
+    let bypassFlow = undefined;
+    for (const antecedent of antecedents) {
+        if (bypassFlow === undefined &&
+            (antecedent.flags & 128 /* FlowFlags.SwitchClause */) !== 0 &&
+            antecedent.isEmpty()) {
+            // The bypass branch of a possibly exhaustive switch.
+            bypassFlow = antecedent;
+            continue;
+        }
+        const flowType = getTypeAtFlowNode(c, f, antecedent);
+        const incomplete = f.incomplete;
+        if (flowType === f.declaredType && f.declaredType === f.initialType)
+            return complete(f, flowType);
+        if (!types.includes(flowType))
+            types.push(flowType);
+        if (!isTypeSubsetOf(c, flowType, f.initialType))
+            subtypeReduction = true;
+        if (incomplete)
+            seenIncomplete = true;
+    }
+    if (bypassFlow !== undefined) {
+        const flowType = getTypeAtFlowNode(c, f, bypassFlow);
+        const incomplete = f.incomplete;
+        if ((flowType.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            !types.includes(flowType) &&
+            !isExhaustiveSwitchStatement(c, bypassFlow.switchStatement)) {
+            if (flowType === f.declaredType && f.declaredType === f.initialType)
+                return complete(f, flowType);
+            types.push(flowType);
+            if (!isTypeSubsetOf(c, flowType, f.initialType))
+                subtypeReduction = true;
+            if (incomplete)
+                seenIncomplete = true;
+        }
+    }
+    return newFlowType(c, f, getUnionOfFlowTypes(c, f, types, subtypeReduction ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */), seenIncomplete);
+}
+/**
+ * The union of the types at a junction: an evolving array when every path has one, otherwise the
+ * union with evolving arrays finalized.
+ */
+function getUnionOfFlowTypes(c, f, types, reduction) {
+    if (isEvolvingArrayTypeList(types)) {
+        const elementTypes = [];
+        for (const t of types)
+            elementTypes.push(getElementTypeOfEvolvingArrayType(c, t));
+        return getEvolvingArrayType(c, getUnionType(c, elementTypes));
+    }
+    // Finalizing changes only evolving arrays; without one, the list itself is unioned (getUnionTypeEx
+    // does not keep or change it).
+    let finalized = types;
+    for (const t of types)
+        if ((t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0) {
+            finalized = [];
+            for (const u of types)
+                finalized.push(finalizeEvolvingArrayType(c, u));
+            break;
+        }
+    const result = recombineUnknownType(c, getUnionTypeEx(c, finalized, reduction, undefined, undefined));
+    const declared = f.declaredType;
+    if (result !== declared && (result.flags & declared.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const a = result.types;
+        const b = declared.types;
+        if (a.length === b.length) {
+            let same = true;
+            for (let i = 0; i < a.length; i++)
+                if (a[i] !== b[i]) {
+                    same = false;
+                    break;
+                }
+            if (same)
+                return declared;
+        }
+    }
+    return result;
+}
+export function recombineUnknownType(c, t) {
+    return t === c.unknownUnionType ? c.unknownType : t;
+}
+function getTypeAtFlowLoopLabel(c, f, flow) {
+    if (f.refKey === undefined)
+        f.refKey = getFlowReferenceKey(c, f);
+    if (f.refKey === '')
+        return complete(f, f.declaredType);
+    const key = f.refKey;
+    let cache = c.flowLoopCaches.get(flow);
+    if (cache === undefined) {
+        cache = new Map();
+        c.flowLoopCaches.set(flow, cache);
+    }
+    const cached = cache.get(key);
+    if (cached !== undefined)
+        return complete(f, cached);
+    // A junction already being analyzed for this reference yields the types seen so far, incomplete.
+    for (const loop of c.flowLoopStack) {
+        if (loop.flow === flow && loop.refKey === key && loop.types.length !== 0)
+            return newFlowType(c, f, getUnionOfFlowTypes(c, f, loop.types, 1 /* UnionReduction.Literal */), true);
+    }
+    const antecedentTypes = [];
+    let subtypeReduction = false;
+    let firstIncomplete = false;
+    let first = true;
+    for (const antecedent of flow.antecedents) {
+        let flowType;
+        if (first) {
+            // The first antecedent is the path into the loop.
+            flowType = getTypeAtFlowNode(c, f, antecedent);
+            firstIncomplete = f.incomplete;
+            first = false;
+        }
+        else {
+            c.flowLoopStack.push(new FlowLoopInfo(flow, key, antecedentTypes));
+            const saveFlowTypeCache = c.flowTypeCache;
+            c.flowTypeCache = undefined;
+            flowType = getTypeAtFlowNode(c, f, antecedent);
+            c.flowTypeCache = saveFlowTypeCache;
+            c.flowLoopStack.pop();
+            const restarted = cache.get(key);
+            if (restarted !== undefined)
+                return complete(f, restarted);
+        }
+        if (!antecedentTypes.includes(flowType))
+            antecedentTypes.push(flowType);
+        if (!isTypeSubsetOf(c, flowType, f.initialType))
+            subtypeReduction = true;
+        if (flowType === f.declaredType)
+            break;
+    }
+    const result = getUnionOfFlowTypes(c, f, antecedentTypes, subtypeReduction ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */);
+    if (firstIncomplete)
+        return newFlowType(c, f, result, true);
+    cache.set(key, result);
+    return complete(f, result);
+}
+/** A key identifying a dotted-name reference and its declared/initial types; '' when not a dotted name. */
+function getFlowReferenceKey(c, f) {
+    return writeFlowCacheKey(c, f.reference, f.declaredType, f.initialType, f.flowContainer) ?? '';
+}
+function writeFlowCacheKey(c, node, declaredType, initialType, flowContainer) {
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 109 /* SyntaxKind.ThisKeyword */: {
+            let key = '';
+            if (node.kind === 79 /* SyntaxKind.Identifier */ && !isThisInTypeQuery(node)) {
+                const symbol = getResolvedSymbol(c, node);
+                if (symbol === c.unknownSymbol)
+                    return undefined;
+                key = String(getSymbolId(symbol));
+            }
+            key += ':' + declaredType.id;
+            if (initialType !== declaredType)
+                key += '=' + initialType.id;
+            if (flowContainer !== undefined)
+                key += '@' + getNodeId(flowContainer);
+            return key;
+        }
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return writeFlowCacheKey(c, getExpression(node), declaredType, initialType, flowContainer);
+        case 167 /* SyntaxKind.QualifiedName */: {
+            const left = writeFlowCacheKey(c, node.left, declaredType, initialType, flowContainer);
+            return left === undefined ? undefined : left + '.' + node.right.text;
+        }
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const name = getAccessedPropertyName(c, node);
+            if (name !== undefined) {
+                const left = writeFlowCacheKey(c, getExpression(node), declaredType, initialType, flowContainer);
+                return left === undefined ? undefined : left + '.' + name;
+            }
+            // `obj[key]` for a key that isn't reassigned.
+            if (node.kind !== 213 /* SyntaxKind.ElementAccessExpression */)
+                return undefined;
+            const argument = node.argumentExpression;
+            if (argument.kind !== 79 /* SyntaxKind.Identifier */)
+                return undefined;
+            const symbol = getResolvedSymbol(c, argument);
+            if (!isUnreassignedVariable(c, symbol))
+                return undefined;
+            const left = writeFlowCacheKey(c, getExpression(node), declaredType, initialType, flowContainer);
+            return left === undefined ? undefined : left + '.@' + getSymbolId(symbol);
+        }
+        // Pseudo-references of getNarrowedTypeOfSymbol.
+        case 207 /* SyntaxKind.ObjectBindingPattern */:
+        case 208 /* SyntaxKind.ArrayBindingPattern */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+            return '#' + getNodeId(node) + '#' + declaredType.id;
+    }
+    return undefined;
+}
+// ---- Narrowing by expressions
+function narrowType(c, f, t, expr, assumeTrue) {
+    // `a?.b` implies `a` is not nullish; so does the left of `??`.
+    const parent = expr.parent;
+    if (isExpressionOfOptionalChainRoot(expr) ||
+        (parent !== undefined &&
+            parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            (parent.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */ ||
+                parent.operatorToken.kind === 77 /* SyntaxKind.QuestionQuestionEqualsToken */) &&
+            parent.left === expr))
+        return narrowTypeByOptionality(c, f, t, expr, assumeTrue);
+    switch (expr.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+            // Narrowing through aliased conditions: `const ok = x !== undefined; if (ok) ...`.
+            if (!isMatchingReference(c, f.reference, expr) && c.inlineLevel < 5) {
+                const symbol = getResolvedSymbol(c, expr);
+                if (isConstantVariable(c, symbol)) {
+                    const declaration = symbol.valueDeclaration;
+                    if (declaration !== undefined &&
+                        declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                        getType(declaration) === undefined) {
+                        const initializer = getInitializer(declaration);
+                        // For an access, isConstantReference reads the property symbol resolved where the
+                        // reference is, which narrowing of its object changes.
+                        if (initializer !== undefined && isAccessExpression(f.reference))
+                            f.positional = true;
+                        if (initializer !== undefined && isConstantReference(c, f.reference)) {
+                            c.inlineLevel++;
+                            const result = narrowType(c, f, t, initializer, assumeTrue);
+                            c.inlineLevel--;
+                            return result;
+                        }
+                    }
+                }
+            }
+            return narrowTypeByTruthiness(c, f, t, expr, assumeTrue);
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+            return narrowTypeByTruthiness(c, f, t, expr, assumeTrue);
+        case 214 /* SyntaxKind.CallExpression */:
+            return narrowTypeByCallExpression(c, f, t, expr, assumeTrue);
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return narrowType(c, f, t, getExpression(expr), assumeTrue);
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return narrowTypeByBinaryExpression(c, f, t, expr, assumeTrue);
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            if (expr.operator === 53 /* SyntaxKind.ExclamationToken */)
+                return narrowType(c, f, t, expr.operand, !assumeTrue);
+            break;
+    }
+    return t;
+}
+function narrowTypeByOptionality(c, f, t, expr, assumePresent) {
+    const facts = assumePresent ? 2097152 /* TypeFacts.NEUndefinedOrNull */ : 262144 /* TypeFacts.EQUndefinedOrNull */;
+    if (isMatchingReference(c, f.reference, expr))
+        return getAdjustedTypeWithFacts(c, t, facts);
+    const access = getDiscriminantPropertyAccess(c, f, expr, t);
+    if (access !== undefined)
+        return narrowTypeByDiscriminant(c, t, access, (u) => getTypeWithFacts(c, u, facts));
+    return t;
+}
+function narrowTypeByTruthiness(c, f, t, expr, assumeTrue) {
+    const facts = assumeTrue ? 4194304 /* TypeFacts.Truthy */ : 8388608 /* TypeFacts.Falsy */;
+    if (isMatchingReference(c, f.reference, expr))
+        return getAdjustedTypeWithFacts(c, t, facts);
+    if (c.strictNullChecks && assumeTrue && optionalChainContainsReference(c, expr, f.reference))
+        t = getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */);
+    const access = getDiscriminantPropertyAccess(c, f, expr, t);
+    if (access !== undefined)
+        return narrowTypeByDiscriminant(c, t, access, (u) => getTypeWithFacts(c, u, facts));
+    return t;
+}
+function narrowTypeByCallExpression(c, f, t, call, assumeTrue) {
+    if (hasMatchingArgument(c, call, f.reference)) {
+        const signature = assumeTrue || !isCallChain(call) ? getEffectsSignature(c, call) : undefined;
+        const predicate = signature !== undefined ? getTypePredicateOfSignature(c, signature) : undefined;
+        if (predicate !== undefined &&
+            (predicate.kind === 0 /* TypePredicateKind.This */ || predicate.kind === 1 /* TypePredicateKind.Identifier */))
+            return narrowTypeByTypePredicate(c, f, t, predicate, call, assumeTrue);
+    }
+    // `obj.hasOwnProperty("p")` narrows an optional `obj.p` under exactOptionalPropertyTypes.
+    if (containsMissingType(c, t) && isAccessExpression(f.reference)) {
+        const callee = getExpression(call);
+        if (callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+            const name = callee.name;
+            const args = getArguments(call).nodes;
+            if (isMatchingReference(c, getExpression(f.reference), getReferenceCandidate(getExpression(callee))) &&
+                name.kind === 79 /* SyntaxKind.Identifier */ &&
+                getText(name) === 'hasOwnProperty' &&
+                args.length === 1 &&
+                isStringLiteralLike(args[0]) &&
+                getAccessedPropertyName(c, f.reference) === getText(args[0]))
+                return getTypeWithFacts(c, t, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */);
+        }
+    }
+    return t;
+}
+function narrowTypeByTypePredicate(c, f, t, predicate, call, assumeTrue) {
+    const predicateType = predicate.type;
+    if (predicateType === undefined)
+        return t;
+    if ((t.flags & 1 /* TypeFlags.Any */) !== 0 &&
+        (predicateType === c.globalObjectType || predicateType === c.globalFunctionType))
+        return t;
+    const argument = getTypePredicateArgument(predicate, call);
+    if (argument === undefined)
+        return t;
+    if (isMatchingReference(c, f.reference, argument))
+        return getNarrowedType(c, t, predicateType, assumeTrue, false);
+    if (c.strictNullChecks &&
+        optionalChainContainsReference(c, argument, f.reference) &&
+        ((assumeTrue && !hasTypeFacts(c, predicateType, 65536 /* TypeFacts.EQUndefined */)) ||
+            (!assumeTrue && everyType(predicateType, isNullableType))))
+        t = getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */);
+    const access = getDiscriminantPropertyAccess(c, f, argument, t);
+    if (access !== undefined)
+        return narrowTypeByDiscriminant(c, t, access, (u) => getNarrowedType(c, u, predicateType, assumeTrue, false));
+    return t;
+}
+function isNullableType(t) {
+    return (t.flags & 12 /* TypeFlags.Nullable */) !== 0;
+}
+function getTypePredicateArgument(predicate, call) {
+    if (predicate.kind === 1 /* TypePredicateKind.Identifier */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */) {
+        const args = getArguments(call).nodes;
+        return predicate.parameterIndex >= 0 && predicate.parameterIndex < args.length
+            ? args[predicate.parameterIndex]
+            : undefined;
+    }
+    const invoked = skipParentheses(getExpression(call));
+    return invoked.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || invoked.kind === 213 /* SyntaxKind.ElementAccessExpression */
+        ? skipParentheses(getExpression(invoked))
+        : undefined;
+}
+function narrowTypeByBinaryExpression(c, f, t, expr, assumeTrue) {
+    const operator = expr.operatorToken.kind;
+    switch (operator) {
+        case 63 /* SyntaxKind.EqualsToken */:
+        case 75 /* SyntaxKind.BarBarEqualsToken */:
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            return narrowTypeByTruthiness(c, f, narrowType(c, f, t, expr.right, assumeTrue), expr.left, assumeTrue);
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+        case 36 /* SyntaxKind.EqualsEqualsEqualsToken */:
+        case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: {
+            const left = getReferenceCandidate(expr.left);
+            const right = getReferenceCandidate(expr.right);
+            if (left.kind === 222 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(right))
+                return narrowTypeByTypeof(c, f, t, left, operator, right, assumeTrue);
+            if (right.kind === 222 /* SyntaxKind.TypeOfExpression */ && isStringLiteralLike(left))
+                return narrowTypeByTypeof(c, f, t, right, operator, left, assumeTrue);
+            if (isMatchingReference(c, f.reference, left))
+                return narrowTypeByEquality(c, t, operator, right, assumeTrue);
+            if (isMatchingReference(c, f.reference, right))
+                return narrowTypeByEquality(c, t, operator, left, assumeTrue);
+            if (c.strictNullChecks) {
+                if (optionalChainContainsReference(c, left, f.reference))
+                    t = narrowTypeByOptionalChainContainment(c, t, operator, right, assumeTrue);
+                else if (optionalChainContainsReference(c, right, f.reference))
+                    t = narrowTypeByOptionalChainContainment(c, t, operator, left, assumeTrue);
+            }
+            const leftAccess = getDiscriminantPropertyAccess(c, f, left, t);
+            if (leftAccess !== undefined)
+                return narrowTypeByDiscriminantProperty(c, t, leftAccess, operator, right, assumeTrue);
+            const rightAccess = getDiscriminantPropertyAccess(c, f, right, t);
+            if (rightAccess !== undefined)
+                return narrowTypeByDiscriminantProperty(c, t, rightAccess, operator, left, assumeTrue);
+            if (isMatchingConstructorReference(c, f, left))
+                return narrowTypeByConstructor(c, t, operator, right, assumeTrue);
+            if (isMatchingConstructorReference(c, f, right))
+                return narrowTypeByConstructor(c, t, operator, left, assumeTrue);
+            if (isBooleanLiteral(right) && !isAccessExpression(left))
+                return narrowTypeByBooleanComparison(c, f, t, left, right, operator, assumeTrue);
+            if (isBooleanLiteral(left) && !isAccessExpression(right))
+                return narrowTypeByBooleanComparison(c, f, t, right, left, operator, assumeTrue);
+            break;
+        }
+        case 103 /* SyntaxKind.InstanceOfKeyword */:
+            return narrowTypeByInstanceof(c, f, t, expr, assumeTrue);
+        case 102 /* SyntaxKind.InKeyword */: {
+            if (expr.left.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+                return narrowTypeByPrivateIdentifierInInExpression(c, f, t, expr, assumeTrue);
+            const target = getReferenceCandidate(expr.right);
+            if (containsMissingType(c, t) &&
+                isAccessExpression(f.reference) &&
+                isMatchingReference(c, getExpression(f.reference), target)) {
+                const leftType = getTypeOfExpression(c, expr.left);
+                if (isTypeUsableAsPropertyName(leftType) &&
+                    getAccessedPropertyName(c, f.reference) === getPropertyNameFromType(leftType))
+                    return getTypeWithFacts(c, t, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */);
+            }
+            if (isMatchingReference(c, f.reference, target)) {
+                const leftType = getTypeOfExpression(c, expr.left);
+                if (isTypeUsableAsPropertyName(leftType))
+                    return narrowTypeByInKeyword(c, t, leftType, assumeTrue);
+            }
+            break;
+        }
+        case 27 /* SyntaxKind.CommaToken */:
+            return narrowType(c, f, t, expr.right, assumeTrue);
+        case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+            if (assumeTrue)
+                return narrowType(c, f, narrowType(c, f, t, expr.left, true), expr.right, true);
+            return getUnionType(c, [narrowType(c, f, t, expr.left, false), narrowType(c, f, t, expr.right, false)]);
+        case 56 /* SyntaxKind.BarBarToken */:
+            if (assumeTrue)
+                return getUnionType(c, [narrowType(c, f, t, expr.left, true), narrowType(c, f, t, expr.right, true)]);
+            return narrowType(c, f, narrowType(c, f, t, expr.left, false), expr.right, false);
+    }
+    return t;
+}
+function narrowTypeByPrivateIdentifierInInExpression(c, f, t, expr, assumeTrue) {
+    if (!isMatchingReference(c, f.reference, getReferenceCandidate(expr.right)))
+        return t;
+    const symbol = getSymbolForPrivateIdentifierExpression(c, expr.left);
+    if (symbol === undefined)
+        return t;
+    const classSymbol = symbol.parent;
+    const targetType = hasStaticModifier(symbol.valueDeclaration)
+        ? getTypeOfSymbol(c, classSymbol)
+        : getDeclaredTypeOfSymbol(c, classSymbol);
+    return getNarrowedType(c, t, targetType, assumeTrue, true);
+}
+function isBooleanLiteral(node) {
+    return node.kind === 111 /* SyntaxKind.TrueKeyword */ || node.kind === 96 /* SyntaxKind.FalseKeyword */;
+}
+function isAccessExpression(node) {
+    return node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 213 /* SyntaxKind.ElementAccessExpression */;
+}
+function isStringLiteralLike(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
+}
+function narrowTypeByBooleanComparison(c, f, t, expr, boolValue, operator, assumeTrue) {
+    const isEquality = operator !== 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ && operator !== 35 /* SyntaxKind.ExclamationEqualsToken */;
+    return narrowType(c, f, t, expr, (assumeTrue !== (boolValue.kind === 111 /* SyntaxKind.TrueKeyword */)) !== isEquality);
+}
+function narrowTypeByEquality(c, t, operator, value, assumeTrueIn) {
+    if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+        return t;
+    let assumeTrue = assumeTrueIn;
+    if (operator === 35 /* SyntaxKind.ExclamationEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */)
+        assumeTrue = !assumeTrue;
+    const valueType = getTypeOfExpression(c, value);
+    const doubleEquals = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */;
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return narrowTypeByEqualityWorker(c, t, valueType, doubleEquals, assumeTrue);
+    // The result depends only on the types and the operator, and each flow walk through a condition
+    // narrows the same union again: cache it.
+    const bits = 8 | (doubleEquals ? 2 : 0) | (assumeTrue ? 1 : 0);
+    const pair = cachedTypePairKey(t.id, valueType.id, bits);
+    const key = pair < 0 ? 'narrowedByEquality' + t.id + ',' + valueType.id + ',' + bits : '';
+    let result = pair < 0 ? c.cachedTypes.get(key) : c.cachedTypesByPair.get(pair);
+    if (result === undefined) {
+        result = narrowTypeByEqualityWorker(c, t, valueType, doubleEquals, assumeTrue);
+        if (pair < 0)
+            c.cachedTypes.set(key, result);
+        else
+            c.cachedTypesByPair.set(pair, result);
+    }
+    return result;
+}
+function narrowTypeByEqualityWorker(c, t, valueType, doubleEquals, assumeTrue) {
+    if ((valueType.flags & 12 /* TypeFlags.Nullable */) !== 0) {
+        if (!c.strictNullChecks)
+            return t;
+        let facts;
+        if (doubleEquals)
+            facts = assumeTrue ? 262144 /* TypeFacts.EQUndefinedOrNull */ : 2097152 /* TypeFacts.NEUndefinedOrNull */;
+        else if ((valueType.flags & 8 /* TypeFlags.Null */) !== 0)
+            facts = assumeTrue ? 131072 /* TypeFacts.EQNull */ : 1048576 /* TypeFacts.NENull */;
+        else
+            facts = assumeTrue ? 65536 /* TypeFacts.EQUndefined */ : 524288 /* TypeFacts.NEUndefined */;
+        return getAdjustedTypeWithFacts(c, t, facts);
+    }
+    if (assumeTrue) {
+        if (!doubleEquals &&
+            ((t.flags & 2 /* TypeFlags.Unknown */) !== 0 || someType(t, (u) => isEmptyAnonymousObjectType(c, u)))) {
+            if ((valueType.flags & (12713980 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0 ||
+                isEmptyAnonymousObjectType(c, valueType))
+                return valueType;
+            if ((valueType.flags & 1048576 /* TypeFlags.Object */) !== 0)
+                return c.nonPrimitiveType;
+        }
+        const filtered = filterType(c, t, (u) => areTypesComparable(c, u, valueType) || (doubleEquals && isCoercibleUnderDoubleEquals(u, valueType)));
+        return replacePrimitivesWithLiterals(c, filtered, valueType);
+    }
+    if (isUnitType(valueType))
+        return filterType(c, t, (u) => !(isUnitLikeType(u) && areTypesComparable(c, u, valueType)));
+    return t;
+}
+function isCoercibleUnderDoubleEquals(source, target) {
+    return ((source.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */ | 8192 /* TypeFlags.BooleanLiteral */)) !== 0 &&
+        (target.flags & (64 /* TypeFlags.Number */ | 32 /* TypeFlags.String */ | 256 /* TypeFlags.Boolean */)) !== 0);
+}
+function isUnitLikeType(t) {
+    return extractUnitType(t) !== undefined;
+}
+/** `t`, or the first unit type of intersection `t`; undefined when `t` isn't unit-like. */
+function extractUnitType(t) {
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) === 0)
+        return isUnitType(t) ? t : undefined;
+    for (const u of typesOf(t))
+        if (isUnitType(u))
+            return u;
+    return undefined;
+}
+function replacePrimitivesWithLiterals(c, typeWithPrimitives, typeWithLiterals) {
+    if (maybeTypeOfKind(typeWithPrimitives, 32 /* TypeFlags.String */ | 4194304 /* TypeFlags.TemplateLiteral */ | 64 /* TypeFlags.Number */ | 128 /* TypeFlags.BigInt */) &&
+        maybeTypeOfKind(typeWithLiterals, 1024 /* TypeFlags.StringLiteral */ |
+            4194304 /* TypeFlags.TemplateLiteral */ |
+            8388608 /* TypeFlags.StringMapping */ |
+            2048 /* TypeFlags.NumberLiteral */ |
+            4096 /* TypeFlags.BigIntLiteral */)) {
+        return mapType(c, typeWithPrimitives, (t) => {
+            if ((t.flags & 32 /* TypeFlags.String */) !== 0)
+                return extractTypesOfKind(c, typeWithLiterals, 32 /* TypeFlags.String */ | 1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */);
+            if (isPatternLiteralType(c, t) &&
+                !maybeTypeOfKind(typeWithLiterals, 32 /* TypeFlags.String */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */))
+                return extractTypesOfKind(c, typeWithLiterals, 1024 /* TypeFlags.StringLiteral */);
+            if ((t.flags & 64 /* TypeFlags.Number */) !== 0)
+                return extractTypesOfKind(c, typeWithLiterals, 64 /* TypeFlags.Number */ | 2048 /* TypeFlags.NumberLiteral */);
+            if ((t.flags & 128 /* TypeFlags.BigInt */) !== 0)
+                return extractTypesOfKind(c, typeWithLiterals, 128 /* TypeFlags.BigInt */ | 4096 /* TypeFlags.BigIntLiteral */);
+            return t;
+        });
+    }
+    return typeWithPrimitives;
+}
+function extractTypesOfKind(c, t, kind) {
+    return filterType(c, t, (u) => (u.flags & kind) !== 0);
+}
+function narrowTypeByTypeof(c, f, t, typeOfExpr, operator, literal, assumeTrueIn) {
+    let assumeTrue = assumeTrueIn;
+    if (operator === 35 /* SyntaxKind.ExclamationEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */)
+        assumeTrue = !assumeTrue;
+    const target = getReferenceCandidate(getExpression(typeOfExpr));
+    const text = getText(literal);
+    if (!isMatchingReference(c, f.reference, target)) {
+        if (c.strictNullChecks &&
+            optionalChainContainsReference(c, target, f.reference) &&
+            assumeTrue === (text !== 'undefined'))
+            t = getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */);
+        const access = getDiscriminantPropertyAccess(c, f, target, t);
+        if (access !== undefined)
+            return narrowTypeByDiscriminant(c, t, access, (u) => narrowTypeByLiteralExpression(c, u, text, assumeTrue));
+        return t;
+    }
+    return narrowTypeByLiteralExpression(c, t, text, assumeTrue);
+}
+function typeofNEFacts(text) {
+    switch (text) {
+        case 'string':
+            return 256 /* TypeFacts.TypeofNEString */;
+        case 'number':
+            return 512 /* TypeFacts.TypeofNENumber */;
+        case 'bigint':
+            return 1024 /* TypeFacts.TypeofNEBigInt */;
+        case 'boolean':
+            return 2048 /* TypeFacts.TypeofNEBoolean */;
+        case 'symbol':
+            return 4096 /* TypeFacts.TypeofNESymbol */;
+        case 'undefined':
+            return 524288 /* TypeFacts.NEUndefined */;
+        case 'object':
+            return 8192 /* TypeFacts.TypeofNEObject */;
+        case 'function':
+            return 16384 /* TypeFacts.TypeofNEFunction */;
+    }
+    return 32768 /* TypeFacts.TypeofNEHostObject */;
+}
+function narrowTypeByLiteralExpression(c, t, text, assumeTrue) {
+    return assumeTrue ? narrowTypeByTypeName(c, t, text) : getAdjustedTypeWithFacts(c, t, typeofNEFacts(text));
+}
+function narrowTypeByTypeName(c, t, typeName) {
+    switch (typeName) {
+        case 'string':
+            return narrowTypeByTypeFacts(c, t, c.stringType, 1 /* TypeFacts.TypeofEQString */);
+        case 'number':
+            return narrowTypeByTypeFacts(c, t, c.numberType, 2 /* TypeFacts.TypeofEQNumber */);
+        case 'bigint':
+            return narrowTypeByTypeFacts(c, t, c.bigintType, 4 /* TypeFacts.TypeofEQBigInt */);
+        case 'boolean':
+            return narrowTypeByTypeFacts(c, t, c.booleanType, 8 /* TypeFacts.TypeofEQBoolean */);
+        case 'symbol':
+            return narrowTypeByTypeFacts(c, t, c.esSymbolType, 16 /* TypeFacts.TypeofEQSymbol */);
+        case 'object':
+            if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+                return t;
+            return getUnionType(c, [
+                narrowTypeByTypeFacts(c, t, c.nonPrimitiveType, 32 /* TypeFacts.TypeofEQObject */),
+                narrowTypeByTypeFacts(c, t, c.nullType, 131072 /* TypeFacts.EQNull */),
+            ]);
+        case 'function':
+            if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+                return t;
+            return narrowTypeByTypeFacts(c, t, c.globalFunctionType, 64 /* TypeFacts.TypeofEQFunction */);
+        case 'undefined':
+            return narrowTypeByTypeFacts(c, t, c.undefinedType, 65536 /* TypeFacts.EQUndefined */);
+    }
+    return narrowTypeByTypeFacts(c, t, c.nonPrimitiveType, 128 /* TypeFacts.TypeofEQHostObject */);
+}
+function narrowTypeByTypeFacts(c, t, impliedType, facts) {
+    return mapType(c, t, (u) => {
+        if (isTypeRelatedTo(c, u, impliedType, c.strictSubtypeRelation))
+            return hasTypeFacts(c, u, facts) ? u : c.neverType;
+        if (isTypeSubtypeOf(c, impliedType, u))
+            return impliedType;
+        if (hasTypeFacts(c, u, facts))
+            return getIntersectionType(c, [u, impliedType]);
+        return c.neverType;
+    });
+}
+function narrowTypeByOptionalChainContainment(c, t, operator, value, assumeTrue) {
+    const equalsOperator = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */;
+    const nullableFlags = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */
+        ? 12 /* TypeFlags.Nullable */
+        : 4 /* TypeFlags.Undefined */;
+    const valueType = getTypeOfExpression(c, value);
+    const removeNullable = (equalsOperator !== assumeTrue && everyType(valueType, (u) => (u.flags & nullableFlags) !== 0)) ||
+        (equalsOperator === assumeTrue &&
+            everyType(valueType, (u) => (u.flags & (3 /* TypeFlags.AnyOrUnknown */ | nullableFlags)) === 0));
+    return removeNullable ? getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */) : t;
+}
+function narrowTypeByInstanceof(c, f, t, expr, assumeTrue) {
+    const left = getReferenceCandidate(expr.left);
+    if (!isMatchingReference(c, f.reference, left)) {
+        if (assumeTrue && c.strictNullChecks && optionalChainContainsReference(c, left, f.reference))
+            return getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */);
+        return t;
+    }
+    const rightType = getTypeOfExpression(c, expr.right);
+    if (!isTypeDerivedFrom(c, rightType, c.globalObjectType))
+        return t;
+    // A `[Symbol.hasInstance]` method with a type predicate narrows like a type guard call.
+    const signature = getEffectsSignature(c, expr);
+    const predicate = signature !== undefined ? getTypePredicateOfSignature(c, signature) : undefined;
+    if (predicate !== undefined && predicate.kind === 1 /* TypePredicateKind.Identifier */ && predicate.parameterIndex === 0)
+        return getNarrowedType(c, t, predicate.type, assumeTrue, true);
+    if (!isTypeDerivedFrom(c, rightType, c.globalFunctionType))
+        return t;
+    const instanceType = mapType(c, rightType, (u) => getInstanceType(c, u));
+    if (((t.flags & 1 /* TypeFlags.Any */) !== 0 &&
+        (instanceType === c.globalObjectType || instanceType === c.globalFunctionType)) ||
+        (!assumeTrue && !((instanceType.flags & 1048576 /* TypeFlags.Object */) !== 0 && !isEmptyAnonymousObjectType(c, instanceType))))
+        return t;
+    return getNarrowedType(c, t, instanceType, assumeTrue, true);
+}
+function getInstanceType(c, constructorType) {
+    const prototypeType = getTypeOfPropertyOfType(c, constructorType, 'prototype');
+    if (prototypeType !== undefined && (prototypeType.flags & 1 /* TypeFlags.Any */) === 0)
+        return prototypeType;
+    const signatures = getSignaturesOfType(c, constructorType, 1 /* SignatureKind.Construct */);
+    if (signatures.length === 0)
+        return c.emptyObjectType;
+    const types = [];
+    for (const s of signatures)
+        types.push(getReturnTypeOfSignature(c, getErasedSignature(c, s)));
+    return getUnionType(c, types);
+}
+function narrowTypeByInKeyword(c, t, nameType, assumeTrue) {
+    const name = getPropertyNameFromType(nameType);
+    if (someType(t, (u) => isTypePresencePossible(c, u, name, true)))
+        return filterType(c, t, (u) => isTypePresencePossible(c, u, name, assumeTrue));
+    // `"x" in t` for an unknown property x narrows t to `t & Record<"x", unknown>`.
+    if (assumeTrue) {
+        const record = getGlobalTypeAliasSymbol(c, 'Record', 2, true);
+        if (record !== undefined)
+            return getIntersectionType(c, [t, getTypeAliasInstantiation(c, record, [nameType, c.unknownType], undefined)]);
+    }
+    return t;
+}
+function isTypePresencePossible(c, t, propName, assumeTrue) {
+    const prop = getPropertyOfType(c, t, propName);
+    if (prop !== undefined)
+        return (prop.flags & 16777216 /* SymbolFlags.Optional */) !== 0 || (prop.checkFlags & 48 /* CheckFlags.Partial */) !== 0 || assumeTrue;
+    return getApplicableIndexInfoForName(c, t, propName) !== undefined || !assumeTrue;
+}
+/** `t` narrowed to `candidate` (or with it removed when `assumeTrue` is false). */
+export function getNarrowedType(c, t, candidate, assumeTrue, checkDerived) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return getNarrowedTypeWorker(c, t, candidate, assumeTrue, checkDerived);
+    const pair = cachedTypePairKey(t.id, candidate.id, 4 | (assumeTrue ? 2 : 0) | (checkDerived ? 1 : 0));
+    const key = pair < 0 ? 'narrowed' + t.id + ',' + candidate.id + (assumeTrue ? 't' : 'f') + (checkDerived ? 'd' : '') : '';
+    let result = pair < 0 ? c.cachedTypes.get(key) : c.cachedTypesByPair.get(pair);
+    if (result === undefined) {
+        result = getNarrowedTypeWorker(c, t, candidate, assumeTrue, checkDerived);
+        if (pair < 0)
+            c.cachedTypes.set(key, result);
+        else
+            c.cachedTypesByPair.set(pair, result);
+    }
+    return result;
+}
+function getNarrowedTypeWorker(c, typeIn, candidate, assumeTrue, checkDerived) {
+    let t = typeIn;
+    if (!assumeTrue) {
+        if (t === candidate)
+            return c.neverType;
+        if (checkDerived)
+            return filterType(c, t, (u) => !isTypeDerivedFrom(c, u, candidate));
+        if ((t.flags & 2 /* TypeFlags.Unknown */) !== 0)
+            t = c.unknownUnionType;
+        const trueType = getNarrowedType(c, t, candidate, true, false);
+        return recombineUnknownType(c, filterType(c, t, (u) => !isTypeSubsetOf(c, u, trueType)));
+    }
+    if ((t.flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0)
+        return candidate;
+    if (t === candidate)
+        return candidate;
+    const keyPropertyName = (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? getKeyPropertyName(c, t) : '';
+    const narrowedType = mapType(c, candidate, (n) => {
+        let matching = t;
+        if (keyPropertyName !== '') {
+            const discriminant = getTypeOfPropertyOfType(c, n, keyPropertyName);
+            if (discriminant !== undefined) {
+                const constituent = getConstituentTypeForKeyType(c, t, discriminant);
+                if (constituent !== undefined)
+                    matching = constituent;
+            }
+        }
+        const directlyRelated = mapType(c, matching, (u) => {
+            if (checkDerived) {
+                if (isTypeDerivedFrom(c, u, n))
+                    return u;
+                if (isTypeDerivedFrom(c, n, u))
+                    return n;
+                return c.neverType;
+            }
+            if (isTypeStrictSubtypeOf(c, u, n))
+                return u;
+            if (isTypeStrictSubtypeOf(c, n, u))
+                return n;
+            if (isTypeSubtypeOf(c, u, n))
+                return u;
+            if (isTypeSubtypeOf(c, n, u))
+                return n;
+            return c.neverType;
+        });
+        if ((directlyRelated.flags & 262144 /* TypeFlags.Never */) === 0)
+            return directlyRelated;
+        return mapType(c, t, (u) => {
+            if (maybeTypeOfKind(u, 132644864 /* TypeFlags.Instantiable */)) {
+                const constraint = getBaseConstraintOfType(c, u);
+                if (constraint === undefined ||
+                    (checkDerived ? isTypeDerivedFrom(c, n, constraint) : isTypeSubtypeOf(c, n, constraint)))
+                    return getIntersectionType(c, [u, n]);
+            }
+            return c.neverType;
+        });
+    });
+    if ((narrowedType.flags & 262144 /* TypeFlags.Never */) === 0)
+        return narrowedType;
+    if (isTypeSubtypeOf(c, candidate, t))
+        return candidate;
+    if (isTypeAssignableTo(c, t, candidate))
+        return t;
+    if (isTypeAssignableTo(c, candidate, t))
+        return candidate;
+    return getIntersectionType(c, [t, candidate]);
+}
+// ---- Discriminants
+function getDiscriminantPropertyAccess(c, f, expr, computedType) {
+    if ((f.declaredType.flags & 134217728 /* TypeFlags.Union */) === 0 && (computedType.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return undefined;
+    const access = getCandidateDiscriminantPropertyAccess(c, f, expr);
+    if (access === undefined)
+        return undefined;
+    const name = getAccessedPropertyName(c, access);
+    if (name === undefined)
+        return undefined;
+    const t = (f.declaredType.flags & 134217728 /* TypeFlags.Union */) !== 0 && isTypeSubsetOf(c, computedType, f.declaredType)
+        ? f.declaredType
+        : computedType;
+    return isDiscriminantProperty(c, t, name) ? access : undefined;
+}
+function getCandidateDiscriminantPropertyAccess(c, f, expr) {
+    const reference = f.reference;
+    if (reference.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
+        reference.kind === 208 /* SyntaxKind.ArrayBindingPattern */ ||
+        reference.kind === 219 /* SyntaxKind.FunctionExpression */ ||
+        reference.kind === 220 /* SyntaxKind.ArrowFunction */ ||
+        isObjectLiteralMethod(reference)) {
+        // A pseudo-reference from getNarrowedTypeOfSymbol: a sibling destructured variable or parameter is a candidate.
+        if (expr.kind !== 79 /* SyntaxKind.Identifier */)
+            return undefined;
+        const declaration = getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, expr)).valueDeclaration;
+        if (declaration !== undefined &&
+            (declaration.kind === 209 /* SyntaxKind.BindingElement */ || declaration.kind === 170 /* SyntaxKind.Parameter */) &&
+            declaration.parent === reference &&
+            getInitializer(declaration) === undefined &&
+            (declaration.kind === 209 /* SyntaxKind.BindingElement */
+                ? declaration.dotDotDotToken
+                : getDotDotDotToken(declaration)) === undefined)
+            return declaration;
+        return undefined;
+    }
+    if (isAccessExpression(expr))
+        return isMatchingReference(c, reference, getExpression(expr)) ? expr : undefined;
+    if (expr.kind === 79 /* SyntaxKind.Identifier */) {
+        const symbol = getResolvedSymbol(c, expr);
+        if (isConstantVariable(c, symbol)) {
+            const declaration = symbol.valueDeclaration;
+            // `const x = obj.kind` makes `x` an alias of `obj.kind`.
+            const initializer = getCandidateVariableDeclarationInitializer(declaration);
+            if (initializer !== undefined &&
+                isAccessExpression(initializer) &&
+                isMatchingReference(c, reference, getExpression(initializer)))
+                return initializer;
+            // `const { kind: x } = obj` makes `x` an alias of `obj.kind`.
+            if (declaration !== undefined &&
+                declaration.kind === 209 /* SyntaxKind.BindingElement */ &&
+                getInitializer(declaration) === undefined) {
+                const parentInitializer = getCandidateVariableDeclarationInitializer(declaration.parent.parent);
+                if (parentInitializer !== undefined &&
+                    (parentInitializer.kind === 79 /* SyntaxKind.Identifier */ || isAccessExpression(parentInitializer)) &&
+                    isMatchingReference(c, reference, parentInitializer))
+                    return declaration;
+            }
+        }
+    }
+    return undefined;
+}
+function getCandidateVariableDeclarationInitializer(node) {
+    if (node === undefined || node.kind !== 261 /* SyntaxKind.VariableDeclaration */ || getType(node) !== undefined)
+        return undefined;
+    const initializer = getInitializer(node);
+    return initializer !== undefined ? skipParentheses(initializer) : undefined;
+}
+function narrowTypeByDiscriminant(c, t, access, narrow) {
+    const propName = getAccessedPropertyName(c, access);
+    if (propName === undefined)
+        return t;
+    const optionalChain = isOptionalChain(access);
+    const removeNullable = c.strictNullChecks && (optionalChain || isNonNullAccess(access)) && maybeTypeOfKind(t, 12 /* TypeFlags.Nullable */);
+    const nonNullType = removeNullable ? getTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */) : t;
+    let propType = getTypeOfPropertyOfType(c, nonNullType, propName);
+    if (propType === undefined)
+        return t;
+    if (removeNullable && optionalChain)
+        propType = getOptionalType(c, propType, false);
+    const narrowedPropType = narrow(propType);
+    return filterType(c, t, (u) => {
+        const discriminantType = getTypeOfPropertyOrIndexSignatureOfType(c, u, propName) ?? c.unknownType;
+        return ((discriminantType.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            (narrowedPropType.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            areTypesComparable(c, narrowedPropType, discriminantType));
+    });
+}
+function isNonNullAccess(node) {
+    return isAccessExpression(node) && getExpression(node).kind === 236 /* SyntaxKind.NonNullExpression */;
+}
+function getTypeOfPropertyOrIndexSignatureOfType(c, t, name) {
+    const propType = getTypeOfPropertyOfType(c, t, name);
+    if (propType !== undefined)
+        return propType;
+    const info = getApplicableIndexInfoForName(c, t, name);
+    return info !== undefined ? getOptionalType(c, info.valueType, true) : undefined;
+}
+function narrowTypeByDiscriminantProperty(c, t, access, operator, value, assumeTrue) {
+    if ((operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) &&
+        (t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const keyPropertyName = getKeyPropertyName(c, t);
+        if (keyPropertyName !== '' && keyPropertyName === getAccessedPropertyName(c, access)) {
+            const candidate = getConstituentTypeForKeyType(c, t, getTypeOfExpression(c, value));
+            if (candidate !== undefined) {
+                if ((assumeTrue && operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */) ||
+                    (!assumeTrue && operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */))
+                    return candidate;
+                const propType = getTypeOfPropertyOfType(c, candidate, keyPropertyName);
+                return propType !== undefined && isUnitType(propType) ? removeType(c, t, candidate) : t;
+            }
+        }
+    }
+    return narrowTypeByDiscriminant(c, t, access, (u) => narrowTypeByEquality(c, u, operator, value, assumeTrue));
+}
+/** The name of a property usable to index the constituents of a large union by literal values, or ''. */
+export function getKeyPropertyName(c, t) {
+    const side = sideOf(c, t);
+    if (side.keyPropertyName === '')
+        computeKeyPropertyNameAndMap(c, t, side);
+    return side.keyPropertyName === "\uFFFEmissing" /* InternalSymbolName.Missing */ ? '' : side.keyPropertyName;
+}
+export function getConstituentTypeForKeyType(c, t, keyType) {
+    const result = sideOf(c, t).constituentMap?.get(getRegularTypeOfLiteralType(c, keyType));
+    return result !== c.unknownType ? result : undefined;
+}
+/** Computes the key property of `t` and its constituents by key into `side`, the holder of its state. */
+function computeKeyPropertyNameAndMap(c, t, side) {
+    side.keyPropertyName = "\uFFFEmissing" /* InternalSymbolName.Missing */;
+    const types = t.types;
+    let objectCount = 0;
+    for (const u of types)
+        if ((u.flags & (1048576 /* TypeFlags.Object */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) !== 0)
+            objectCount++;
+    if (types.length < 10 || (t.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) !== 0 || objectCount < 10)
+        return;
+    let keyPropertyName = '';
+    for (const u of types) {
+        if (keyPropertyName !== '')
+            break;
+        if ((u.flags & (1048576 /* TypeFlags.Object */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) === 0)
+            continue;
+        for (const p of getPropertiesOfType(c, u)) {
+            if (isUnitType(getTypeOfSymbol(c, p))) {
+                keyPropertyName = p.name;
+                break;
+            }
+        }
+    }
+    if (keyPropertyName === '')
+        return;
+    const map = new Map();
+    let count = 0;
+    for (const u of types) {
+        if ((u.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) === 0)
+            continue;
+        const discriminant = getTypeOfPropertyOfType(c, u, keyPropertyName);
+        if (discriminant === undefined || !isLiteralType(discriminant))
+            return;
+        let duplicate = false;
+        for (const d of (discriminant.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(discriminant) : [discriminant]) {
+            const key = getRegularTypeOfLiteralType(c, d);
+            const existing = map.get(key);
+            if (existing === undefined)
+                map.set(key, u);
+            else if (existing !== c.unknownType) {
+                map.set(key, c.unknownType);
+                duplicate = true;
+            }
+        }
+        if (!duplicate)
+            count++;
+    }
+    if (count >= 10 && count * 2 >= types.length) {
+        side.keyPropertyName = keyPropertyName;
+        side.constituentMap = map;
+    }
+}
+// ---- Switch statements
+function getTypeAtSwitchClause(c, f, flow) {
+    const statement = flow.switchStatement;
+    const expr = skipParentheses(statement.expression);
+    const flowType = getTypeAtFlowNode(c, f, flow.antecedent);
+    const incomplete = f.incomplete;
+    let t = flowType;
+    if (isMatchingReference(c, f.reference, expr))
+        t = narrowTypeBySwitchOnDiscriminant(c, t, flow);
+    else if (expr.kind === 222 /* SyntaxKind.TypeOfExpression */ && isMatchingReference(c, f.reference, getExpression(expr)))
+        t = narrowTypeBySwitchOnTypeOf(c, t, flow);
+    else if (expr.kind === 111 /* SyntaxKind.TrueKeyword */)
+        t = narrowTypeBySwitchOnTrue(c, f, t, flow);
+    else {
+        if (c.strictNullChecks) {
+            if (optionalChainContainsReference(c, expr, f.reference))
+                t = narrowTypeBySwitchOptionalChainContainment(c, t, flow, (u) => (u.flags & (4 /* TypeFlags.Undefined */ | 262144 /* TypeFlags.Never */)) === 0);
+            else if (expr.kind === 222 /* SyntaxKind.TypeOfExpression */ &&
+                optionalChainContainsReference(c, getExpression(expr), f.reference))
+                t = narrowTypeBySwitchOptionalChainContainment(c, t, flow, (u) => !((u.flags & 262144 /* TypeFlags.Never */) !== 0 ||
+                    ((u.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && u.stringValue === 'undefined')));
+        }
+        const access = getDiscriminantPropertyAccess(c, f, expr, t);
+        if (access !== undefined)
+            t = narrowTypeBySwitchOnDiscriminantProperty(c, t, access, flow);
+    }
+    return newFlowType(c, f, t, incomplete);
+}
+function narrowTypeBySwitchOptionalChainContainment(c, t, flow, clauseCheck) {
+    if (flow.clauseStart === flow.clauseEnd)
+        return t;
+    const clauseTypes = getSwitchClauseTypes(c, flow.switchStatement);
+    for (let i = flow.clauseStart; i < flow.clauseEnd; i++)
+        if (!clauseCheck(clauseTypes[i]))
+            return t;
+    return getTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */);
+}
+function narrowTypeBySwitchOnDiscriminantProperty(c, t, access, flow) {
+    if (flow.clauseStart < flow.clauseEnd && (t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const accessedName = getAccessedPropertyName(c, access);
+        if (accessedName !== undefined && accessedName !== '' && getKeyPropertyName(c, t) === accessedName) {
+            const clauseTypes = getSwitchClauseTypes(c, flow.switchStatement);
+            const types = [];
+            for (let i = flow.clauseStart; i < flow.clauseEnd && i < clauseTypes.length; i++)
+                types.push(getConstituentTypeForKeyType(c, t, clauseTypes[i]) ?? c.unknownType);
+            const candidate = getUnionType(c, types);
+            if (candidate !== c.unknownType)
+                return candidate;
+        }
+    }
+    return narrowTypeByDiscriminant(c, t, access, (u) => narrowTypeBySwitchOnDiscriminant(c, u, flow));
+}
+function getClauses(statement) {
+    return statement.caseBlock.clauses.nodes;
+}
+function getSwitchClauseTypes(c, statement) {
+    const links = c.nodeLinks(statement);
+    if (links.switchTypes === undefined) {
+        const types = [];
+        for (const clause of getClauses(statement)) {
+            const expr = clause.expression;
+            types.push(expr !== undefined ? getRegularTypeOfLiteralType(c, getTypeOfExpression(c, expr)) : c.neverType);
+        }
+        links.switchTypes = types;
+    }
+    return links.switchTypes;
+}
+function narrowTypeBySwitchOnDiscriminant(c, t, flow) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return narrowTypeBySwitchOnDiscriminantWorker(c, t, flow);
+    // As in narrowTypeByEquality, each union is narrowed by each range of clauses once.
+    const key = 'narrowedBySwitch' + t.id + ',' + getNodeId(flow.switchStatement) + ',' + flow.clauseStart + ',' + flow.clauseEnd;
+    let result = c.cachedTypes.get(key);
+    if (result === undefined) {
+        result = narrowTypeBySwitchOnDiscriminantWorker(c, t, flow);
+        c.cachedTypes.set(key, result);
+    }
+    return result;
+}
+function narrowTypeBySwitchOnDiscriminantWorker(c, t, flow) {
+    const switchTypes = getSwitchClauseTypes(c, flow.switchStatement);
+    if (switchTypes.length === 0)
+        return t;
+    const clauseTypes = switchTypes.slice(flow.clauseStart, flow.clauseEnd);
+    const hasDefaultClause = flow.clauseStart === flow.clauseEnd || clauseTypes.includes(c.neverType);
+    if ((t.flags & 2 /* TypeFlags.Unknown */) !== 0 && !hasDefaultClause) {
+        const ground = [];
+        for (const s of clauseTypes) {
+            if ((s.flags & (12713980 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0)
+                ground.push(s);
+            else if ((s.flags & 1048576 /* TypeFlags.Object */) !== 0)
+                ground.push(c.nonPrimitiveType);
+            else
+                return t;
+        }
+        return getUnionType(c, ground);
+    }
+    const discriminantType = getUnionType(c, clauseTypes);
+    const caseType = (discriminantType.flags & 262144 /* TypeFlags.Never */) !== 0
+        ? c.neverType
+        : replacePrimitivesWithLiterals(c, filterType(c, t, (u) => areTypesComparable(c, discriminantType, u)), discriminantType);
+    if (!hasDefaultClause)
+        return caseType;
+    const defaultType = filterType(c, t, (u) => {
+        const unit = extractUnitType(u);
+        if (unit === undefined)
+            return true;
+        const v = (u.flags & 4 /* TypeFlags.Undefined */) !== 0 ? c.undefinedType : getRegularTypeOfLiteralType(c, unit);
+        for (const st of switchTypes)
+            if (isUnitType(st) && areTypesComparable(c, st, v))
+                return false;
+        return true;
+    });
+    if ((caseType.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return defaultType;
+    return getUnionType(c, [caseType, defaultType]);
+}
+function getSwitchClauseTypeOfWitnesses(c, statement) {
+    const links = c.nodeLinks(statement);
+    if (links.switchWitnesses === undefined) {
+        const witnesses = [];
+        let valid = true;
+        for (const clause of getClauses(statement)) {
+            const expr = clause.expression;
+            if (expr === undefined) {
+                witnesses.push('');
+                continue;
+            }
+            if (!isStringLiteralLike(expr)) {
+                valid = false;
+                break;
+            }
+            const text = getText(expr);
+            witnesses.push(witnesses.includes(text) ? '' : text);
+        }
+        links.switchWitnesses = valid ? witnesses : [];
+        links.switchWitnessesValid = valid;
+    }
+    return links.switchWitnessesValid ? links.switchWitnesses : undefined;
+}
+function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) {
+    let facts = 0 /* TypeFacts.None */;
+    for (let i = 0; i < witnesses.length; i++)
+        if ((i < start || i >= end) && witnesses[i] !== '')
+            facts |= typeofNEFacts(witnesses[i]);
+    return facts;
+}
+function getDefaultClauseIndex(statement) {
+    const clauses = getClauses(statement);
+    for (let i = 0; i < clauses.length; i++)
+        if (clauses[i].kind === 298 /* SyntaxKind.DefaultClause */)
+            return i;
+    return -1;
+}
+function narrowTypeBySwitchOnTypeOf(c, t, flow) {
+    const witnesses = getSwitchClauseTypeOfWitnesses(c, flow.switchStatement);
+    if (witnesses === undefined)
+        return t;
+    const defaultIndex = getDefaultClauseIndex(flow.switchStatement);
+    const hasDefaultClause = flow.clauseStart === flow.clauseEnd || (defaultIndex >= flow.clauseStart && defaultIndex < flow.clauseEnd);
+    if (hasDefaultClause) {
+        const notEqualFacts = getNotEqualFactsFromTypeofSwitch(flow.clauseStart, flow.clauseEnd, witnesses);
+        return filterType(c, t, (u) => getTypeFacts(c, u, notEqualFacts) === notEqualFacts);
+    }
+    const types = [];
+    for (const text of witnesses.slice(flow.clauseStart, flow.clauseEnd))
+        types.push(text !== '' ? narrowTypeByTypeName(c, t, text) : c.neverType);
+    return getUnionType(c, types);
+}
+function narrowTypeBySwitchOnTrue(c, f, typeIn, flow) {
+    let t = typeIn;
+    const clauses = getClauses(flow.switchStatement);
+    const defaultIndex = getDefaultClauseIndex(flow.switchStatement);
+    const hasDefaultClause = flow.clauseStart === flow.clauseEnd || (defaultIndex >= flow.clauseStart && defaultIndex < flow.clauseEnd);
+    for (let i = 0; i < flow.clauseStart; i++) {
+        const expr = clauses[i].expression;
+        if (expr !== undefined)
+            t = narrowType(c, f, t, expr, false);
+    }
+    if (hasDefaultClause) {
+        for (let i = flow.clauseEnd; i < clauses.length; i++) {
+            const expr = clauses[i].expression;
+            if (expr !== undefined)
+                t = narrowType(c, f, t, expr, false);
+        }
+        return t;
+    }
+    const types = [];
+    for (let i = flow.clauseStart; i < flow.clauseEnd; i++) {
+        const expr = clauses[i].expression;
+        types.push(expr !== undefined ? narrowType(c, f, t, expr, true) : c.neverType);
+    }
+    return getUnionType(c, types);
+}
+/** Whether every value of the switch expression is handled by a case. */
+export function isExhaustiveSwitchStatement(c, statement) {
+    const links = c.nodeLinks(statement);
+    if (links.exhaustiveState === 0) {
+        links.exhaustiveState = 1;
+        const exhaustive = computeExhaustiveSwitchStatement(c, statement);
+        if (links.exhaustiveState === 1)
+            links.exhaustiveState = exhaustive ? 3 : 2;
+    }
+    else if (links.exhaustiveState === 1)
+        links.exhaustiveState = 2;
+    return links.exhaustiveState === 3;
+}
+function computeExhaustiveSwitchStatement(c, statement) {
+    const expression = statement.expression;
+    if (expression.kind === 222 /* SyntaxKind.TypeOfExpression */) {
+        const witnesses = getSwitchClauseTypeOfWitnesses(c, statement);
+        if (witnesses === undefined)
+            return false;
+        const operandConstraint = getBaseConstraintOrType(c, checkExpressionCached(c, getExpression(expression)));
+        const notEqualFacts = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
+        if ((operandConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0)
+            return (556800 /* TypeFacts.AllTypeofNE */ & notEqualFacts) === 556800 /* TypeFacts.AllTypeofNE */;
+        return !someType(operandConstraint, (u) => getTypeFacts(c, u, notEqualFacts) === notEqualFacts);
+    }
+    const t = getBaseConstraintOrType(c, checkExpressionCached(c, expression));
+    if (!isLiteralType(t))
+        return false;
+    const switchTypes = getSwitchClauseTypes(c, statement);
+    if (switchTypes.length === 0)
+        return false;
+    for (const s of switchTypes)
+        if (!isUnitType(s) && (s.flags & 262144 /* TypeFlags.Never */) === 0)
+            return false;
+    const regular = mapType(c, t, (u) => getRegularTypeOfLiteralType(c, u));
+    if ((regular.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return typesOf(regular).every((u) => switchTypes.includes(u));
+    return switchTypes.includes(regular);
+}
+function getBaseConstraintOrType(c, t) {
+    return getBaseConstraintOfType(c, t) ?? t;
+}
+// ---- References
+export function isMatchingReference(c, source, target) {
+    // A declaration's symbol has the declaration's name, and an identifier's text is its name: an
+    // identifier never refers to the variable or binding element of a declaration of another name.
+    if (source.kind === 79 /* SyntaxKind.Identifier */ &&
+        (target.kind === 261 /* SyntaxKind.VariableDeclaration */ || target.kind === 209 /* SyntaxKind.BindingElement */)) {
+        // A cast to one class: a union of the two would be boxed in native builds.
+        const name = target.kind === 261 /* SyntaxKind.VariableDeclaration */
+            ? target.name
+            : target.name;
+        if (name !== undefined &&
+            name.kind === 79 /* SyntaxKind.Identifier */ &&
+            name.text !== source.text)
+            return false;
+    }
+    switch (target.kind) {
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+            return isMatchingReference(c, source, getExpression(target));
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = target;
+            return ((isAssignmentExpression(target, false) && isMatchingReference(c, source, binary.left)) ||
+                (binary.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && isMatchingReference(c, source, binary.right)));
+        }
+    }
+    switch (source.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+            if (isThisInTypeQuery(source))
+                return target.kind === 109 /* SyntaxKind.ThisKeyword */;
+            if (target.kind === 79 /* SyntaxKind.Identifier */)
+                return getResolvedSymbol(c, source) === getResolvedSymbol(c, target);
+            if (target.kind === 261 /* SyntaxKind.VariableDeclaration */ || target.kind === 209 /* SyntaxKind.BindingElement */)
+                return (getExportSymbolOfValueSymbolIfExported(c, getResolvedSymbol(c, source)) === getSymbolOfDeclaration(c, target));
+            return false;
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return target.kind === 109 /* SyntaxKind.ThisKeyword */;
+        case 107 /* SyntaxKind.SuperKeyword */:
+            return target.kind === 107 /* SyntaxKind.SuperKeyword */;
+        case 237 /* SyntaxKind.MetaProperty */:
+            return (target.kind === 237 /* SyntaxKind.MetaProperty */ &&
+                source.keywordToken === target.keywordToken &&
+                source.name.text === target.name.text);
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 239 /* SyntaxKind.SatisfiesExpression */:
+            return isMatchingReference(c, getExpression(source), target);
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            const sourceName = getAccessedPropertyName(c, source);
+            if (sourceName !== undefined && isAccessExpression(target)) {
+                const targetName = getAccessedPropertyName(c, target);
+                if (targetName !== undefined)
+                    return targetName === sourceName && isMatchingReference(c, getExpression(source), getExpression(target));
+            }
+            // `obj[key]` matches `obj[key]` for a key that isn't reassigned.
+            if (source.kind === 213 /* SyntaxKind.ElementAccessExpression */ && target.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+                const sourceArg = source.argumentExpression;
+                const targetArg = target.argumentExpression;
+                if (sourceArg.kind === 79 /* SyntaxKind.Identifier */ && targetArg.kind === 79 /* SyntaxKind.Identifier */) {
+                    const symbol = getResolvedSymbol(c, sourceArg);
+                    if (symbol === getResolvedSymbol(c, targetArg) && isUnreassignedVariable(c, symbol))
+                        return isMatchingReference(c, getExpression(source), getExpression(target));
+                }
+            }
+            return false;
+        }
+        case 167 /* SyntaxKind.QualifiedName */:
+            if (isAccessExpression(target)) {
+                const targetName = getAccessedPropertyName(c, target);
+                if (targetName !== undefined)
+                    return (source.right.text === targetName &&
+                        isMatchingReference(c, source.left, getExpression(target)));
+            }
+            return false;
+        case 227 /* SyntaxKind.BinaryExpression */:
+            return (source.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ &&
+                isMatchingReference(c, source.right, target));
+    }
+    return false;
+}
+/** Whether `expr` is `reference.constructor`. */
+function isMatchingConstructorReference(c, f, expr) {
+    return (isAccessExpression(expr) &&
+        getAccessedPropertyName(c, expr) === 'constructor' &&
+        isMatchingReference(c, f.reference, getExpression(expr)));
+}
+/** Narrows by `x.constructor === C` to the constituents constructed by `C`. */
+function narrowTypeByConstructor(c, t, operator, identifier, assumeTrue) {
+    // Inequality doesn't narrow.
+    if (assumeTrue
+        ? operator !== 34 /* SyntaxKind.EqualsEqualsToken */ && operator !== 36 /* SyntaxKind.EqualsEqualsEqualsToken */
+        : operator !== 35 /* SyntaxKind.ExclamationEqualsToken */ && operator !== 37 /* SyntaxKind.ExclamationEqualsEqualsToken */)
+        return t;
+    const identifierType = getTypeOfExpression(c, identifier);
+    if (!((identifierType.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        getSignaturesOfType(c, identifierType, 0 /* SignatureKind.Call */).length > 0) &&
+        !isConstructorType(c, identifierType))
+        return t;
+    const prototypeProperty = getPropertyOfType(c, identifierType, 'prototype');
+    if (prototypeProperty === undefined)
+        return t;
+    const prototypeType = getTypeOfSymbol(c, prototypeProperty);
+    if ((prototypeType.flags & 1 /* TypeFlags.Any */) !== 0 ||
+        prototypeType === c.globalObjectType ||
+        prototypeType === c.globalFunctionType)
+        return t;
+    if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+        return prototypeType;
+    return filterType(c, t, (u) => isConstructedBy(c, u, prototypeType));
+}
+function isConstructedBy(c, source, target) {
+    // Class instances are only constructed by their own class, even when structurally identical to another.
+    if (((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (source.objectFlags & 1 /* ObjectFlags.Class */) !== 0) ||
+        ((target.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.objectFlags & 1 /* ObjectFlags.Class */) !== 0))
+        return source.symbol === target.symbol;
+    return isTypeSubtypeOf(c, source, target);
+}
+export function getAccessedPropertyName(c, access) {
+    if (access.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        return getText(access.name);
+    if (access.kind === 209 /* SyntaxKind.BindingElement */)
+        return getDestructuringPropertyName(c, access);
+    if (access.kind === 213 /* SyntaxKind.ElementAccessExpression */) {
+        const argument = access.argumentExpression;
+        if (isStringLiteralLike(argument))
+            return getText(argument);
+        if (argument.kind === 8 /* SyntaxKind.NumericLiteral */)
+            return String(Number(getText(argument)));
+        if (isEntityNameExpression(argument, false))
+            return tryGetNameFromEntityNameExpression(c, argument);
+    }
+    if (access.kind === 170 /* SyntaxKind.Parameter */)
+        return String(getParameters(access.parent).nodes.indexOf(access));
+    return undefined;
+}
+/** The property name a constant or enum member used as an index stands for. */
+export function tryGetNameFromEntityNameExpression(c, node) {
+    const symbol = resolveEntityName(c, node, 111551 /* SymbolFlags.Value */, true, false, undefined);
+    if (symbol === undefined || !(isConstantVariable(c, symbol) || (symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0))
+        return undefined;
+    const declaration = symbol.valueDeclaration;
+    if (declaration === undefined)
+        return undefined;
+    const typeNode = getType(declaration);
+    if (typeNode !== undefined) {
+        const name = tryGetNameFromType(getTypeFromTypeNode(c, typeNode));
+        if (name !== undefined)
+            return name;
+    }
+    // Binding elements are excluded: their initializers don't alone determine their types, and resolving
+    // their full types can be circular.
+    if ((declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ ||
+        declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
+        declaration.kind === 303 /* SyntaxKind.PropertyAssignment */ ||
+        declaration.kind === 170 /* SyntaxKind.Parameter */ ||
+        declaration.kind === 306 /* SyntaxKind.EnumMember */) &&
+        isBlockScopedNameDeclaredBeforeUse(c, declaration, node)) {
+        const initializer = getInitializer(declaration);
+        if (initializer !== undefined)
+            return tryGetNameFromType(getTypeOfExpression(c, initializer));
+        if (declaration.kind === 306 /* SyntaxKind.EnumMember */) {
+            const name = getName(declaration);
+            if (isStringLiteralLike(name) || name.kind === 8 /* SyntaxKind.NumericLiteral */ || name.kind === 79 /* SyntaxKind.Identifier */)
+                return getText(name);
+        }
+    }
+    return undefined;
+}
+export function tryGetNameFromType(t) {
+    return (t.flags & (16384 /* TypeFlags.UniqueESSymbol */ | 3072 /* TypeFlags.StringOrNumberLiteral */)) !== 0
+        ? getPropertyNameFromType(t)
+        : undefined;
+}
+/** The property name or element index a destructuring element reads. */
+export function getDestructuringPropertyName(c, node) {
+    const parent = node.parent;
+    let name;
+    if (node.kind === 209 /* SyntaxKind.BindingElement */ && parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */)
+        name = node.propertyName ?? node.name;
+    else if (node.kind === 303 /* SyntaxKind.PropertyAssignment */ || node.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */)
+        name = getName(node);
+    else if (parent.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || parent.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        return String(getElements(parent).nodes.indexOf(node));
+    if (name === undefined)
+        return undefined;
+    const t = getLiteralTypeFromPropertyName(c, name);
+    return t !== undefined && (t.flags & (1024 /* TypeFlags.StringLiteral */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0
+        ? getPropertyNameFromType(t)
+        : undefined;
+}
+export function isConstantReference(c, node) {
+    switch (node.kind) {
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return true;
+        case 79 /* SyntaxKind.Identifier */: {
+            if (isThisInTypeQuery(node))
+                return false;
+            const symbol = getResolvedSymbol(c, node);
+            return (isConstantVariable(c, symbol) ||
+                (isParameterOrMutableLocalVariable(c, symbol) && !isSymbolAssigned(c, symbol)) ||
+                (symbol.valueDeclaration !== undefined && symbol.valueDeclaration.kind === 219 /* SyntaxKind.FunctionExpression */));
+        }
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */: {
+            if (!isConstantReference(c, getExpression(node)))
+                return false;
+            const symbol = c.resolvedSymbols.get(node.id);
+            return symbol !== undefined && isReadonlySymbol(c, symbol);
+        }
+        case 207 /* SyntaxKind.ObjectBindingPattern */:
+        case 208 /* SyntaxKind.ArrayBindingPattern */: {
+            // A destructuring pseudo-reference is constant when none of its variables are reassigned.
+            const rootDeclaration = getRootDeclaration(node.parent);
+            if (rootDeclaration.kind === 170 /* SyntaxKind.Parameter */ ||
+                (rootDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                    rootDeclaration.parent.kind === 300 /* SyntaxKind.CatchClause */))
+                return !isSomeSymbolAssigned(c, getName(rootDeclaration));
+            if (rootDeclaration.kind !== 261 /* SyntaxKind.VariableDeclaration */)
+                return false;
+            const blockScopeKind = getCombinedNodeFlags(rootDeclaration) & 7 /* NodeFlags.BlockScoped */;
+            return (blockScopeKind === 2 /* NodeFlags.Const */ ||
+                blockScopeKind === 4 /* NodeFlags.Using */ ||
+                blockScopeKind === 6 /* NodeFlags.AwaitUsing */);
+        }
+    }
+    return false;
+}
+function containsMatchingReference(c, sourceIn, target) {
+    let source = sourceIn;
+    while (isAccessExpression(source)) {
+        source = getExpression(source);
+        if (isMatchingReference(c, source, target))
+            return true;
+    }
+    return false;
+}
+function optionalChainContainsReference(c, sourceIn, target) {
+    let source = sourceIn;
+    while (isOptionalChain(source)) {
+        source = getExpression(source);
+        if (isMatchingReference(c, source, target))
+            return true;
+    }
+    return false;
+}
+function getReferenceCandidate(node) {
+    switch (node.kind) {
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+            return getReferenceCandidate(getExpression(node));
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = node;
+            switch (binary.operatorToken.kind) {
+                case 63 /* SyntaxKind.EqualsToken */:
+                case 75 /* SyntaxKind.BarBarEqualsToken */:
+                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                    return getReferenceCandidate(binary.left);
+                case 27 /* SyntaxKind.CommaToken */:
+                    return getReferenceCandidate(binary.right);
+            }
+        }
+    }
+    return node;
+}
+export function hasMatchingArgument(c, call, reference) {
+    const args = getArguments(call);
+    if (args !== undefined) {
+        for (const argument of args.nodes)
+            if (isOrContainsMatchingReference(c, reference, argument) ||
+                optionalChainContainsReference(c, argument, reference))
+                return true;
+    }
+    const callee = getExpression(call);
+    return (callee.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+        isOrContainsMatchingReference(c, reference, getExpression(callee)));
+}
+function isOrContainsMatchingReference(c, source, target) {
+    return isMatchingReference(c, source, target) || containsMatchingReference(c, source, target);
+}
+function isCallChain(node) {
+    return node.kind === 214 /* SyntaxKind.CallExpression */ && isOptionalChain(node);
+}
+// ---- Reachability
+export function isReachableFlowNode(c, flow) {
+    const result = isReachableFlowNodeWorker(c, flow, false);
+    c.lastFlowNode = flow;
+    c.lastFlowNodeReachable = result;
+    return result;
+}
+function isReachableFlowNodeWorker(c, start, noCacheCheckIn) {
+    let flow = start;
+    let noCacheCheck = noCacheCheckIn;
+    for (;;) {
+        if (flow === c.lastFlowNode)
+            return c.lastFlowNodeReachable;
+        const flags = flow.flags;
+        if ((flags & 4096 /* FlowFlags.Shared */) !== 0) {
+            if (!noCacheCheck) {
+                const cached = c.flowNodeReachable.get(flow);
+                if (cached !== undefined)
+                    return cached;
+                const reachable = isReachableFlowNodeWorker(c, flow, true);
+                c.flowNodeReachable.set(flow, reachable);
+                return reachable;
+            }
+            noCacheCheck = false;
+        }
+        if ((flags & (16 /* FlowFlags.Assignment */ | 96 /* FlowFlags.Condition */ | 256 /* FlowFlags.ArrayMutation */)) !== 0)
+            flow = flow.antecedent;
+        else if ((flags & 512 /* FlowFlags.Call */) !== 0) {
+            const signature = getEffectsSignature(c, flow.node);
+            if (signature !== undefined) {
+                const predicate = getTypePredicateOfSignature(c, signature);
+                if (predicate !== undefined &&
+                    predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ &&
+                    predicate.type === undefined) {
+                    const args = getArguments(flow.node).nodes;
+                    if (predicate.parameterIndex >= 0 &&
+                        predicate.parameterIndex < args.length &&
+                        isFalseExpression(args[predicate.parameterIndex]))
+                        return false;
+                }
+                if ((getReturnTypeOfSignature(c, signature).flags & 262144 /* TypeFlags.Never */) !== 0)
+                    return false;
+            }
+            flow = flow.antecedent;
+        }
+        else if ((flags & 4 /* FlowFlags.BranchLabel */) !== 0) {
+            for (const antecedent of getBranchLabelAntecedents(c, flow))
+                if (isReachableFlowNodeWorker(c, antecedent, false))
+                    return true;
+            return false;
+        }
+        else if ((flags & 8 /* FlowFlags.LoopLabel */) !== 0) {
+            const antecedents = flow.antecedents;
+            if (antecedents === undefined || antecedents.length === 0)
+                return false;
+            flow = antecedents[0];
+        }
+        else if ((flags & 128 /* FlowFlags.SwitchClause */) !== 0) {
+            const clause = flow;
+            if (clause.isEmpty() && isExhaustiveSwitchStatement(c, clause.switchStatement))
+                return false;
+            flow = flow.antecedent;
+        }
+        else if ((flags & 1024 /* FlowFlags.ReduceLabel */) !== 0) {
+            c.lastFlowNode = undefined;
+            c.flowReduceLabels.push(flow);
+            const result = isReachableFlowNodeWorker(c, flow.antecedent, false);
+            c.flowReduceLabels.pop();
+            return result;
+        }
+        else
+            return (flags & 1 /* FlowFlags.Unreachable */) === 0;
+    }
+}
+function isFalseExpression(expr) {
+    const node = skipParentheses(expr);
+    if (node.kind === 96 /* SyntaxKind.FalseKeyword */)
+        return true;
+    if (node.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const binary = node;
+        if (binary.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)
+            return isFalseExpression(binary.left) || isFalseExpression(binary.right);
+        if (binary.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */)
+            return isFalseExpression(binary.left) && isFalseExpression(binary.right);
+    }
+    return false;
+}
+export function getAssignmentTargetKind(node) {
+    const target = getAssignmentTarget(node);
+    if (target === undefined)
+        return 0 /* AssignmentKind.None */;
+    if (target.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const op = target.operatorToken.kind;
+        return op === 63 /* SyntaxKind.EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(op)
+            ? 1 /* AssignmentKind.Definite */
+            : 2 /* AssignmentKind.Compound */;
+    }
+    if (target.kind === 225 /* SyntaxKind.PrefixUnaryExpression */ || target.kind === 226 /* SyntaxKind.PostfixUnaryExpression */)
+        return 2 /* AssignmentKind.Compound */;
+    return 1 /* AssignmentKind.Definite */;
+}
+export function isInCompoundLikeAssignment(node) {
+    const target = getAssignmentTarget(node);
+    if (target === undefined || !isAssignmentExpression(target, true))
+        return false;
+    const right = skipParentheses(target.right);
+    return (right.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        isShiftOperatorOrHigher(right.operatorToken.kind));
+}
+function isShiftOperatorOrHigher(kind) {
+    switch (kind) {
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+        case 41 /* SyntaxKind.AsteriskToken */:
+        case 43 /* SyntaxKind.SlashToken */:
+        case 44 /* SyntaxKind.PercentToken */:
+        case 39 /* SyntaxKind.PlusToken */:
+        case 40 /* SyntaxKind.MinusToken */:
+        case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+            return true;
+    }
+    return false;
+}
+function isUnreassignedVariable(c, symbol) {
+    return (isConstantVariable(c, symbol) || (isParameterOrMutableLocalVariable(c, symbol) && !isSymbolAssigned(c, symbol)));
+}
+export function isConstantVariable(_c, symbol) {
+    if ((symbol.flags & 3 /* SymbolFlags.Variable */) === 0 || symbol.valueDeclaration === undefined)
+        return false;
+    return (getCombinedNodeFlags(symbol.valueDeclaration) & 6 /* NodeFlags.Constant */) !== 0;
+}
+export function isParameterOrMutableLocalVariable(_c, symbol) {
+    if (symbol.valueDeclaration === undefined)
+        return false;
+    const declaration = getRootDeclaration(symbol.valueDeclaration);
+    return (declaration.kind === 170 /* SyntaxKind.Parameter */ ||
+        (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+            (declaration.parent.kind === 300 /* SyntaxKind.CatchClause */ || isMutableLocalVariableDeclaration(declaration))));
+}
+export function isMutableLocalVariableDeclaration(declaration) {
+    const list = declaration.parent;
+    if ((list.flags & 1 /* NodeFlags.Let */) === 0)
+        return false;
+    if ((getCombinedModifierFlags(declaration) & 32 /* ModifierFlags.Export */) !== 0)
+        return false;
+    const statement = list.parent;
+    return !(statement.kind === 244 /* SyntaxKind.VariableStatement */ && isGlobalSourceFile(statement.parent));
+}
+export function isSymbolAssigned(c, symbol) {
+    ensureAssignmentsMarked(c, symbol);
+    return c.symbolLinks(symbol).lastAssignmentPos !== 0;
+}
+export function isSymbolAssignedDefinitely(c, symbol) {
+    ensureAssignmentsMarked(c, symbol);
+    return c.symbolLinks(symbol).hasDefiniteAssignment;
+}
+/** Whether there are no assignments to `symbol`, or `location` is past the last one. */
+export function isPastLastAssignment(c, symbol, location) {
+    ensureAssignmentsMarked(c, symbol);
+    const pos = c.symbolLinks(symbol).lastAssignmentPos;
+    return pos === 0 || (location !== undefined && pos < location.pos);
+}
+function isFunctionOrSourceFile(node) {
+    return node.kind === 307 /* SyntaxKind.SourceFile */ || isFunctionLike(node);
+}
+function findFunctionOrSourceFile(node) {
+    let current = node;
+    while (current !== undefined && !isFunctionOrSourceFile(current))
+        current = current.parent;
+    return current;
+}
+function ensureAssignmentsMarked(c, symbol) {
+    if (c.symbolLinks(symbol).lastAssignmentPos !== 0)
+        return;
+    const parent = findFunctionOrSourceFile(symbol.valueDeclaration);
+    if (parent === undefined)
+        return;
+    const links = c.nodeLinks(parent);
+    if ((links.flags & 131072 /* NodeCheckFlags.AssignmentsMarked */) !== 0)
+        return;
+    links.flags |= 131072 /* NodeCheckFlags.AssignmentsMarked */;
+    // An enclosing function already marked everything inside it.
+    let outer = parent.parent;
+    while (outer !== undefined) {
+        if (isFunctionOrSourceFile(outer) &&
+            ((c.existingNodeLinks(outer)?.flags ?? 0) & 131072 /* NodeCheckFlags.AssignmentsMarked */) !== 0)
+            return;
+        outer = outer.parent;
+    }
+    c.assignmentMarker.visitNode(parent);
+}
+const maxAssignmentPos = 2147483647;
+/** Records the last assignment position of parameters and mutable locals in one walk. */
+export class AssignmentMarker extends NodeVisitor {
+    c;
+    constructor(c) {
+        super();
+        this.c = c;
+    }
+    visitNode(node) {
+        const c = this.c;
+        switch (node.kind) {
+            case 79 /* SyntaxKind.Identifier */: {
+                const kind = getAssignmentTargetKind(node);
+                if (kind === 0 /* AssignmentKind.None */)
+                    return false;
+                const symbol = getResolvedSymbol(c, node);
+                if (!isParameterOrMutableLocalVariable(c, symbol))
+                    return false;
+                const links = c.symbolLinks(symbol);
+                if (links.lastAssignmentPos !== maxAssignmentPos) {
+                    const referencing = findFunctionOrSourceFile(node);
+                    const declaring = findFunctionOrSourceFile(symbol.valueDeclaration);
+                    links.lastAssignmentPos =
+                        referencing === declaring ? extendAssignmentPosition(node, symbol.valueDeclaration) : maxAssignmentPos;
+                }
+                if (kind === 1 /* AssignmentKind.Definite */)
+                    links.hasDefiniteAssignment = true;
+                return false;
+            }
+            case 282 /* SyntaxKind.ExportSpecifier */: {
+                const specifier = node;
+                const declaration = specifier.parent.parent;
+                const name = specifier.propertyName ?? specifier.name;
+                if (!specifier.isTypeOnly &&
+                    !declaration.isTypeOnly &&
+                    declaration.moduleSpecifier === undefined &&
+                    name.kind !== 10 /* SyntaxKind.StringLiteral */) {
+                    const symbol = resolveEntityName(c, name, 111551 /* SymbolFlags.Value */, true, true, undefined);
+                    if (symbol !== undefined && isParameterOrMutableLocalVariable(c, symbol))
+                        c.symbolLinks(symbol).lastAssignmentPos = maxAssignmentPos;
+                }
+                return false;
+            }
+            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 266 /* SyntaxKind.TypeAliasDeclaration */:
+            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 267 /* SyntaxKind.EnumDeclaration */:
+                return false;
+        }
+        if (node.kind >= 183 /* SyntaxKind.FirstTypeNode */ && node.kind <= 206 /* SyntaxKind.LastTypeNode */)
+            return false;
+        return node.forEachChild(this);
+    }
+}
+function extendAssignmentPosition(nodeIn, declaration) {
+    let node = nodeIn;
+    let pos = nodeIn.pos;
+    while (node !== undefined && node.pos > declaration.pos) {
+        switch (node.kind) {
+            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.ExpressionStatement */:
+            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 255 /* SyntaxKind.WithStatement */:
+            case 256 /* SyntaxKind.SwitchStatement */:
+            case 259 /* SyntaxKind.TryStatement */:
+            case 264 /* SyntaxKind.ClassDeclaration */:
+                pos = node.end;
+        }
+        node = node.parent;
+    }
+    return pos;
+}
+/** The function, module block, source file or property declaration whose flow graph contains `node`. */
+export function getControlFlowContainer(node) {
+    let current = node.parent;
+    for (;;) {
+        if ((isFunctionLike(current) && getImmediatelyInvokedFunctionExpression(current) === undefined) ||
+            current.kind === 269 /* SyntaxKind.ModuleBlock */ ||
+            current.kind === 307 /* SyntaxKind.SourceFile */ ||
+            current.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+            return current;
+        current = current.parent;
+    }
+}
+/** Array mutations of an auto-typed array (`x.push(...)`, `x[i] = ...`) on the way to its references. */
+function getTypeAtFlowArrayMutation(c, f, flow) {
+    if (f.declaredType !== c.autoType && f.declaredType !== c.autoArrayType)
+        return undefined;
+    const node = flow.node;
+    const expr = node.kind === 214 /* SyntaxKind.CallExpression */
+        ? getExpression(getExpression(node))
+        : getExpression(node.left);
+    if (!isMatchingReference(c, f.reference, getReferenceCandidate(expr)))
+        return undefined;
+    const flowType = getTypeAtFlowNode(c, f, flow.antecedent);
+    if ((flowType.objectFlags & 256 /* ObjectFlags.EvolvingArray */) === 0)
+        return flowType;
+    const incomplete = f.incomplete;
+    let evolvedType = flowType;
+    if (node.kind === 214 /* SyntaxKind.CallExpression */) {
+        for (const arg of getArguments(node).nodes)
+            evolvedType = addEvolvingArrayElementType(c, evolvedType, arg);
+    }
+    else {
+        // The context-free type avoids rechecking the left side without caching, which blows up.
+        const binary = node;
+        const indexType = getContextFreeTypeOfExpression(c, binary.left.argumentExpression);
+        if (isTypeAssignableToKindEx(c, indexType, 67648 /* TypeFlags.NumberLike */, false))
+            evolvedType = addEvolvingArrayElementType(c, evolvedType, binary.right);
+    }
+    return newFlowType(c, f, evolvedType, incomplete);
+}
+// ---- Evolving arrays
+/** The evolving array type of `let x = []` with the element types added so far. */
+export function getEvolvingArrayType(c, elementType) {
+    const key = cachedTypeKey(6 /* CachedTypeKind.EvolvingArray */, elementType.id);
+    const cached = c.cachedTypesById.get(key);
+    if (cached !== undefined)
+        return cached;
+    const evolving = newObjectType(c, 256 /* ObjectFlags.EvolvingArray */, undefined);
+    evolving.elementType = elementType;
+    c.cachedTypesById.set(key, evolving);
+    return evolving;
+}
+function getElementTypeOfEvolvingArrayType(c, t) {
+    return (t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0 ? t.elementType : c.neverType;
+}
+function isEvolvingArrayTypeList(types) {
+    let hasEvolvingArrayType = false;
+    for (const t of types) {
+        if ((t.flags & 262144 /* TypeFlags.Never */) !== 0)
+            continue;
+        if ((t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) === 0)
+            return false;
+        hasEvolvingArrayType = true;
+    }
+    return hasEvolvingArrayType;
+}
+/**
+ * Whether `node` is `x` in `x.length`, `x.push(v)`, `x.unshift(v)` or `x[n] = v` with a numeric,
+ * undefined or any `n`.
+ */
+export function isEvolvingArrayOperationTarget(c, node) {
+    const root = getReferenceRoot(node);
+    const parent = root.parent;
+    if (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const name = parent.name;
+        return (getText(name) === 'length' ||
+            (parent.parent.kind === 214 /* SyntaxKind.CallExpression */ &&
+                name.kind === 79 /* SyntaxKind.Identifier */ &&
+                isPushOrUnshiftIdentifier(name)));
+    }
+    if (parent.kind !== 213 /* SyntaxKind.ElementAccessExpression */ || getExpression(parent) !== root)
+        return false;
+    const grandparent = parent.parent;
+    return (grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        grandparent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ &&
+        grandparent.left === parent &&
+        !isAssignmentTarget(grandparent) &&
+        isTypeAssignableToKindEx(c, getTypeOfExpression(c, parent.argumentExpression), 67648 /* TypeFlags.NumberLike */, false));
+}
+function getReferenceRoot(node) {
+    const parent = node.parent;
+    if (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        return getReferenceRoot(parent);
+    if (parent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const binary = parent;
+        if ((binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && binary.left === node) ||
+            (binary.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && binary.right === node))
+            return getReferenceRoot(parent);
+    }
+    return node;
+}
+/** Adds the type of `node` to an evolving array; subtype reduction waits until it's finalized. */
+function addEvolvingArrayElementType(c, evolvingArrayType, node) {
+    const newElementType = getRegularTypeOfObjectLiteral(c, getBaseTypeOfLiteralType(c, getContextFreeTypeOfExpression(c, node)));
+    const elementType = evolvingArrayType.elementType;
+    if (isTypeSubsetOf(c, newElementType, elementType))
+        return evolvingArrayType;
+    return getEvolvingArrayType(c, getUnionType(c, [elementType, newElementType]));
+}
+/** The array type an evolving array settles on; `any[]` while it has no elements. */
+export function finalizeEvolvingArrayType(c, t) {
+    if ((t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) === 0)
+        return t;
+    const evolving = t;
+    const side = sideOf(c, evolving);
+    if (side.finalArrayType !== undefined)
+        return side.finalArrayType;
+    const elementType = evolving.elementType;
+    const finalArrayType = (elementType.flags & 262144 /* TypeFlags.Never */) !== 0
+        ? c.autoArrayType
+        : createArrayType(c, (elementType.flags & 134217728 /* TypeFlags.Union */) !== 0
+            ? getUnionTypeEx(c, elementType.types, 2 /* UnionReduction.Subtype */, undefined, undefined)
+            : elementType);
+    side.finalArrayType = finalArrayType;
+    return finalArrayType;
+}
+/** The type of an expression checked without contextual types, computed once. */
+function getContextFreeTypeOfExpression(c, node) {
+    const links = c.nodeLinks(node);
+    if (links.contextFreeType !== undefined)
+        return links.contextFreeType;
+    const t = checkExpressionEx(c, node, 4 /* CheckMode.SkipContextSensitive */);
+    links.contextFreeType = t;
+    return t;
+}
+function reportFlowControlError(c, node) {
+    let block = node;
+    while (block !== undefined && !isFunctionOrModuleBlock(block))
+        block = block.parent;
+    if (block === undefined)
+        return;
+    const file = getSourceFileOfNode(node);
+    const span = getRangeOfTokenAtPosition(file, getStatements(block).pos);
+    c.addDiagnostic(new Diagnostic(file.diagnosticFile(), span.pos, span.end, 717 /* Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis */, []));
+}
+function isFunctionOrModuleBlock(node) {
+    return (node.kind === 307 /* SyntaxKind.SourceFile */ ||
+        node.kind === 269 /* SyntaxKind.ModuleBlock */ ||
+        (node.kind === 242 /* SyntaxKind.Block */ && node.parent !== undefined && isFunctionLike(node.parent)));
+}
+/**
+ * The type of `symbol` at `location`. A destructured variable of a const declaration or unassigned
+ * parameter is narrowed by checks of its siblings: in `const { kind, payload } = action`, testing
+ * `kind` narrows `payload`.
+ */
+export function getNarrowedTypeOfSymbol(c, symbol, location) {
+    const t = getTypeOfSymbol(c, symbol);
+    const declaration = symbol.valueDeclaration;
+    if (declaration !== undefined &&
+        declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+        getType(declaration) === undefined &&
+        getInitializer(declaration) === undefined &&
+        getDotDotDotToken(declaration) === undefined)
+        return getNarrowedTypeOfDependentParameter(c, t, declaration, location);
+    if (declaration === undefined ||
+        declaration.kind !== 209 /* SyntaxKind.BindingElement */ ||
+        getInitializer(declaration) !== undefined ||
+        declaration.dotDotDotToken !== undefined ||
+        getElements(declaration.parent).nodes.length < 2)
+        return t;
+    const pattern = declaration.parent;
+    const parent = pattern.parent;
+    const rootDeclaration = getRootDeclaration(parent);
+    const isParameter = rootDeclaration.kind === 170 /* SyntaxKind.Parameter */;
+    if (!isParameter &&
+        !(rootDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+            (getCombinedNodeFlags(rootDeclaration) & 6 /* NodeFlags.Constant */) !== 0))
+        return t;
+    const links = c.nodeLinks(parent);
+    if ((links.flags & 4194304 /* NodeCheckFlags.InCheckIdentifier */) !== 0)
+        return t;
+    links.flags |= 4194304 /* NodeCheckFlags.InCheckIdentifier */;
+    let result = t;
+    const parentType = getTypeForBindingElementParent(c, parent, 0 /* CheckMode.Normal */);
+    const parentTypeConstraint = parentType !== undefined ? mapToBaseConstraintOrType(c, parentType) : undefined;
+    if (parentTypeConstraint !== undefined &&
+        (parentTypeConstraint.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+        !(isParameter && isSomeSymbolAssigned(c, getName(rootDeclaration)))) {
+        const narrowedType = getFlowTypeOfReferenceAt(c, pattern, parentTypeConstraint, parentTypeConstraint, undefined, getFlowNode(location));
+        // Tuple bounds aren't checked, as the narrowed parent may have fewer elements than the declared one.
+        result =
+            (narrowedType.flags & 262144 /* TypeFlags.Never */) !== 0
+                ? c.neverType
+                : getBindingElementTypeFromParentType(c, declaration, narrowedType, true);
+    }
+    links.flags &= ~4194304 /* NodeCheckFlags.InCheckIdentifier */;
+    return result;
+}
+/**
+ * A parameter of a function contextually typed by a rest union of tuples, as in
+ * `const f: (...args: [1, string] | [2, number]) => void = (kind, data) => ...`, narrowed by checks of its
+ * sibling parameters: the function is the pseudo-reference for the tuple.
+ */
+function getNarrowedTypeOfDependentParameter(c, t, declaration, location) {
+    const fn = declaration.parent;
+    const parameters = getParameters(fn).nodes;
+    if (parameters.length < 2 || !isContextSensitiveFunctionOrObjectLiteralMethod(c, fn))
+        return t;
+    const contextualSignature = getContextualSignature(c, fn);
+    if (contextualSignature === undefined ||
+        contextualSignature.parameters.length !== 1 ||
+        !contextualSignature.hasRestParameter())
+        return t;
+    const context = getInferenceContext(c, fn);
+    const restType = getReducedApparentType(c, instantiateType(c, getTypeOfSymbol(c, contextualSignature.parameters[0]), context !== undefined ? context.nonFixingMapper : undefined));
+    if ((restType.flags & 134217728 /* TypeFlags.Union */) === 0 ||
+        !everyType(restType, isTupleType) ||
+        someParameterAssigned(c, parameters))
+        return t;
+    const narrowedType = getFlowTypeOfReferenceAt(c, fn, restType, restType, undefined, getFlowNode(location));
+    const index = parameters.indexOf(declaration) - (isThisParameter(parameters[0]) ? 1 : 0);
+    return getIndexedAccessType(c, narrowedType, getNumberLiteralType(c, index));
+}
+function isThisParameter(parameter) {
+    const name = getName(parameter);
+    return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this';
+}
+function someParameterAssigned(c, parameters) {
+    for (const p of parameters)
+        if (isSomeSymbolAssigned(c, getName(p)))
+            return true;
+    return false;
+}
+function isSomeSymbolAssigned(c, name) {
+    if (name.kind === 79 /* SyntaxKind.Identifier */) {
+        const symbol = getSymbolOfDeclaration(c, name.parent);
+        return symbol !== undefined && isSymbolAssigned(c, symbol);
+    }
+    for (const e of getElements(name).nodes) {
+        const elementName = getName(e);
+        if (elementName !== undefined && isSomeSymbolAssigned(c, elementName))
+            return true;
+    }
+    return false;
+}