Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(javascript): preserve uncertain call targets across activation boundaries

morluto3b02179560f4
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
index 536281b30..794a53ffb 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts
@@ -165,7 +165,7 @@ describe("JavaScript semantic analysis: computed method keys", () => {
const name = "m";
const pick = () => "n";
const obj = { [name]() { return 1; }, [pick()]() { return name; } };
- class C { [name]() { return 2; } }
+ class C { [name]() { return 2; } [pick()]() { return 3; } }
}
`);
@@ -177,6 +177,14 @@ describe("JavaScript semantic analysis: computed method keys", () => {
callerCallableId: outer.callableId,
resolution: "exact",
});
+ expect(
+ ir.callSites.filter(
+ ({ callerCallableId, calleeCallableIds, resolution }) =>
+ callerCallableId === outer.callableId &&
+ calleeCallableIds.length === 1 &&
+ resolution === "exact",
+ ),
+ ).toHaveLength(2);
// Only the method body that reads `name` captures it; the computed keys
// are evaluated outside every method environment.
expect(
@@ -189,6 +197,23 @@ describe("JavaScript semantic analysis: computed method keys", () => {
).toEqual([{ owner: "method", binding: "name" }]);
});
+ it("keeps ordinary nested method-body reads uncertain", () => {
+ const ir = analyzeJavaScriptSemantics(`
+ function outer() {
+ const pick = () => "n";
+ return { method() { return pick(); } };
+ }
+ `);
+ const pick = onlyCallable(ir, "pick");
+ const pickCall = ir.callSites.find(({ calleeCallableIds }) =>
+ calleeCallableIds.includes(pick.callableId),
+ );
+ expect(pickCall).toMatchObject({
+ resolution: "ambiguous",
+ calleeCallableIds: [pick.callableId],
+ });
+ });
+
it("keeps callables nested in a computed method key in their own frames", () => {
const ir = analyzeJavaScriptSemantics(`
function outer() {
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.ts
index 239c0a79a..e569948e4 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts
@@ -7,6 +7,7 @@ import {
import * as t from "@babel/types";
import {
+ semanticComputedMethodKey,
semanticBranchMayBeSkipped,
semanticIterationCardinality,
} from "./javascriptSemanticEvaluationOrder.js";
@@ -1029,10 +1030,7 @@ function* collectDefinitionsSteps(
needsPrototypeFacts = true;
let parentScope = currentSemanticScope(stack);
if (
- parent !== null &&
- (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
- parent.computed &&
- parent.key === node &&
+ semanticComputedMethodKey(parent ?? undefined, node) &&
parentScope.parentScopeId !== null
) {
// A computed method key is evaluated before entering the method's
diff --git a/src/domain/javascript/javascriptSemanticCallResolution.test.ts b/src/domain/javascript/javascriptSemanticCallResolution.test.ts
index 54e1dc0ef..f24fc89c1 100644
--- a/src/domain/javascript/javascriptSemanticCallResolution.test.ts
+++ b/src/domain/javascript/javascriptSemanticCallResolution.test.ts
@@ -137,6 +137,123 @@ it("does not reuse a later resolved callback at an earlier read", () => {
expect(context.resolve(after)).toMatchObject({ complete: true });
});
+it("keeps a nested callback read uncertain across a later var initializer", () => {
+ const context = indexed(
+ `function target(){} function read(){cb();} read(); var cb=target;`,
+ );
+ const target = context.state.callables.find(
+ (callable) => callable.name === "target",
+ );
+ let read: t.Identifier | undefined;
+ traverseJavaScriptAst(context.state.program, {
+ enter(node) {
+ if (
+ t.isCallExpression(node) &&
+ t.isIdentifier(node.callee, { name: "cb" })
+ )
+ read = node.callee;
+ },
+ });
+ if (target === undefined || read === undefined)
+ throw new Error("Missing target or callback read");
+ expect(context.resolve(read)).toMatchObject({
+ callableIds: [target.callableId],
+ complete: false,
+ });
+});
+
+it("keeps same-activation calls after a var initializer resolved", () => {
+ const context = indexed(`function target(){} var cb=target; cb();`);
+ let read: t.Identifier | undefined;
+ traverseJavaScriptAst(context.state.program, {
+ enter(node) {
+ if (
+ t.isCallExpression(node) &&
+ t.isIdentifier(node.callee, { name: "cb" })
+ )
+ read = node.callee;
+ },
+ });
+ if (read === undefined) throw new Error("Missing callback read");
+ expect(context.resolve(read)).toMatchObject({
+ callableIds: [context.state.callables[0]?.callableId],
+ complete: true,
+ });
+});
+
+it("keeps a hoisted function declaration resolved from a nested read", () => {
+ const context = indexed(
+ `function read(){target();} read(); function target(){}`,
+ );
+ const target = context.state.callables.find(
+ (callable) => callable.name === "target",
+ );
+ let read: t.Identifier | undefined;
+ traverseJavaScriptAst(context.state.program, {
+ enter(node) {
+ if (
+ t.isCallExpression(node) &&
+ t.isIdentifier(node.callee, { name: "target" })
+ )
+ read = node.callee;
+ },
+ });
+ if (target === undefined || read === undefined)
+ throw new Error("Missing target or nested call");
+ expect(context.resolve(read)).toMatchObject({
+ callableIds: [target.callableId],
+ complete: true,
+ });
+});
+
+it("does not infer hoisting for a conditional function declaration", () => {
+ const context = indexed(
+ `if (flag) { function target(){} } function read(){target();} read();`,
+ );
+ let read: t.Identifier | undefined;
+ traverseJavaScriptAst(context.state.program, {
+ enter(node) {
+ if (
+ t.isCallExpression(node) &&
+ t.isIdentifier(node.callee, { name: "target" })
+ )
+ read = node.callee;
+ },
+ });
+ if (read === undefined) throw new Error("Missing conditional function read");
+ expect(context.resolve(read)).toMatchObject({ complete: false });
+});
+
+it("uses class declaration order instead of a stable initializer shortcut", () => {
+ const before = indexed("class Target {} new Target();");
+ const after = indexed("new Target(); class Target {}");
+ const exported = indexed("export class Target {} new Target();");
+ const callTarget = (context: ReturnType<typeof indexed>) => {
+ let read: t.Identifier | undefined;
+ traverseJavaScriptAst(context.state.program, {
+ enter(node) {
+ if (
+ t.isNewExpression(node) &&
+ t.isIdentifier(node.callee, { name: "Target" })
+ )
+ read = node.callee;
+ },
+ });
+ if (read === undefined) throw new Error("Missing class constructor read");
+ return context.resolve(read);
+ };
+ const beforeTarget = before.state.callables.find(
+ (callable) => callable.name === "Target",
+ );
+ if (beforeTarget === undefined) throw new Error("Missing class target");
+ expect(callTarget(before)).toMatchObject({
+ callableIds: [beforeTarget.callableId],
+ complete: true,
+ });
+ expect(callTarget(after)).toMatchObject({ complete: false });
+ expect(callTarget(exported)).toMatchObject({ complete: true });
+});
+
it.each([false, true])(
"bounds separate branch assignments with intrinsic cycle=%s",
(cyclic) => {
diff --git a/src/domain/javascript/javascriptSemanticCallResolution.ts b/src/domain/javascript/javascriptSemanticCallResolution.ts
index 4ca40cc9f..473cd60fd 100644
--- a/src/domain/javascript/javascriptSemanticCallResolution.ts
+++ b/src/domain/javascript/javascriptSemanticCallResolution.ts
@@ -13,7 +13,6 @@ import {
} from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
- semanticStableInitializer,
type JavaScriptSemanticAnalysisState,
type JavaScriptSemanticBindingState,
type JavaScriptSemanticInitializer,
@@ -128,9 +127,7 @@ const resolveIdentifier = (
);
// Knowing every local candidate does not prove that any write replaced the
// incoming value, or that a write in another activation precedes this read.
- const covered =
- read.hasDefiniteInitializer ||
- semanticStableInitializer(binding, context.state) !== undefined;
+ const covered = read.hasDefiniteInitializer;
const resolution =
candidates.complete && !covered
? {
diff --git a/src/domain/javascript/javascriptSemanticCallableStack.ts b/src/domain/javascript/javascriptSemanticCallableStack.ts
index 0718d4aad..f7c84d204 100644
--- a/src/domain/javascript/javascriptSemanticCallableStack.ts
+++ b/src/domain/javascript/javascriptSemanticCallableStack.ts
@@ -1,5 +1,6 @@
import * as t from "@babel/types";
+import { semanticComputedMethodKey } from "./javascriptSemanticEvaluationOrder.js";
import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
/**
@@ -48,9 +49,7 @@ export const createSemanticCallableStack = <Callable>(
enter: (node, parent) => {
if (
parent !== null &&
- (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
- parent.computed &&
- parent.key === node &&
+ semanticComputedMethodKey(parent, node) &&
frames.at(-1)?.callableId === semanticCallableIdForNode(parent)
) {
const method = pop();
diff --git a/src/domain/javascript/javascriptSemanticEvaluationOrder.ts b/src/domain/javascript/javascriptSemanticEvaluationOrder.ts
index 62013fc95..d5cdc38c5 100644
--- a/src/domain/javascript/javascriptSemanticEvaluationOrder.ts
+++ b/src/domain/javascript/javascriptSemanticEvaluationOrder.ts
@@ -13,6 +13,15 @@ export type JavaScriptSemanticIterationCardinality =
| "nonempty"
| "unknown";
+/** Whether a method's computed key executes in the enclosing environment. */
+export const semanticComputedMethodKey = (
+ parent: t.Node | undefined,
+ child: t.Node,
+): boolean =>
+ (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&
+ parent.computed &&
+ parent.key === child;
+
/** Exact source-only cardinality for literal loop heads. */
export const semanticIterationCardinality = (
loop: t.ForInStatement | t.ForOfStatement,
diff --git a/src/domain/javascript/javascriptSemanticMutationInitializers.ts b/src/domain/javascript/javascriptSemanticMutationInitializers.ts
index c297caa13..a29fed448 100644
--- a/src/domain/javascript/javascriptSemanticMutationInitializers.ts
+++ b/src/domain/javascript/javascriptSemanticMutationInitializers.ts
@@ -2,6 +2,7 @@ import * as t from "@babel/types";
import {
delayedInstanceFieldValue,
+ semanticComputedMethodKey,
semanticBranchMayBeSkipped,
semanticIterationCardinality,
} from "./javascriptSemanticEvaluationOrder.js";
@@ -377,6 +378,16 @@ const computeDirectInitializerPosition = (
node: t.Node,
parents: WeakMap<t.Node, t.Node>,
): StatementPosition | null => {
+ if (t.isClassDeclaration(node) && node.id !== null) {
+ const parent = parents.get(node);
+ const statement =
+ (t.isExportNamedDeclaration(parent) ||
+ t.isExportDefaultDeclaration(parent)) &&
+ parent.declaration === node
+ ? parent
+ : node;
+ return statementPosition(statement, parents);
+ }
if (
(t.isAssignmentExpression(node) &&
t.isIdentifier(unwrapJavaScriptExpression(node.left).node)) ||
@@ -597,7 +608,7 @@ const bindingReadPosition = (
}
if (
parent === undefined ||
- t.isFunction(parent) ||
+ (t.isFunction(parent) && !semanticComputedMethodKey(parent, current)) ||
delayedInstanceFieldValue(parent, current)
) {
result = { position: null, repeating: false };
@@ -646,6 +657,17 @@ export const semanticBindingAtRead = (
binding.referenceInitializers.length === 0
)
return { status: "ordered", binding, hasDefiniteInitializer: false };
+ const [soleInitializer] = binding.initializers;
+ if (
+ binding.initializers.length === 1 &&
+ binding.referenceInitializers.length === 0 &&
+ binding.declarationKinds.size === 0 &&
+ binding.definitions.length === 1 &&
+ binding.definitions[0]?.kind === "function" &&
+ soleInitializer !== undefined &&
+ t.isFunctionDeclaration(soleInitializer.node)
+ )
+ return { status: "ordered", binding, hasDefiniteInitializer: true };
const initializer = binding.initializers[0];
const reference = binding.referenceInitializers[0];
const origin = initializer ?? reference;