@soundscript/soundscript 0.1.13 → 0.1.15

package/project-transform/src/checker/rules/flow_invalidation.js

@@ -0,0 +1,1119 @@
+import ts from 'typescript';
+import { bindFunctionBindingName, appendSegment, arrayMutationCallAffectsNarrow, assignmentAffectsNarrow, bindFunctionReceiverPath, cloneState, getCalledMember, getExpressionSymbol, getFunctionBindings, getFunctionBodyCalledMember, getFunctionLikeFromBoundMemberCall, getFunctionLikeFromBoundValue, getFunctionLikeFromCallExpression, getStateExpressionBoundValue, getUniformArrayElementBindingFromExpression, getUniformArrayElementBindingFromFunctionBodyExpression, getUniformMapEntryBindingsFromExpression, getUniformMapEntryBindingsFromFunctionBodyExpression, getUniformSetElementBindingFromExpression, getUniformSetElementBindingFromFunctionBodyExpression, getNestedFunctionBindings, getMutableBindingSymbol, getShorthandStateBoundValue, getSymbolId, getUpdateExpressionOperand, isConstLocalBindingPath, isFunctionLikeWithBody, isLocalBindingPath, isStableConstLocalBindingPath, MUTATING_ASSIGNMENT_OPERATORS, mutationAffectsNarrow, normalizeExpressionPath, normalizeExpressionSourcePath, normalizeFunctionBodyPath, opaqueArgumentEscapeAffectsNarrow, pathsMatch, recordForOfLoopHeaderAliases, recordFunctionBodyConstBindings, recordExecutedExpressionAliases, recordVariableAliases, typeMayAliasMutableState, typedUpdateExpressionAffectsNarrow, } from './flow_shared.js';
+export { appendSegment, cloneState, isFunctionLikeWithBody, normalizeExpressionPath, recordExecutedExpressionAliases, recordVariableAliases, } from './flow_shared.js';
+const SYNCHRONOUS_ARRAY_CALLBACK_PARAMETER_BINDINGS = new Map([
+    ['every', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['filter', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['find', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['findIndex', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['findLast', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['findLastIndex', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['flatMap', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['forEach', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['map', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+    ['reduce', { callbackArgumentIndex: 0, elementParameterIndex: 1, arrayParameterIndex: 3 }],
+    ['reduceRight', { callbackArgumentIndex: 0, elementParameterIndex: 1, arrayParameterIndex: 3 }],
+    ['some', { callbackArgumentIndex: 0, elementParameterIndex: 0, arrayParameterIndex: 2 }],
+]);
+const SYNCHRONOUS_SET_CALLBACK_PARAMETER_BINDINGS = new Map([
+    ['forEach', { callbackArgumentIndex: 0, elementParameterIndexes: [0, 1], receiverParameterIndex: 2 }],
+]);
+const SYNCHRONOUS_MAP_CALLBACK_PARAMETER_BINDINGS = new Map([
+    ['forEach', { callbackArgumentIndex: 0, valueParameterIndex: 0, keyParameterIndex: 1, receiverParameterIndex: 2 }],
+]);
+function unwrapTransparentExpression(expression) {
+    while (ts.isParenthesizedExpression(expression) ||
+        ts.isAsExpression(expression) ||
+        ts.isTypeAssertionExpression(expression) ||
+        ts.isNonNullExpression(expression) ||
+        ts.isSatisfiesExpression(expression)) {
+        expression = expression.expression;
+    }
+    return expression;
+}
+function expressionIsThisLikeInBindings(context, expression, bindings, seen = new Set()) {
+    expression = unwrapTransparentExpression(expression);
+    if (expression.kind === ts.SyntaxKind.ThisKeyword) {
+        return true;
+    }
+    if (!ts.isIdentifier(expression)) {
+        return false;
+    }
+    const symbol = getExpressionSymbol(context, expression);
+    if (!symbol) {
+        return false;
+    }
+    const symbolId = getSymbolId(context, symbol);
+    if (seen.has(symbolId)) {
+        return false;
+    }
+    seen.add(symbolId);
+    const boundValue = bindings.boundValues.get(symbolId);
+    return !!boundValue && ts.isExpression(boundValue) &&
+        expressionIsThisLikeInBindings(context, boundValue, bindings, seen);
+}
+function getAssignedReceiverMemberKey(context, expression, bindings) {
+    expression = unwrapTransparentExpression(expression);
+    if (ts.isPropertyAccessExpression(expression)) {
+        return expressionIsThisLikeInBindings(context, expression.expression, bindings)
+            ? expression.name.text
+            : undefined;
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        if (!expressionIsThisLikeInBindings(context, expression.expression, bindings)) {
+            return undefined;
+        }
+        const argument = expression.argumentExpression;
+        if (!argument) {
+            return undefined;
+        }
+        const unwrappedArgument = unwrapTransparentExpression(argument);
+        if (ts.isStringLiteral(unwrappedArgument) ||
+            ts.isNumericLiteral(unwrappedArgument) ||
+            ts.isNoSubstitutionTemplateLiteral(unwrappedArgument)) {
+            return unwrappedArgument.text;
+        }
+    }
+    return undefined;
+}
+function getConstructorAssignedReceiverMemberPaths(context, declaration, bindings) {
+    if (!ts.isConstructorDeclaration(declaration) || !declaration.body) {
+        return undefined;
+    }
+    const memberPaths = new Map();
+    recordFunctionBodyConstBindings(context, declaration.body, bindings);
+    for (const candidate of getFlowInvalidationStructure(context, declaration.body, 'functionBody').candidates) {
+        if (candidate.kind !== 'assignment' ||
+            candidate.node.operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
+            context.isGeneratedNode(candidate.node)) {
+            continue;
+        }
+        const key = getAssignedReceiverMemberKey(context, candidate.left, bindings);
+        if (!key) {
+            continue;
+        }
+        const rightPath = normalizeFunctionBodyPath(context, candidate.right, bindings);
+        if (rightPath) {
+            memberPaths.set(key, rightPath);
+        }
+    }
+    return memberPaths.size > 0 ? memberPaths : undefined;
+}
+function getConstructorReceiverBindingFromState(context, declaration, argumentsList, state) {
+    if (!isFunctionLikeWithBody(declaration)) {
+        return undefined;
+    }
+    const bindings = getFunctionBindings(context, argumentsList, declaration, state);
+    const memberPaths = getConstructorAssignedReceiverMemberPaths(context, declaration, bindings);
+    return memberPaths ? { path: undefined, memberPaths } : undefined;
+}
+function getConstructorReceiverBindingFromBindings(context, declaration, argumentsList, bindings) {
+    if (!isFunctionLikeWithBody(declaration)) {
+        return undefined;
+    }
+    const nestedBindings = getNestedFunctionBindings(context, argumentsList, declaration, bindings);
+    const memberPaths = getConstructorAssignedReceiverMemberPaths(context, declaration, nestedBindings);
+    return memberPaths ? { path: undefined, memberPaths } : undefined;
+}
+function getStateConstructedReceiverBinding(context, expression, state, kind, seen = new Set()) {
+    expression = unwrapTransparentExpression(expression);
+    if (ts.isIdentifier(expression)) {
+        const symbol = getExpressionSymbol(context, expression);
+        if (!symbol) {
+            return undefined;
+        }
+        const symbolId = getSymbolId(context, symbol);
+        if (seen.has(symbolId)) {
+            return {
+                path: getInvalidationPath(context, expression, state, kind),
+                memberPaths: undefined,
+            };
+        }
+        seen.add(symbolId);
+        const boundValue = state.boundValues.get(symbolId);
+        if (boundValue && ts.isExpression(boundValue)) {
+            return getStateConstructedReceiverBinding(context, boundValue, state, kind, seen) ?? {
+                path: getInvalidationPath(context, expression, state, kind),
+                memberPaths: undefined,
+            };
+        }
+    }
+    if (!ts.isNewExpression(expression)) {
+        const path = getInvalidationPath(context, expression, state, kind);
+        return path ? { path, memberPaths: undefined } : undefined;
+    }
+    const constructorDeclaration = context.checker.getResolvedSignature(expression)?.declaration;
+    return constructorDeclaration
+        ? getConstructorReceiverBindingFromState(context, constructorDeclaration, expression.arguments ?? [], state)
+        : undefined;
+}
+function getFunctionConstructedReceiverBinding(context, expression, bindings, seen = new Set()) {
+    expression = unwrapTransparentExpression(expression);
+    if (expression.kind === ts.SyntaxKind.ThisKeyword) {
+        return bindings.receiverPath || bindings.receiverMemberPaths
+            ? {
+                path: bindings.receiverPath,
+                memberPaths: bindings.receiverMemberPaths,
+            }
+            : undefined;
+    }
+    if (ts.isIdentifier(expression)) {
+        const symbol = getExpressionSymbol(context, expression);
+        if (!symbol) {
+            return undefined;
+        }
+        const symbolId = getSymbolId(context, symbol);
+        if (seen.has(symbolId)) {
+            const path = normalizeFunctionBodyPath(context, expression, bindings);
+            return path ? { path, memberPaths: undefined } : undefined;
+        }
+        seen.add(symbolId);
+        const boundValue = bindings.boundValues.get(symbolId);
+        if (boundValue && ts.isExpression(boundValue)) {
+            return getFunctionConstructedReceiverBinding(context, boundValue, bindings, seen) ?? {
+                path: normalizeFunctionBodyPath(context, expression, bindings),
+                memberPaths: undefined,
+            };
+        }
+    }
+    if (!ts.isNewExpression(expression)) {
+        const path = normalizeFunctionBodyPath(context, expression, bindings);
+        return path ? { path, memberPaths: undefined } : undefined;
+    }
+    const constructorDeclaration = context.checker.getResolvedSignature(expression)?.declaration;
+    return constructorDeclaration
+        ? getConstructorReceiverBindingFromBindings(context, constructorDeclaration, expression.arguments ?? [], bindings)
+        : undefined;
+}
+function getExpressionPathInfo(context, expression, state) {
+    const readPath = normalizeExpressionPath(context, expression, state);
+    const sourcePath = normalizeExpressionSourcePath(context, expression, state);
+    return {
+        readPath,
+        sourcePath,
+        extracted: !!readPath && !!sourcePath && !pathsMatch(readPath, sourcePath),
+    };
+}
+function getInvalidationPath(context, expression, state, kind) {
+    const pathInfo = getExpressionPathInfo(context, expression, state);
+    if (!pathInfo.extracted) {
+        return pathInfo.readPath;
+    }
+    if (!pathInfo.sourcePath) {
+        return pathInfo.readPath;
+    }
+    if (kind === 'opaqueEscape' && pathInfo.sourcePath.segments.length > 0) {
+        const type = context.checker.getTypeAtLocation(expression);
+        if (!typeMayAliasMutableState(context, type)) {
+            return undefined;
+        }
+    }
+    if (kind === 'return' && pathInfo.sourcePath.segments.length > 0) {
+        return undefined;
+    }
+    return pathInfo.sourcePath;
+}
+function isExtractedReadOnlyReturnArgument(context, expression, state) {
+    const sourcePath = normalizeExpressionSourcePath(context, expression, state);
+    return !!sourcePath && sourcePath.segments.length > 0;
+}
+function expressionPathEscapesNarrow(context, expression, narrowPath, state) {
+    const expressionPath = normalizeExpressionPath(context, expression, state);
+    return expressionPath !== undefined &&
+        opaqueArgumentEscapeAffectsNarrow(expressionPath, narrowPath);
+}
+function functionBodyPathEscapesNarrow(context, expression, bindings, narrowPath) {
+    const expressionPath = normalizeFunctionBodyPath(context, expression, bindings);
+    return expressionPath !== undefined &&
+        opaqueArgumentEscapeAffectsNarrow(expressionPath, narrowPath);
+}
+function boundParameterAffectsNarrow(context, node, bindings, narrowPath, state) {
+    if ((ts.isCallExpression(node.parent) || ts.isNewExpression(node.parent)) &&
+        node.parent.expression === node) {
+        return false;
+    }
+    const parameterSymbol = getExpressionSymbol(context, node);
+    if (!parameterSymbol) {
+        return false;
+    }
+    const boundValue = bindings.boundValues.get(getSymbolId(context, parameterSymbol));
+    if (!boundValue) {
+        return false;
+    }
+    if (ts.isExpression(boundValue) &&
+        !expressionPathEscapesNarrow(context, boundValue, narrowPath, state) &&
+        escapingExpressionAffectsNarrow(context, boundValue, narrowPath, state)) {
+        return true;
+    }
+    const boundFunction = getFunctionLikeFromBoundValue(context, boundValue);
+    return boundFunction
+        ? functionLikeAffectsNarrow(context, boundFunction, [], narrowPath, state, false)
+        : false;
+}
+function isNodeWithinScope(node, scope) {
+    for (let current = node; current; current = current.parent) {
+        if (current === scope) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLocalConstInitializer(context, identifier, scope) {
+    const symbol = getExpressionSymbol(context, identifier);
+    if (!symbol) {
+        return undefined;
+    }
+    const declaration = symbol.valueDeclaration;
+    if (!declaration ||
+        !ts.isVariableDeclaration(declaration) ||
+        !declaration.initializer ||
+        !declaration.parent ||
+        !ts.isVariableDeclarationList(declaration.parent) ||
+        (declaration.parent.flags & ts.NodeFlags.Const) === 0 ||
+        !isNodeWithinScope(declaration, scope)) {
+        return undefined;
+    }
+    return declaration.initializer;
+}
+function forEachReturnExpression(root, callback) {
+    const visit = (node) => {
+        if (node !== root && isFunctionLikeWithBody(node)) {
+            return false;
+        }
+        if (ts.isReturnStatement(node) && node.expression) {
+            return callback(node.expression);
+        }
+        return ts.forEachChild(node, visit) ?? false;
+    };
+    return visit(root);
+}
+function functionBodyExpressionEscapesNarrow(context, expression, bindings, narrowPath, state, scope, activeDeclarations, seenExpressions) {
+    if (seenExpressions.has(expression)) {
+        return false;
+    }
+    seenExpressions.add(expression);
+    if (isFunctionLikeWithBody(expression)) {
+        const nestedBindings = getNestedFunctionBindings(context, [], expression, bindings);
+        return functionLikeAffectsNarrow(context, expression, [], narrowPath, state, false, undefined, nestedBindings);
+    }
+    for (const candidate of getFlowInvalidationStructure(context, expression, 'functionBodyResultExpression').candidates) {
+        if (candidate.kind === 'access') {
+            if (functionBodyPathEscapesNarrow(context, candidate.node, bindings, narrowPath)) {
+                return true;
+            }
+            if (ts.isIdentifier(candidate.node)) {
+                const initializer = getLocalConstInitializer(context, candidate.node, scope);
+                if (initializer &&
+                    functionBodyExpressionEscapesNarrow(context, initializer, bindings, narrowPath, state, scope, activeDeclarations, seenExpressions)) {
+                    return true;
+                }
+            }
+        }
+        if (candidate.kind === 'call') {
+            const calleeDeclaration = getFunctionLikeFromCallExpression(context, candidate.node);
+            if (calleeDeclaration &&
+                functionLikeResultEscapesNarrow(context, calleeDeclaration, candidate.node.arguments, narrowPath, state, activeDeclarations)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function functionLikeResultEscapesNarrow(context, declaration, argumentsList, narrowPath, state, activeDeclarations = new Set()) {
+    const body = declaration.body;
+    if (!body || activeDeclarations.has(declaration)) {
+        return false;
+    }
+    activeDeclarations.add(declaration);
+    try {
+        const bindings = getFunctionBindings(context, argumentsList, declaration, state);
+        return forEachReturnExpression(body, (expression) => functionBodyExpressionEscapesNarrow(context, expression, bindings, narrowPath, state, body, activeDeclarations, new Set()));
+    }
+    finally {
+        activeDeclarations.delete(declaration);
+    }
+}
+function opaqueArgumentExpressionAffectsNarrow(context, expression, narrowPath, state) {
+    const pathInfo = getExpressionPathInfo(context, expression, state);
+    if (pathInfo.sourcePath &&
+        pathInfo.sourcePath.segments.length > 0 &&
+        !typeMayAliasMutableState(context, context.checker.getTypeAtLocation(expression))) {
+        return false;
+    }
+    if (pathInfo.extracted &&
+        pathInfo.sourcePath &&
+        pathInfo.sourcePath.segments.length > 0 &&
+        !typeMayAliasMutableState(context, context.checker.getTypeAtLocation(expression))) {
+        return false;
+    }
+    const invalidationPath = getInvalidationPath(context, expression, state, 'opaqueEscape');
+    if (invalidationPath && opaqueArgumentEscapeAffectsNarrow(invalidationPath, narrowPath)) {
+        return true;
+    }
+    if (!pathInfo.extracted) {
+        if (expressionPathEscapesNarrow(context, expression, narrowPath, state)) {
+            return true;
+        }
+        if (escapingExpressionAffectsNarrow(context, expression, narrowPath, state)) {
+            return true;
+        }
+        if (stateBoundValueAffectsNarrow(context, expression, narrowPath, state)) {
+            return true;
+        }
+    }
+    if (!ts.isCallExpression(expression)) {
+        return false;
+    }
+    const calleeDeclaration = getFunctionLikeFromCallExpression(context, expression);
+    return calleeDeclaration
+        ? functionLikeResultEscapesNarrow(context, calleeDeclaration, expression.arguments, narrowPath, state)
+        : false;
+}
+function opaqueFunctionBodyArgumentExpressionAffectsNarrow(context, expression, bindings, narrowPath, state, scope) {
+    const functionBodyPath = normalizeFunctionBodyPath(context, expression, bindings);
+    if (functionBodyPath &&
+        functionBodyPath.segments.length > 0 &&
+        !typeMayAliasMutableState(context, context.checker.getTypeAtLocation(expression))) {
+        return false;
+    }
+    return functionBodyPathEscapesNarrow(context, expression, bindings, narrowPath) ||
+        functionBodyExpressionEscapesNarrow(context, expression, bindings, narrowPath, state, scope, new Set(), new Set());
+}
+function getLocalCallbackFunctionLike(context, expression, bindings) {
+    expression = unwrapTransparentExpression(expression);
+    if (isFunctionLikeWithBody(expression)) {
+        return expression;
+    }
+    if (!ts.isIdentifier(expression)) {
+        return undefined;
+    }
+    const symbol = getExpressionSymbol(context, expression);
+    if (!symbol) {
+        return undefined;
+    }
+    const boundValue = bindings.boundValues.get(getSymbolId(context, symbol));
+    return boundValue ? getFunctionLikeFromBoundValue(context, boundValue) : undefined;
+}
+function arrayCallbackArgumentAffectsNarrow(context, receiver, member, callExpression, bindings, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_ARRAY_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = getLocalCallbackFunctionLike(context, callbackArgument, bindings);
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeElement = getUniformArrayElementBindingFromFunctionBodyExpression(context, receiver, bindings);
+    if (!representativeElement) {
+        return false;
+    }
+    const nestedBindings = getNestedFunctionBindings(context, [], callbackDeclaration, bindings);
+    const elementParameter = callbackDeclaration.parameters[callbackBinding.elementParameterIndex];
+    if (elementParameter) {
+        bindFunctionBindingName(context, elementParameter.name, representativeElement.path, representativeElement.value, nestedBindings);
+    }
+    if (callbackBinding.arrayParameterIndex !== undefined) {
+        const arrayParameter = callbackDeclaration.parameters[callbackBinding.arrayParameterIndex];
+        if (arrayParameter) {
+            bindFunctionBindingName(context, arrayParameter.name, normalizeFunctionBodyPath(context, receiver, bindings), receiver, nestedBindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, nestedBindings);
+}
+function arrayCallbackExpressionAffectsNarrow(context, receiver, member, callExpression, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_ARRAY_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = isFunctionLikeWithBody(callbackArgument)
+        ? callbackArgument
+        : (() => {
+            const boundValue = getStateExpressionBoundValue(context, callbackArgument, state);
+            return boundValue ? getFunctionLikeFromBoundValue(context, boundValue) : undefined;
+        })();
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeElement = getUniformArrayElementBindingFromExpression(context, receiver, state);
+    if (!representativeElement) {
+        return false;
+    }
+    const bindings = getFunctionBindings(context, [], callbackDeclaration, state);
+    const elementParameter = callbackDeclaration.parameters[callbackBinding.elementParameterIndex];
+    if (elementParameter) {
+        bindFunctionBindingName(context, elementParameter.name, representativeElement.path, representativeElement.value, bindings);
+    }
+    if (callbackBinding.arrayParameterIndex !== undefined) {
+        const arrayParameter = callbackDeclaration.parameters[callbackBinding.arrayParameterIndex];
+        if (arrayParameter) {
+            bindFunctionBindingName(context, arrayParameter.name, normalizeExpressionPath(context, receiver, state), getStateExpressionBoundValue(context, receiver, state) ?? receiver, bindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, bindings);
+}
+function setCallbackArgumentAffectsNarrow(context, receiver, member, callExpression, bindings, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_SET_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = getLocalCallbackFunctionLike(context, callbackArgument, bindings);
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeElement = getUniformSetElementBindingFromFunctionBodyExpression(context, receiver, bindings);
+    if (!representativeElement) {
+        return false;
+    }
+    const nestedBindings = getNestedFunctionBindings(context, [], callbackDeclaration, bindings);
+    for (const parameterIndex of callbackBinding.elementParameterIndexes) {
+        const parameter = callbackDeclaration.parameters[parameterIndex];
+        if (!parameter) {
+            continue;
+        }
+        bindFunctionBindingName(context, parameter.name, representativeElement.path, representativeElement.value, nestedBindings);
+    }
+    if (callbackBinding.receiverParameterIndex !== undefined) {
+        const receiverParameter = callbackDeclaration.parameters[callbackBinding.receiverParameterIndex];
+        if (receiverParameter) {
+            bindFunctionBindingName(context, receiverParameter.name, normalizeFunctionBodyPath(context, receiver, bindings), receiver, nestedBindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, nestedBindings);
+}
+function setCallbackExpressionAffectsNarrow(context, receiver, member, callExpression, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_SET_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = isFunctionLikeWithBody(callbackArgument)
+        ? callbackArgument
+        : (() => {
+            const boundValue = getStateExpressionBoundValue(context, callbackArgument, state);
+            return boundValue ? getFunctionLikeFromBoundValue(context, boundValue) : undefined;
+        })();
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeElement = getUniformSetElementBindingFromExpression(context, receiver, state);
+    if (!representativeElement) {
+        return false;
+    }
+    const bindings = getFunctionBindings(context, [], callbackDeclaration, state);
+    for (const parameterIndex of callbackBinding.elementParameterIndexes) {
+        const parameter = callbackDeclaration.parameters[parameterIndex];
+        if (!parameter) {
+            continue;
+        }
+        bindFunctionBindingName(context, parameter.name, representativeElement.path, representativeElement.value, bindings);
+    }
+    if (callbackBinding.receiverParameterIndex !== undefined) {
+        const receiverParameter = callbackDeclaration.parameters[callbackBinding.receiverParameterIndex];
+        if (receiverParameter) {
+            bindFunctionBindingName(context, receiverParameter.name, normalizeExpressionPath(context, receiver, state), getStateExpressionBoundValue(context, receiver, state) ?? receiver, bindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, bindings);
+}
+function mapCallbackArgumentAffectsNarrow(context, receiver, member, callExpression, bindings, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_MAP_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = getLocalCallbackFunctionLike(context, callbackArgument, bindings);
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeEntry = getUniformMapEntryBindingsFromFunctionBodyExpression(context, receiver, bindings);
+    if (!representativeEntry) {
+        return false;
+    }
+    const nestedBindings = getNestedFunctionBindings(context, [], callbackDeclaration, bindings);
+    if (callbackBinding.valueParameterIndex !== undefined && representativeEntry.value) {
+        const parameter = callbackDeclaration.parameters[callbackBinding.valueParameterIndex];
+        if (parameter) {
+            bindFunctionBindingName(context, parameter.name, representativeEntry.value.path, representativeEntry.value.value, nestedBindings);
+        }
+    }
+    if (callbackBinding.keyParameterIndex !== undefined && representativeEntry.key) {
+        const parameter = callbackDeclaration.parameters[callbackBinding.keyParameterIndex];
+        if (parameter) {
+            bindFunctionBindingName(context, parameter.name, representativeEntry.key.path, representativeEntry.key.value, nestedBindings);
+        }
+    }
+    if (callbackBinding.receiverParameterIndex !== undefined) {
+        const receiverParameter = callbackDeclaration.parameters[callbackBinding.receiverParameterIndex];
+        if (receiverParameter) {
+            bindFunctionBindingName(context, receiverParameter.name, normalizeFunctionBodyPath(context, receiver, bindings), receiver, nestedBindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, nestedBindings);
+}
+function mapCallbackExpressionAffectsNarrow(context, receiver, member, callExpression, narrowPath, state) {
+    const callbackBinding = member
+        ? SYNCHRONOUS_MAP_CALLBACK_PARAMETER_BINDINGS.get(member)
+        : undefined;
+    if (!callbackBinding) {
+        return false;
+    }
+    const callbackArgument = callExpression.arguments[callbackBinding.callbackArgumentIndex];
+    if (!callbackArgument) {
+        return false;
+    }
+    const callbackDeclaration = isFunctionLikeWithBody(callbackArgument)
+        ? callbackArgument
+        : (() => {
+            const boundValue = getStateExpressionBoundValue(context, callbackArgument, state);
+            return boundValue ? getFunctionLikeFromBoundValue(context, boundValue) : undefined;
+        })();
+    if (!callbackDeclaration) {
+        return false;
+    }
+    const representativeEntry = getUniformMapEntryBindingsFromExpression(context, receiver, state);
+    if (!representativeEntry) {
+        return false;
+    }
+    const bindings = getFunctionBindings(context, [], callbackDeclaration, state);
+    if (callbackBinding.valueParameterIndex !== undefined && representativeEntry.value) {
+        const parameter = callbackDeclaration.parameters[callbackBinding.valueParameterIndex];
+        if (parameter) {
+            bindFunctionBindingName(context, parameter.name, representativeEntry.value.path, representativeEntry.value.value, bindings);
+        }
+    }
+    if (callbackBinding.keyParameterIndex !== undefined && representativeEntry.key) {
+        const parameter = callbackDeclaration.parameters[callbackBinding.keyParameterIndex];
+        if (parameter) {
+            bindFunctionBindingName(context, parameter.name, representativeEntry.key.path, representativeEntry.key.value, bindings);
+        }
+    }
+    if (callbackBinding.receiverParameterIndex !== undefined) {
+        const receiverParameter = callbackDeclaration.parameters[callbackBinding.receiverParameterIndex];
+        if (receiverParameter) {
+            bindFunctionBindingName(context, receiverParameter.name, normalizeExpressionPath(context, receiver, state), getStateExpressionBoundValue(context, receiver, state) ?? receiver, bindings);
+        }
+    }
+    return functionLikeAffectsNarrow(context, callbackDeclaration, [], narrowPath, state, false, undefined, bindings);
+}
+function functionLikeAffectsNarrow(context, declaration, argumentsList, narrowPath, state, allowCapturedRead, receiverBinding, precomputedBindings, activeDeclarations = new Set()) {
+    const body = declaration.body;
+    if (!body || activeDeclarations.has(declaration)) {
+        return false;
+    }
+    activeDeclarations.add(declaration);
+    try {
+        const bindings = precomputedBindings ?? getFunctionBindings(context, argumentsList, declaration, state);
+        if (receiverBinding) {
+            bindFunctionReceiverPath(bindings, receiverBinding.path);
+            bindings.receiverMemberPaths = receiverBinding.memberPaths;
+        }
+        recordFunctionBodyConstBindings(context, body, bindings);
+        for (const candidate of getFlowInvalidationStructure(context, body, 'functionBody').candidates) {
+            if (candidate.kind === 'assignment') {
+                const leftPath = normalizeFunctionBodyPath(context, candidate.left, bindings);
+                if (leftPath && assignmentAffectsNarrow(context, candidate.node, leftPath, narrowPath)) {
+                    return true;
+                }
+            }
+            if (candidate.kind === 'delete') {
+                const targetPath = normalizeFunctionBodyPath(context, candidate.expression, bindings);
+                if (targetPath && mutationAffectsNarrow(targetPath, narrowPath)) {
+                    return true;
+                }
+            }
+            if (candidate.kind === 'update') {
+                const operandPath = normalizeFunctionBodyPath(context, candidate.operand, bindings);
+                if (operandPath &&
+                    typedUpdateExpressionAffectsNarrow(context, candidate.node, operandPath, narrowPath)) {
+                    return true;
+                }
+            }
+            if (candidate.kind === 'call') {
+                const directCalleeDeclaration = getFunctionLikeFromCallExpression(context, candidate.node);
+                const directCalleeHasBody = directCalleeDeclaration &&
+                    isFunctionLikeWithBody(directCalleeDeclaration);
+                const calledMember = getFunctionBodyCalledMember(context, candidate.node.expression, bindings);
+                if (calledMember &&
+                    arrayMutationCallAffectsNarrow(context, calledMember.receiver, normalizeFunctionBodyPath(context, calledMember.receiver, bindings), calledMember.member, calledMember.memberType, narrowPath)) {
+                    return true;
+                }
+                if (calledMember &&
+                    arrayCallbackArgumentAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, bindings, narrowPath, state)) {
+                    return true;
+                }
+                if (calledMember &&
+                    setCallbackArgumentAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, bindings, narrowPath, state)) {
+                    return true;
+                }
+                if (calledMember &&
+                    mapCallbackArgumentAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, bindings, narrowPath, state)) {
+                    return true;
+                }
+                const boundMemberDeclaration = getFunctionLikeFromBoundMemberCall(context, candidate.node.expression, bindings);
+                const boundMemberHasBody = boundMemberDeclaration && isFunctionLikeWithBody(boundMemberDeclaration);
+                const receiverBinding = calledMember
+                    ? getFunctionConstructedReceiverBinding(context, calledMember.receiver, bindings)
+                    : undefined;
+                if (boundMemberHasBody &&
+                    functionLikeAffectsNarrow(context, boundMemberDeclaration, candidate.node.arguments, narrowPath, state, false, receiverBinding, undefined, activeDeclarations)) {
+                    return true;
+                }
+                if (ts.isElementAccessExpression(candidate.node.expression) ||
+                    candidate.node.questionDotToken !== undefined) {
+                    const receiver = ts.isPropertyAccessExpression(candidate.node.expression) ||
+                        ts.isElementAccessExpression(candidate.node.expression)
+                        ? candidate.node.expression.expression
+                        : undefined;
+                    if (receiver) {
+                        const receiverPath = normalizeFunctionBodyPath(context, receiver, bindings);
+                        if (receiverPath &&
+                            receiverPath.baseSymbol === narrowPath.baseSymbol &&
+                            receiverPath.segments.length === 0 &&
+                            narrowPath.segments.length > 0) {
+                            return true;
+                        }
+                    }
+                }
+                if (directCalleeHasBody &&
+                    functionLikeAffectsNarrow(context, directCalleeDeclaration, candidate.node.arguments, narrowPath, state, false, receiverBinding, undefined, activeDeclarations)) {
+                    return true;
+                }
+                if (ts.isIdentifier(candidate.node.expression)) {
+                    const parameterSymbol = getExpressionSymbol(context, candidate.node.expression);
+                    if (parameterSymbol) {
+                        const boundValue = bindings.boundValues.get(getSymbolId(context, parameterSymbol));
+                        const boundFunction = boundValue
+                            ? getFunctionLikeFromBoundValue(context, boundValue)
+                            : undefined;
+                        const boundFunctionHasBody = boundFunction && isFunctionLikeWithBody(boundFunction);
+                        if (boundFunctionHasBody &&
+                            functionLikeAffectsNarrow(context, boundFunction, candidate.node.arguments, narrowPath, state, false, undefined, undefined, activeDeclarations)) {
+                            return true;
+                        }
+                    }
+                }
+                if (!directCalleeHasBody &&
+                    !boundMemberHasBody &&
+                    candidate.node.arguments.some((argument) => opaqueFunctionBodyArgumentExpressionAffectsNarrow(context, argument, bindings, narrowPath, state, body))) {
+                    return true;
+                }
+            }
+            if (allowCapturedRead &&
+                getMutableBindingSymbol(narrowPath) &&
+                candidate.kind === 'access') {
+                const usedPath = normalizeFunctionBodyPath(context, candidate.node, bindings);
+                if (usedPath && pathsMatch(usedPath, narrowPath)) {
+                    return true;
+                }
+            }
+            if (candidate.kind === 'access' &&
+                ts.isIdentifier(candidate.node) &&
+                boundParameterAffectsNarrow(context, candidate.node, bindings, narrowPath, state)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    finally {
+        activeDeclarations.delete(declaration);
+    }
+}
+function classInstanceMethodsAffectNarrow(context, constructorDeclaration, argumentsList, narrowPath, state) {
+    const classLike = constructorDeclaration.parent;
+    if (!ts.isClassLike(classLike)) {
+        return false;
+    }
+    let hasInstanceMethod = false;
+    const receiverBinding = getConstructorReceiverBindingFromState(context, constructorDeclaration, argumentsList, state);
+    for (const member of classLike.members) {
+        if ((ts.isMethodDeclaration(member) || ts.isGetAccessorDeclaration(member) ||
+            ts.isSetAccessorDeclaration(member)) &&
+            !hasStaticModifier(member)) {
+            hasInstanceMethod = true;
+            if (isFunctionLikeWithBody(member) &&
+                functionLikeAffectsNarrow(context, member, [], narrowPath, state, false, receiverBinding)) {
+                return true;
+            }
+        }
+    }
+    return hasInstanceMethod &&
+        argumentsList.some((argument) => expressionPathEscapesNarrow(context, argument, narrowPath, state));
+}
+function hasStaticModifier(node) {
+    return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Static) !== 0;
+}
+function escapingExpressionAffectsNarrow(context, expression, narrowPath, state, seenExpressions = new Set()) {
+    expression = ts.isParenthesizedExpression(expression) ? expression.expression : expression;
+    if (seenExpressions.has(expression)) {
+        return false;
+    }
+    seenExpressions.add(expression);
+    for (const candidate of getFlowInvalidationStructure(context, expression, 'expression').candidates) {
+        if (candidate.kind === 'access' &&
+            expressionPathEscapesNarrow(context, candidate.node, narrowPath, state)) {
+            return true;
+        }
+        if (candidate.kind === 'shorthandProperty') {
+            const boundValue = getShorthandStateBoundValue(context, candidate.node, state);
+            if (!boundValue) {
+                continue;
+            }
+            if (ts.isExpression(boundValue) &&
+                escapingExpressionAffectsNarrow(context, boundValue, narrowPath, state, seenExpressions)) {
+                return true;
+            }
+            const boundFunction = getFunctionLikeFromBoundValue(context, boundValue);
+            if (boundFunction &&
+                functionLikeAffectsNarrow(context, boundFunction, [], narrowPath, state, false)) {
+                return true;
+            }
+        }
+        if (candidate.kind === 'access' &&
+            ts.isIdentifier(candidate.node) &&
+            stateBoundValueAffectsNarrow(context, candidate.node, narrowPath, state, seenExpressions)) {
+            return true;
+        }
+        if (candidate.kind === 'functionLike' &&
+            functionLikeAffectsNarrow(context, candidate.node, [], narrowPath, state, false)) {
+            return true;
+        }
+        if (candidate.kind === 'call') {
+            const calledMember = getCalledMember(context, candidate.node.expression);
+            if (calledMember &&
+                arrayMutationCallAffectsNarrow(context, calledMember.receiver, normalizeExpressionPath(context, calledMember.receiver, state), calledMember.member, calledMember.memberType, narrowPath)) {
+                return true;
+            }
+            if (ts.isElementAccessExpression(candidate.node.expression) ||
+                candidate.node.questionDotToken !== undefined) {
+                const receiver = ts.isPropertyAccessExpression(candidate.node.expression) ||
+                    ts.isElementAccessExpression(candidate.node.expression)
+                    ? candidate.node.expression.expression
+                    : undefined;
+                if (receiver) {
+                    const receiverPath = normalizeExpressionPath(context, receiver, state);
+                    if (receiverPath &&
+                        receiverPath.baseSymbol === narrowPath.baseSymbol &&
+                        receiverPath.segments.length === 0 &&
+                        narrowPath.segments.length > 0) {
+                        return true;
+                    }
+                }
+            }
+            const calleeDeclaration = getFunctionLikeFromCallExpression(context, candidate.node);
+            if (calleeDeclaration &&
+                functionLikeAffectsNarrow(context, calleeDeclaration, candidate.node.arguments, narrowPath, state, true, calledMember
+                    ? getStateConstructedReceiverBinding(context, calledMember.receiver, state, 'mutation')
+                    : undefined)) {
+                return true;
+            }
+            if (!calleeDeclaration &&
+                candidate.node.arguments.some((argument) => opaqueArgumentExpressionAffectsNarrow(context, argument, narrowPath, state))) {
+                return true;
+            }
+        }
+        if (candidate.kind === 'new') {
+            const constructorDeclaration = context.checker.getResolvedSignature(candidate.node)
+                ?.declaration;
+            if (constructorDeclaration &&
+                ((isFunctionLikeWithBody(constructorDeclaration) &&
+                    functionLikeAffectsNarrow(context, constructorDeclaration, candidate.node.arguments ?? [], narrowPath, state, false)) ||
+                    classInstanceMethodsAffectNarrow(context, constructorDeclaration, candidate.node.arguments ?? [], narrowPath, state))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export const FLOW_FACT_ENVIRONMENT = {
+    appendSegment,
+    escapingExpressionAffectsNarrow,
+    normalizeExpressionPath,
+    normalizeWholeValueFactPath(context, expression, state) {
+        const path = normalizeExpressionPath(context, expression, state);
+        if (!path) {
+            return undefined;
+        }
+        const unwrappedExpression = ts.isParenthesizedExpression(expression) ||
+            ts.isAsExpression(expression) ||
+            ts.isTypeAssertionExpression(expression) ||
+            ts.isNonNullExpression(expression) ||
+            ts.isSatisfiesExpression(expression)
+            ? unwrapTransparentExpression(expression)
+            : expression;
+        if (!ts.isIdentifier(unwrappedExpression)) {
+            return path;
+        }
+        const symbol = getExpressionSymbol(context, unwrappedExpression);
+        if (!symbol) {
+            return path;
+        }
+        const localPath = {
+            baseSymbol: symbol,
+            segments: [],
+        };
+        return isConstLocalBindingPath(localPath) ? localPath : path;
+    },
+    shouldTrackFact(context, path) {
+        return !isStableConstLocalBindingPath(context, path);
+    },
+};
+function stateBoundValueAffectsNarrow(context, expression, narrowPath, state, seenExpressions = new Set()) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return stateBoundValueAffectsNarrow(context, expression.expression, narrowPath, state, seenExpressions);
+    }
+    if (!ts.isIdentifier(expression)) {
+        return false;
+    }
+    if (seenExpressions.has(expression)) {
+        return false;
+    }
+    seenExpressions.add(expression);
+    const symbol = getExpressionSymbol(context, expression);
+    if (!symbol) {
+        return false;
+    }
+    const symbolId = getSymbolId(context, symbol);
+    if (state.extractedBindings.has(symbolId)) {
+        return false;
+    }
+    const boundValue = state.boundValues.get(symbolId);
+    if (!boundValue) {
+        return false;
+    }
+    if (ts.isExpression(boundValue) &&
+        escapingExpressionAffectsNarrow(context, boundValue, narrowPath, state, seenExpressions)) {
+        return true;
+    }
+    const boundFunction = getFunctionLikeFromBoundValue(context, boundValue);
+    return boundFunction !== undefined &&
+        functionLikeAffectsNarrow(context, boundFunction, [], narrowPath, state, false);
+}
+function getFlowInvalidationStructure(context, node, optionsKey) {
+    return context.facts.getFlowInvalidationStructure(node, optionsKey, () => parseFlowInvalidationStructure(node, optionsKey === 'expression'));
+}
+function parseFlowInvalidationStructure(rootNode, includeNestedFunctionLikeCandidates) {
+    const candidates = [];
+    const visit = (node) => {
+        if (isFunctionLikeWithBody(node)) {
+            if (includeNestedFunctionLikeCandidates) {
+                candidates.push({
+                    kind: 'functionLike',
+                    node,
+                });
+            }
+            return;
+        }
+        if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) ||
+            ts.isElementAccessExpression(node)) {
+            candidates.push({
+                kind: 'access',
+                node,
+            });
+        }
+        else if (ts.isBinaryExpression(node) &&
+            MUTATING_ASSIGNMENT_OPERATORS.has(node.operatorToken.kind)) {
+            candidates.push({
+                kind: 'assignment',
+                left: node.left,
+                node,
+                right: node.right,
+            });
+        }
+        else if (ts.isDeleteExpression(node)) {
+            candidates.push({
+                kind: 'delete',
+                expression: node.expression,
+                node,
+            });
+        }
+        else {
+            const updateOperand = getUpdateExpressionOperand(node);
+            if (updateOperand &&
+                (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node))) {
+                candidates.push({
+                    kind: 'update',
+                    node,
+                    operand: updateOperand,
+                });
+            }
+            else if (ts.isAwaitExpression(node) || ts.isYieldExpression(node)) {
+                candidates.push({
+                    kind: 'awaitYield',
+                    node,
+                });
+            }
+            else if (ts.isCallExpression(node)) {
+                candidates.push({
+                    kind: 'call',
+                    node,
+                });
+            }
+            else if (ts.isShorthandPropertyAssignment(node)) {
+                candidates.push({
+                    kind: 'shorthandProperty',
+                    node,
+                });
+            }
+            else if (ts.isNewExpression(node)) {
+                candidates.push({
+                    kind: 'new',
+                    node,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(rootNode);
+    return { candidates };
+}
+export function statementAffectsNarrow(context, statement, narrowPath, state) {
+    for (const candidate of getFlowInvalidationStructure(context, statement, 'statement').candidates) {
+        if (candidate.kind === 'awaitYield') {
+            if (narrowPath.segments.length > 0) {
+                return candidate.node;
+            }
+        }
+        if (candidate.kind === 'assignment') {
+            const leftPath = getInvalidationPath(context, candidate.left, state, 'mutation');
+            if (leftPath && assignmentAffectsNarrow(context, candidate.node, leftPath, narrowPath)) {
+                return candidate.left;
+            }
+            if (leftPath &&
+                !isLocalBindingPath(leftPath) &&
+                escapingExpressionAffectsNarrow(context, candidate.right, narrowPath, state)) {
+                return candidate.left;
+            }
+        }
+        if (candidate.kind === 'delete') {
+            const targetPath = getInvalidationPath(context, candidate.expression, state, 'mutation');
+            if (targetPath && mutationAffectsNarrow(targetPath, narrowPath)) {
+                return candidate.expression;
+            }
+        }
+        if (candidate.kind === 'update') {
+            const operandPath = getInvalidationPath(context, candidate.operand, state, 'mutation');
+            if (operandPath &&
+                typedUpdateExpressionAffectsNarrow(context, candidate.node, operandPath, narrowPath)) {
+                return candidate.operand;
+            }
+        }
+        if (candidate.kind === 'call') {
+            const calledMember = getCalledMember(context, candidate.node.expression);
+            const receiverBinding = calledMember
+                ? getStateConstructedReceiverBinding(context, calledMember.receiver, state, 'mutation')
+                : undefined;
+            if (calledMember &&
+                arrayMutationCallAffectsNarrow(context, calledMember.receiver, receiverBinding?.path, calledMember.member, calledMember.memberType, narrowPath)) {
+                return candidate.node;
+            }
+            if (calledMember &&
+                arrayCallbackExpressionAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, narrowPath, state)) {
+                return candidate.node;
+            }
+            if (calledMember &&
+                setCallbackExpressionAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, narrowPath, state)) {
+                return candidate.node;
+            }
+            if (calledMember &&
+                mapCallbackExpressionAffectsNarrow(context, calledMember.receiver, calledMember.member, candidate.node, narrowPath, state)) {
+                return candidate.node;
+            }
+            if (ts.isElementAccessExpression(candidate.node.expression) ||
+                candidate.node.questionDotToken !== undefined) {
+                const receiver = ts.isPropertyAccessExpression(candidate.node.expression) ||
+                    ts.isElementAccessExpression(candidate.node.expression)
+                    ? candidate.node.expression.expression
+                    : undefined;
+                if (!receiver) {
+                    continue;
+                }
+                const receiverPath = normalizeExpressionPath(context, receiver, state);
+                if (receiverPath &&
+                    receiverPath.baseSymbol === narrowPath.baseSymbol &&
+                    receiverPath.segments.length === 0 &&
+                    narrowPath.segments.length > 0) {
+                    return candidate.node;
+                }
+            }
+            const calleeDeclaration = getFunctionLikeFromCallExpression(context, candidate.node);
+            if (calleeDeclaration &&
+                functionLikeAffectsNarrow(context, calleeDeclaration, candidate.node.arguments, narrowPath, state, true, receiverBinding)) {
+                return candidate.node;
+            }
+            if (!calleeDeclaration &&
+                candidate.node.arguments.some((argument) => {
+                    if (!opaqueArgumentExpressionAffectsNarrow(context, argument, narrowPath, state)) {
+                        return false;
+                    }
+                    if (!ts.isReturnStatement(statement)) {
+                        return true;
+                    }
+                    return !isExtractedReadOnlyReturnArgument(context, argument, state);
+                })) {
+                return candidate.node;
+            }
+        }
+        if (candidate.kind === 'new') {
+            const constructorDeclaration = context.checker.getResolvedSignature(candidate.node)
+                ?.declaration;
+            if (constructorDeclaration &&
+                isFunctionLikeWithBody(constructorDeclaration) &&
+                functionLikeAffectsNarrow(context, constructorDeclaration, candidate.node.arguments ?? [], narrowPath, state, true)) {
+                return candidate.node;
+            }
+        }
+    }
+    return undefined;
+}
+export function prepareChildRegionState(context, statement, state) {
+    if (ts.isForStatement(statement) && statement.initializer) {
+        const preparedState = cloneState(state);
+        if (ts.isVariableDeclarationList(statement.initializer)) {
+            for (const declaration of statement.initializer.declarations) {
+                recordVariableAliases(context, declaration, preparedState);
+            }
+            return preparedState;
+        }
+        recordExecutedExpressionAliases(context, statement.initializer, preparedState);
+        return preparedState;
+    }
+    if (ts.isForOfStatement(statement) &&
+        ts.isVariableDeclarationList(statement.initializer)) {
+        const preparedState = cloneState(state);
+        for (const declaration of statement.initializer.declarations) {
+            if (!recordForOfLoopHeaderAliases(context, declaration.name, statement.expression, preparedState)) {
+                recordVariableAliases(context, declaration, preparedState);
+            }
+        }
+        return preparedState;
+    }
+    return state;
+}