Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
perf(javascript): reduce retained semantic analysis allocations (#1601)
Ysopwnableb28c0337fcb3
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.scope_depth.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.scope_depth.test.tsnew file mode 100644index 000000000..175b22cc2--- /dev/null+++ b/src/domain/javascript/javascriptSemanticAnalysis.scope_depth.test.ts@@ -0,0 +1,43 @@+import { expect, it, vi } from "vitest";++import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";+import { onlyBinding } from "./javascriptSemanticAnalysis.fixture.js";++it("bounds ancestry reads for repeated deep lexical references", () => {+ const ancestryReads = (depth: number): number => {+ const original = WeakMap.prototype.get;+ let reads = 0;+ const get = vi.spyOn(WeakMap.prototype, "get").mockImplementation(function (+ this: WeakMap<object, unknown>,+ key,+ ) {+ const value: unknown = original.call(this, key);+ if (+ typeof value === "object" &&+ value !== null &&+ "type" in value &&+ typeof value.type === "string"+ )+ reads++;+ return value;+ });+ try {+ const ir = analyzeJavaScriptSemantics(+ `const a=1; module.exports.value=${"a+(".repeat(depth)}a${")".repeat(depth)};`,+ );+ expect(ir.coverage).toEqual({ status: "complete", omittedCount: 0 });+ expect(onlyBinding(ir, "a").value).toEqual({+ status: "literal",+ value: 1,+ });+ return reads;+ } finally {+ get.mockRestore();+ }+ };++ const smaller = ancestryReads(80);+ const larger = ancestryReads(160);+ expect(smaller).toBeGreaterThan(0);+ expect(larger).toBeLessThan(3 * smaller);+});diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.tsindex 2719c5589..f0b299b1c 100644--- a/src/domain/javascript/javascriptSemanticAnalysis.ts+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts@@ -444,6 +444,7 @@ function* collectDefinitionsSteps(}[] = [];yield* traverseJavaScriptAstSteps(program, {enter: (node, parent, readAncestors) => {+ if (parent !== null) state.parentsByNode.set(node, parent);let parentScope = currentSemanticScope(stack);if (parent !== null &&@@ -493,7 +494,10 @@ function* collectDefinitionsSteps(});}const scope = currentSemanticScope(stack);- state.scopeByNode.set(node, scope);+ // Other nodes inherit the nearest boundary through their AST parents.+ // Avoid a second full-tree index for the same lexical relationship.+ if (parent === null || openedScopes.has(node))+ state.scopeByNode.set(node, scope);collectSemanticCallable({node,parent,diff --git a/src/domain/javascript/javascriptSemanticCalls.ts b/src/domain/javascript/javascriptSemanticCalls.tsindex 2d5f94abd..53ada1654 100644--- a/src/domain/javascript/javascriptSemanticCalls.ts+++ b/src/domain/javascript/javascriptSemanticCalls.ts@@ -428,4 +428,10 @@ const enclosingFunction = (const semanticCallSiteId = (node: t.CallExpression | t.OptionalCallExpression | t.NewExpression,): string =>- `call:${t.isNewExpression(node) ? "construct" : "call"}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;+ // Join once so retained IDs do not keep a chain of intermediate strings.+ [+ "call",+ t.isNewExpression(node) ? "construct" : "call",+ String(node.start ?? -1),+ String(node.end ?? -1),+ ].join(":");diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.tsindex 12ceec71d..ed5d2fb09 100644--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts@@ -40,11 +40,6 @@ export function* collectSemanticMemberMutationsSteps(state: JavaScriptSemanticAnalysisState,): Generator<void, void> {const parents = state.parentsByNode;- yield* traverseJavaScriptAstSteps(program, {- enter: (node, parent) => {- if (parent !== null) parents.set(node, parent);- },- });const normalizePath = observableMutationPaths(state);const returnedReferences = createSemanticReturnedReferences(state);const recordedEffects = new Set<string>();@@ -670,10 +665,10 @@ type MutationObservableOrigin =| "opaque";interface MutationObserverNode {- readonly origins: Set<MutationObservableOrigin>;- readonly sources: Set<MutationObserverNode>;- readonly dependents: Set<MutationObserverNode>;- readonly projections: Map<string, MutationObserverNode>;+ origins?: Set<MutationObservableOrigin>;+ sources?: Set<MutationObserverNode>;+ dependents?: Set<MutationObserverNode>;+ projections?: Map<string, MutationObserverNode>;readonly read?: {readonly source: MutationObserverNode;readonly key: PropertyPath[number];@@ -700,22 +695,17 @@ const observableMutationPaths = (queued.add(node);pending.push(node);};- const create = (- read?: MutationObserverNode["read"],- ): MutationObserverNode => ({- origins: new Set(),- sources: new Set(),- dependents: new Set(),- projections: new Map(),- ...(read === undefined ? {} : { read }),- });+ const create = (read?: MutationObserverNode["read"]): MutationObserverNode =>+ // Most bindings have no object origin or property projection. Materialize+ // each collection only when it contains a fact or relationship.+ read === undefined ? {} : { read };const link = (source: MutationObserverNode,target: MutationObserverNode,): void => {- if (target.sources.has(source)) return;- target.sources.add(source);- source.dependents.add(target);+ if (target.sources?.has(source) === true) return;+ (target.sources ??= new Set()).add(source);+ (source.dependents ??= new Set()).add(target);schedule(target);};const expressionNode = (node: t.Node): MutationObserverNode => {@@ -736,11 +726,11 @@ const observableMutationPaths = (const identity = JSON.stringify(key === null || typeof key === "object" ? key : String(key),);- let selected = observer.projections.get(identity);+ let selected = observer.projections?.get(identity);if (selected === undefined) {selected = create({ source: observer, key });- observer.projections.set(identity, selected);- observer.dependents.add(selected);+ (observer.projections ??= new Map()).set(identity, selected);+ (observer.dependents ??= new Set()).add(selected);schedule(selected);}observer = selected;@@ -760,7 +750,7 @@ const observableMutationPaths = (// Preserve exact paths where copies, defaults or iteration need their// reference-specific projections; an opaque origin prevents pruning.if (binding.referenceInitializers.length > 0)- observer.origins.add("opaque");+ (observer.origins ??= new Set()).add("opaque");for (const initializer of binding.referenceInitializers) {for (const source of [initializer,@@ -777,7 +767,7 @@ const observableMutationPaths = (if (selected === undefined) break;const { expression, observer } = selected;if (t.isObjectExpression(expression) || t.isArrayExpression(expression))- observer.origins.add(expression);+ (observer.origins ??= new Set()).add(expression);else if (t.isIdentifier(expression)) {const binding = resolveSemanticBindingState(state,@@ -787,11 +777,12 @@ const observableMutationPaths = (if (binding !== undefined) {const origin = bindingNodes.get(binding.bindingId);if (origin !== undefined) link(origin, observer);- } else if (expression.name === "Array") observer.origins.add("array");+ } else if (expression.name === "Array")+ (observer.origins ??= new Set()).add("array");else if (["globalThis", "global", "window", "self"].includes(expression.name))- observer.origins.add("ambient");+ (observer.origins ??= new Set()).add("ambient");} else if (t.isMemberExpression(expression) ||t.isOptionalMemberExpression(expression)@@ -818,21 +809,21 @@ const observableMutationPaths = (queued.delete(observer);let changed = false;const add = (origin: MutationObservableOrigin): void => {- if (observer.origins.has(origin)) return;- observer.origins.add(origin);+ if (observer.origins?.has(origin) === true) return;+ (observer.origins ??= new Set()).add(origin);changed = true;};- for (const source of observer.sources)- for (const origin of source.origins) add(origin);+ for (const source of observer.sources ?? [])+ for (const origin of source.origins ?? []) add(origin);if (observer.read !== undefined) {const { source, key } = observer.read;if (key === null || typeof key === "object") {// Dynamic keys and copied-slot masks retain their original paths.// Enumerating their exclusion combinations would recreate the growth// that the mutation collector's selection union already prevents.- if (source.origins.size > 0) add("opaque");+ if ((source.origins?.size ?? 0) > 0) add("opaque");} else- for (const origin of source.origins) {+ for (const origin of source.origins ?? []) {if (typeof origin === "string") {if (origin === "array-prototype" || origin === "opaque")add(origin);@@ -869,7 +860,7 @@ const observableMutationPaths = (}}if (changed)- for (const dependent of observer.dependents) schedule(dependent);+ for (const dependent of observer.dependents ?? []) schedule(dependent);}};settle();@@ -881,15 +872,16 @@ const observableMutationPaths = (if (effect === "escape") {observer = project(observer, path);settle();- return observer.origins.size === 0 ? null : path;+ return (observer.origins?.size ?? 0) === 0 ? null : path;}- if (observer.origins.size === 0) return path.length === 0 ? path : [null];+ if ((observer.origins?.size ?? 0) === 0)+ return path.length === 0 ? path : [null];for (let offset = 0; offset < path.length; offset++) {const key = path[offset];if (key === undefined) break;observer = project(observer, [key]);settle();- if (observer.origins.size === 0 && offset + 1 < path.length)+ if ((observer.origins?.size ?? 0) === 0 && offset + 1 < path.length)return [...path.slice(0, offset + 1), null];}return path;diff --git a/src/domain/javascript/javascriptSemanticObjects.ts b/src/domain/javascript/javascriptSemanticObjects.tsindex 27f5d73b3..08acf25f8 100644--- a/src/domain/javascript/javascriptSemanticObjects.ts+++ b/src/domain/javascript/javascriptSemanticObjects.ts@@ -179,7 +179,13 @@ const addObjectOperation = (output: JavaScriptSemanticObjectOperation[],): void => {output.push({- objectOperationId: `object:${input.kind}:${String(input.node.start ?? -1)}:${String(input.node.end ?? -1)}`,+ // These high-volume IDs must not retain intermediate concatenations.+ objectOperationId: [+ "object",+ input.kind,+ String(input.node.start ?? -1),+ String(input.node.end ?? -1),+ ].join(":"),kind: input.kind,location: range(input.node),ownerCallableId: input.ownerCallableId,diff --git a/src/domain/javascript/javascriptSemanticReturns.ts b/src/domain/javascript/javascriptSemanticReturns.tsindex fb51279bf..80aeb1eb3 100644--- a/src/domain/javascript/javascriptSemanticReturns.ts+++ b/src/domain/javascript/javascriptSemanticReturns.ts@@ -83,7 +83,14 @@ const semanticReturnSiteId = (callableId: string,location: JavaScriptSemanticReturnSite["location"],): string =>- `${callableId}:return:${String(location.start.line)}:${String(location.start.column)}:${String(location.end.line)}:${String(location.end.column)}`;+ [+ callableId,+ "return",+ String(location.start.line),+ String(location.start.column),+ String(location.end.line),+ String(location.end.column),+ ].join(":");/** Link exports to callables only when lexical resolution is unique and exact. */export const resolveSemanticModuleCallables = (diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.tsindex 28ca97371..f7ef25319 100644--- a/src/domain/javascript/javascriptSemanticState.ts+++ b/src/domain/javascript/javascriptSemanticState.ts@@ -60,6 +60,7 @@ export interface JavaScriptSemanticAnalysisState {readonly parentsByNode: WeakMap<t.Node, t.Node>;readonly scopes: JavaScriptSemanticScopeState[];readonly scopesById: Map<string, JavaScriptSemanticScopeState>;+ /** Scope boundaries and descendant scopes resolved on demand. */readonly scopeByNode: WeakMap<t.Node, JavaScriptSemanticScopeState>;readonly bindingsById: Map<string, JavaScriptSemanticBindingState>;readonly callables: JavaScriptSemanticCallable[];@@ -94,7 +95,7 @@ export const resolveSemanticBindingState = (node: t.Node,name: string,): JavaScriptSemanticBindingState | undefined => {- let scope = state.scopeByNode.get(node);+ let scope = semanticScopeForNode(state, node);while (scope !== undefined) {const binding = scope.bindings.get(name);if (binding !== undefined) return binding;@@ -113,7 +114,7 @@ export const semanticResolutionBlocked = (node: t.Node,name: string,): boolean => {- let scope = state.scopeByNode.get(node);+ let scope = semanticScopeForNode(state, node);while (scope !== undefined) {if (scope.bindings.has(name)) return false;if (!scope.bindingsComplete) return true;@@ -125,6 +126,28 @@ export const semanticResolutionBlocked = (return false;};+const semanticScopeForNode = (+ state: JavaScriptSemanticAnalysisState,+ node: t.Node,+): JavaScriptSemanticScopeState | undefined => {+ let candidate: t.Node | undefined = node;+ while (candidate !== undefined) {+ const scope = state.scopeByNode.get(candidate);+ if (scope !== undefined) {+ // Repeated references in a deep expression share this ancestry. Cache+ // the traversed path without eagerly indexing nodes never resolved.+ let descendant: t.Node | undefined = node;+ while (descendant !== undefined && descendant !== candidate) {+ state.scopeByNode.set(descendant, scope);+ descendant = state.parentsByNode.get(descendant);+ }+ return scope;+ }+ candidate = state.parentsByNode.get(candidate);+ }+ return undefined;+};+/** Resolve one name starting from an explicitly selected lexical scope. */export const resolveSemanticBindingFromScope = (scope: JavaScriptSemanticScopeState,