Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
refactor(javascript): share computed-key callable ownership
morluto76fa5304a8f1
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.tsindex 217480175..536281b30 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.calls.test.ts@@ -158,6 +158,121 @@ describe("JavaScript semantic analysis: calls 1", () => {});});+describe("JavaScript semantic analysis: computed method keys", () => {+ it("evaluates computed method keys in the enclosing callable", () => {+ const ir = analyzeJavaScriptSemantics(`+ function outer() {+ const name = "m";+ const pick = () => "n";+ const obj = { [name]() { return 1; }, [pick()]() { return name; } };+ class C { [name]() { return 2; } }+ }+ `);++ const outer = onlyCallable(ir, "outer");+ const pickCall = ir.callSites.find(+ ({ calleeCallableIds }) => calleeCallableIds.length === 1,+ );+ expect(pickCall).toMatchObject({+ callerCallableId: outer.callableId,+ resolution: "exact",+ });+ // Only the method body that reads `name` captures it; the computed keys+ // are evaluated outside every method environment.+ expect(+ ir.closureCaptures.map(({ callableId, bindingId }) => ({+ owner: ir.callables.find(+ (callable) => callable.callableId === callableId,+ )?.kind,+ binding: bindingById(ir, bindingId)?.name,+ })),+ ).toEqual([{ owner: "method", binding: "name" }]);+ });++ it("keeps callables nested in a computed method key in their own frames", () => {+ const ir = analyzeJavaScriptSemantics(`+ function outer() {+ const name = "m";+ const pick = () => "n";+ return { [(() => pick())()]() { return name; } };+ }+ `);++ const outer = onlyCallable(ir, "outer");+ const pick = onlyCallable(ir, "pick");+ const keyArrow = ir.callables.find(+ ({ kind, name }) => kind === "function" && name === null,+ );+ const method = ir.callables.find(({ kind }) => kind === "method");+ expect(keyArrow).toBeDefined();+ expect(method).toBeDefined();+ const callerOf = (calleeCallableId: string | undefined) =>+ ir.callSites.find(({ calleeCallableIds }) =>+ calleeCallableIds.includes(calleeCallableId ?? ""),+ )?.callerCallableId;+ expect(callerOf(pick.callableId)).toBe(keyArrow?.callableId);+ expect(callerOf(keyArrow?.callableId)).toBe(outer.callableId);+ expect(+ ir.closureCaptures.map(({ callableId, bindingId }) => ({+ callableId,+ binding: bindingById(ir, bindingId)?.name,+ })),+ ).toEqual(+ expect.arrayContaining([+ { callableId: keyArrow?.callableId, binding: "pick" },+ { callableId: method?.callableId, binding: "name" },+ ]),+ );+ });++ it("attributes effects in computed method keys to the enclosing callable", () => {+ const ir = analyzeJavaScriptSemantics(`+ import { spawn } from "node:child_process";+ function outer(config) {+ return {+ [fetch("/x")]() {},+ [setTimeout(tick, 1)]() {},+ [Promise.resolve(1)]() {},+ [spawn("ls")]() {},+ [config.key]() {},+ };+ }+ class C { [fetch("/y")]() {} }+ `);++ const outer = onlyCallable(ir, "outer");+ const owners = (+ operations: readonly { readonly ownerCallableId: string | null }[],+ ) => operations.map(({ ownerCallableId }) => ownerCallableId);+ const methodIds = new Set(+ ir.callables+ .filter(({ kind }) => kind === "method")+ .map(({ callableId }) => callableId),+ );+ expect(methodIds.size).toBe(6);+ const classId = onlyCallable(ir, "C").callableId;+ expect(owners(ir.requestOperations).sort()).toEqual(+ [outer.callableId, classId].sort(),+ );+ expect(owners(ir.timerOperations)).toEqual([outer.callableId]);+ expect(owners(ir.promiseOperations)).toEqual([outer.callableId]);+ expect(owners(ir.childProcessSpawns)).toEqual([outer.callableId]);+ expect(+ ir.objectOperations.filter(({ propertyPath }) =>+ propertyPath?.includes("key"),+ ),+ ).toEqual([expect.objectContaining({ ownerCallableId: outer.callableId })]);+ for (const owner of [+ ...owners(ir.requestOperations),+ ...owners(ir.timerOperations),+ ...owners(ir.promiseOperations),+ ...owners(ir.childProcessSpawns),+ ...owners(ir.objectOperations),+ ])+ expect(methodIds.has(owner ?? "")).toBe(false);+ });+});+describe("JavaScript semantic analysis: calls 2", () => {it("does not treat a shadowed Promise binding as the intrinsic", () => {const ir = analyzeJavaScriptSemantics(`diff --git a/src/domain/javascript/javascriptSemanticAsyncEffects.ts b/src/domain/javascript/javascriptSemanticAsyncEffects.tsindex 6ab62bd59..a34bfb750 100644--- a/src/domain/javascript/javascriptSemanticAsyncEffects.ts+++ b/src/domain/javascript/javascriptSemanticAsyncEffects.ts@@ -5,7 +5,7 @@ import type {JavaScriptSemanticEventOperation,JavaScriptSemanticTimerOperation,} from "./javascriptSemanticIr.js";-import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";import { semanticStaticPropertyName } from "./javascriptAstValues.js";import {resolveSemanticBindingState,@@ -94,15 +94,13 @@ export const collectJavaScriptSemanticAsyncEffects = (const events: JavaScriptSemanticEventOperation[] = [];const timers: TimerCandidate[] = [];const callableIds = new Set(callables.map(({ callableId }) => callableId));- const callableStack: string[] = [];+ const callableStack = createSemanticCallableIdStack(callableIds);const ancestors: t.Node[] = [];traverseJavaScriptAst(program, {- enter: (node) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && callableIds.has(callableId))- callableStack.push(callableId);+ enter: (node, parent) => {+ callableStack.enter(node, parent);if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {- const ownerCallableId = callableStack.at(-1) ?? null;+ const ownerCallableId = callableStack.callables.at(-1) ?? null;collectEvent(node, ownerCallableId, state, events);collectTimer({node,@@ -115,10 +113,8 @@ export const collectJavaScriptSemanticAsyncEffects = (ancestors.push(node);},exit: (node) => {- const callableId = semanticCallableIdForNode(node);ancestors.pop();- if (callableId !== null && callableStack.at(-1) === callableId)- callableStack.pop();+ callableStack.exit(node);},});return {diff --git a/src/domain/javascript/javascriptSemanticCallableStack.ts b/src/domain/javascript/javascriptSemanticCallableStack.tsnew file mode 100644index 000000000..0718d4aad--- /dev/null+++ b/src/domain/javascript/javascriptSemanticCallableStack.ts@@ -0,0 +1,85 @@+import * as t from "@babel/types";++import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";++/**+ * Innermost-last stack of admitted callables during one enter/exit traversal.+ *+ * Single owner for semantic callable ownership. A computed object/class method+ * key is evaluated before the method's parameter and body environments, so the+ * method is set aside while its key is traversed and the enclosing callable+ * owns every fact recovered from the key. Collectors share this tracker so+ * calls, captures, effects, promises, and object operations agree.+ */+export interface SemanticCallableStack<Callable> {+ /** Admitted callables, outermost first; the innermost owner is last. */+ readonly callables: readonly Callable[];+ readonly enter: (node: t.Node, parent: t.Node | null) => void;+ readonly exit: (node: t.Node) => void;+}++interface CallableFrame<Callable> {+ readonly callableId: string;+ readonly callable: Callable;+}++/**+ * Track callables admitted by `admit`, which maps a callable ID to the value+ * kept on the stack or `undefined` to ignore it. A caller-owned `callables`+ * array is updated in place, so shared contexts can keep reading it.+ */+export const createSemanticCallableStack = <Callable>(+ admit: (callableId: string) => Callable | undefined,+ callables: Callable[] = [],+): SemanticCallableStack<Callable> => {+ const frames: CallableFrame<Callable>[] = [];+ const suspendedMethods = new Map<t.Node, CallableFrame<Callable>>();+ callables.length = 0;+ const push = (frame: CallableFrame<Callable>): void => {+ frames.push(frame);+ callables.push(frame.callable);+ };+ const pop = (): CallableFrame<Callable> | undefined => {+ callables.pop();+ return frames.pop();+ };+ return {+ callables,+ enter: (node, parent) => {+ if (+ parent !== null &&+ (t.isObjectMethod(parent) || t.isClassMethod(parent)) &&+ parent.computed &&+ parent.key === node &&+ frames.at(-1)?.callableId === semanticCallableIdForNode(parent)+ ) {+ const method = pop();+ if (method !== undefined) suspendedMethods.set(node, method);+ }+ const callableId = semanticCallableIdForNode(node);+ if (callableId === null) return;+ const callable = admit(callableId);+ if (callable !== undefined) push({ callableId, callable });+ },+ exit: (node) => {+ const callableId = semanticCallableIdForNode(node);+ if (callableId !== null && frames.at(-1)?.callableId === callableId)+ pop();+ const method = suspendedMethods.get(node);+ if (method !== undefined) {+ suspendedMethods.delete(node);+ push(method);+ }+ },+ };+};++/** Track admitted callable IDs, keeping each ID as its stack value. */+export const createSemanticCallableIdStack = (+ admitted: ReadonlySet<string>,+ callables: string[] = [],+): SemanticCallableStack<string> =>+ createSemanticCallableStack(+ (callableId) => (admitted.has(callableId) ? callableId : undefined),+ callables,+ );diff --git a/src/domain/javascript/javascriptSemanticCalls.ts b/src/domain/javascript/javascriptSemanticCalls.tsindex b07715af8..fc0816635 100644--- a/src/domain/javascript/javascriptSemanticCalls.ts+++ b/src/domain/javascript/javascriptSemanticCalls.ts@@ -9,10 +9,8 @@ import type {JavaScriptSemanticClosureCapture,JavaScriptSemanticFrontier,} from "./javascriptSemanticIr.js";-import {- semanticCallableIdForNode,- semanticReferenceRole,-} from "./javascriptSemanticProjection.js";+import { semanticReferenceRole } from "./javascriptSemanticProjection.js";+import { createSemanticCallableStack } from "./javascriptSemanticCallableStack.js";import { semanticStaticPropertyKey } from "./javascriptAstValues.js";import {resolveSemanticBindingState,@@ -58,7 +56,6 @@ interface CallCollectionContext {readonly JavaScriptSemanticBindingState[]>;readonly ancestors: t.Node[];- readonly callableStack: JavaScriptSemanticCallable[];}/** Recover direct-call and lexical-capture candidates from inert syntax. */@@ -78,7 +75,6 @@ export const collectJavaScriptSemanticCalls = (const callableById = new Map(callables.map((callable) => [callable.callableId, callable]),);- const callableStack: JavaScriptSemanticCallable[] = [];const context: CallCollectionContext = {state,callableById,@@ -86,15 +82,14 @@ export const collectJavaScriptSemanticCalls = (bindingResolutionCache: new Map(),parameterBindingCache: new Map(),ancestors: [],- callableStack,};+ const callableStack = createSemanticCallableStack((callableId) =>+ callableById.get(callableId),+ );traverseJavaScriptAst(program, {enter: (node, parent) => {- const callableId = semanticCallableIdForNode(node);- const callable =- callableId === null ? undefined : callableById.get(callableId);- if (callable !== undefined) callableStack.push(callable);- const owner = enclosingFunction(callableStack);+ callableStack.enter(node, parent);+ const owner = enclosingFunction(callableStack.callables);collectCapture(node, parent, owner, context);collectDynamicProperty(node, owner, state, output);collectDynamicScope(node, owner, state, output);@@ -108,12 +103,7 @@ export const collectJavaScriptSemanticCalls = (},exit: (node) => {context.ancestors.pop();- const callableId = semanticCallableIdForNode(node);- if (- callableId !== null &&- callableStack.at(-1)?.callableId === callableId- )- callableStack.pop();+ callableStack.exit(node);},});return {@@ -318,49 +308,19 @@ const collectCapture = ()return;if (semanticReferenceRole(node, parent) === null) return;- const captureOwner = computedMethodKeyOwner(node, owner, context);- if (captureOwner === undefined || captureOwner.bodyScopeId === null) return;const binding = resolveSemanticBindingState(state, node, node.name);if (binding === undefined ||- bindingIsWithinCallable(binding, captureOwner.bodyScopeId, state)+ bindingIsWithinCallable(binding, owner.bodyScopeId, state))return;output.closureCaptures.push({- callableId: captureOwner.callableId,+ callableId: owner.callableId,bindingId: binding.bindingId,referenceLocation: range(node),});};-const computedMethodKeyOwner = (- node: t.Node,- owner: JavaScriptSemanticCallable,- context: CallCollectionContext,-): JavaScriptSemanticCallable | undefined => {- const ownerNode = context.ancestors.findLast(- (candidate) => semanticCallableIdForNode(candidate) === owner.callableId,- );- if (- ownerNode === undefined ||- (!t.isObjectMethod(ownerNode) && !t.isClassMethod(ownerNode)) ||- !ownerNode.computed- )- return owner;- let child = node;- let parent = context.state.parentsByNode.get(child);- while (parent !== undefined && parent !== ownerNode) {- child = parent;- parent = context.state.parentsByNode.get(parent);- }- if (parent !== ownerNode || ownerNode.key !== child) return owner;- return enclosingFunction(- context.callableStack.filter(- ({ callableId }) => callableId !== owner.callableId,- ),- );-};-const collectDynamicProperty = (node: t.Node,owner: JavaScriptSemanticCallable | undefined,diff --git a/src/domain/javascript/javascriptSemanticChildProcesses.ts b/src/domain/javascript/javascriptSemanticChildProcesses.tsindex c9aec78e7..45d15f571 100644--- a/src/domain/javascript/javascriptSemanticChildProcesses.ts+++ b/src/domain/javascript/javascriptSemanticChildProcesses.ts@@ -5,7 +5,7 @@ import type {JavaScriptSemanticChildProcessInteraction,JavaScriptSemanticChildProcessSpawn,} from "./javascriptSemanticIr.js";-import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";import {semanticStaticPropertyName,unwrapJavaScriptExpression,@@ -84,13 +84,11 @@ const collectSpawns = (const admittedCallables = new Set(callables.map(({ callableId }) => callableId),);- const callableStack: string[] = [];+ const callableStack = createSemanticCallableIdStack(admittedCallables);const ancestors: t.Node[] = [];traverseJavaScriptAst(program, {- enter: (node) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && admittedCallables.has(callableId))- callableStack.push(callableId);+ enter: (node, parent) => {+ callableStack.enter(node, parent);if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) {const method = childProcessMethod(node.callee, state);if (method !== null) {@@ -102,7 +100,7 @@ const collectSpawns = (output.push({node,method,- ownerCallableId: callableStack.at(-1) ?? null,+ ownerCallableId: callableStack.callables.at(-1) ?? null,resultBindingId: scalarAssignedResultBinding(projectedResultBindings,),@@ -118,7 +116,7 @@ const collectSpawns = (},exit: (node) => {ancestors.pop();- popCallable(node, callableStack);+ callableStack.exit(node);},});return output;@@ -152,7 +150,7 @@ const collectInteractions = (): JavaScriptSemanticChildProcessInteraction[] => {const output: JavaScriptSemanticChildProcessInteraction[] = [];const callableIds = new Set(callables.map(({ callableId }) => callableId));- const callableStack: string[] = [];+ const callableStack = createSemanticCallableIdStack(callableIds);const spawnByNode = new WeakMap<t.Node, SpawnCandidate>();const spawnsByBinding = new Map<string, SpawnCandidate[]>();for (const spawn of spawns) {@@ -173,21 +171,19 @@ const collectInteractions = (spawnsByBinding,};traverseJavaScriptAst(program, {- enter: (node) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && callableIds.has(callableId))- callableStack.push(callableId);+ enter: (node, parent) => {+ callableStack.enter(node, parent);if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node))return;const interaction = childInteraction(node,- callableStack.at(-1) ?? null,+ callableStack.callables.at(-1) ?? null,context,);if (interaction === null) return;output.push(interaction);},- exit: (node) => popCallable(node, callableStack),+ exit: (node) => callableStack.exit(node),});return output;};@@ -359,10 +355,5 @@ const objectBinding = (? resolveSemanticBindingState(state, node, node.name): undefined;-const popCallable = (node: t.Node, stack: string[]): void => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && stack.at(-1) === callableId) stack.pop();-};-const spawnId = (candidate: SpawnCandidate): string =>`child:spawn:${String(candidate.node.start ?? -1)}:${String(candidate.node.end ?? -1)}`;diff --git a/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts b/src/domain/javascript/javascriptSemanticDataEffectHelpers.tsindex 99ae17097..9112eacd1 100644--- a/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts+++ b/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts@@ -20,6 +20,7 @@ import {import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";import { semanticTopLevelEffectFollowsCapture } from "./javascriptSemanticMutationInitializers.js";+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";import {resolveSemanticBindingState,type JavaScriptSemanticAnalysisState,@@ -882,21 +883,20 @@ export const traverseDataEffects = (context: DataEffectTraversalContext,visit: (node: t.Node, parent: t.Node | null) => void,): void => {- context.callableStack.length = 0;+ const callableStack = createSemanticCallableIdStack(+ context.callableIds,+ context.callableStack,+ );context.ancestors.length = 0;traverseJavaScriptAst(program, {enter: (node, parent) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && context.callableIds.has(callableId))- context.callableStack.push(callableId);+ callableStack.enter(node, parent);visit(node, parent);context.ancestors.push(node);},exit: (node) => {context.ancestors.pop();- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && context.callableStack.at(-1) === callableId)- context.callableStack.pop();+ callableStack.exit(node);},});};diff --git a/src/domain/javascript/javascriptSemanticObjects.ts b/src/domain/javascript/javascriptSemanticObjects.tsindex 8c0b7af8b..6e4dbb0a1 100644--- a/src/domain/javascript/javascriptSemanticObjects.ts+++ b/src/domain/javascript/javascriptSemanticObjects.ts@@ -4,7 +4,7 @@ import type {JavaScriptSemanticCallable,JavaScriptSemanticObjectOperation,} from "./javascriptSemanticIr.js";-import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";import {semanticStaticPropertyKey,semanticWriteSiteReadsFirst,@@ -27,7 +27,7 @@ export const collectJavaScriptSemanticObjects = (): JavaScriptSemanticObjectOperation[] => {const output: JavaScriptSemanticObjectOperation[] = [];const callableIds = new Set(callables.map(({ callableId }) => callableId));- const callableStack: string[] = [];+ const callableStack = createSemanticCallableIdStack(callableIds);const context: ObjectCollectionContext = {state,output,@@ -35,10 +35,8 @@ export const collectJavaScriptSemanticObjects = (};traverseJavaScriptAst(program, {enter: (node, parent) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && callableIds.has(callableId))- callableStack.push(callableId);- const ownerCallableId = callableStack.at(-1) ?? null;+ callableStack.enter(node, parent);+ const ownerCallableId = callableStack.callables.at(-1) ?? null;const writeTarget = semanticWriteSiteTarget(node);if (writeTarget !== null)for (const leaf of semanticWriteTargets(writeTarget))@@ -69,11 +67,7 @@ export const collectJavaScriptSemanticObjects = ()collectDestructuring(node, ownerCallableId, state, output);},- exit: (node) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && callableStack.at(-1) === callableId)- callableStack.pop();- },+ exit: (node) => callableStack.exit(node),});return output;};diff --git a/src/domain/javascript/javascriptSemanticPromises.ts b/src/domain/javascript/javascriptSemanticPromises.tsindex 524d3d0ff..062e59356 100644--- a/src/domain/javascript/javascriptSemanticPromises.ts+++ b/src/domain/javascript/javascriptSemanticPromises.ts@@ -5,6 +5,7 @@ import type {JavaScriptSemanticPromiseOperation,} from "./javascriptSemanticIr.js";import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";+import { createSemanticCallableIdStack } from "./javascriptSemanticCallableStack.js";import {semanticStaticPropertyName,unwrapJavaScriptExpression,@@ -106,20 +107,18 @@ const collectCandidates = (const admittedCallables = new Set(callables.map(({ callableId }) => callableId),);- const callableStack: string[] = [];+ const callableStack = createSemanticCallableIdStack(admittedCallables);const ancestors: t.Node[] = [];traverseJavaScriptAst(program, {- enter: (node) => {- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && admittedCallables.has(callableId))- callableStack.push(callableId);+ enter: (node, parent) => {+ callableStack.enter(node, parent);const details = promiseCandidateDetails(node, state);if (details !== null) {output.push({node,...details,promiseId: semanticPromiseId(details.kind, node),- ownerCallableId: callableStack.at(-1) ?? null,+ ownerCallableId: callableStack.callables.at(-1) ?? null,ancestors: [...ancestors],});}@@ -127,9 +126,7 @@ const collectCandidates = (},exit: (node) => {ancestors.pop();- const callableId = semanticCallableIdForNode(node);- if (callableId !== null && callableStack.at(-1) === callableId)- callableStack.pop();+ callableStack.exit(node);},});return output;