Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(javascript): preserve unknown branches in primitive unions
Kaoru08229a2f3950286a
diff --git a/src/application/JavaScriptReturnShapeProjection.test.ts b/src/application/JavaScriptReturnShapeProjection.test.tsnew file mode 100644index 000000000..91a168025--- /dev/null+++ b/src/application/JavaScriptReturnShapeProjection.test.ts@@ -0,0 +1,166 @@+import { describe, expect, it } from "vitest";++import { analyzeJavaScriptSemantics } from "../domain/javascriptSemanticAnalysis.js";+import { completeApplicationCoverage } from "../domain/javascriptApplicationEvidenceSchemas.js";+import { projectJavaScriptExportReturnShapes } from "./JavaScriptReturnShapeProjection.js";++const projectReturns = (body: string) => {+ const ir = analyzeJavaScriptSemantics(`export function result() { ${body} }`);+ const link = ir.moduleLinks.find(+ ({ exportedName }) => exportedName === "result",+ );+ if (link === undefined) throw new Error("Expected the result export");+ const projected = projectJavaScriptExportReturnShapes({+ ir,+ link,+ modulePath: "fixture.js",+ baseCoverage: completeApplicationCoverage(),+ });+ if (projected === null) throw new Error("Expected exported return shapes");+ return projected;+};++const unknownBranchField = {+ path: "",+ state: "unknown",+ value: null,+ reason: "Branches have incompatible values.",+};++describe("exported primitive union return shapes", () => {+ const conditionalCases = [+ "missing",+ "unsupported()",+ '({ key: "value" })',+ '["value"]',+ '+"invalid"',+ ].flatMap((other) => [+ `condition ? (choice ? "one" : "two") : ${other}`,+ `condition ? ${other} : (choice ? "one" : "two")`,+ ]);+ const logicalCases = [+ { operator: "||", known: '(choice ? "" : "one")' },+ { operator: "&&", known: '(choice ? 0 : "one")' },+ { operator: "??", known: '(choice ? null : "one")' },+ ].flatMap(({ operator, known }) => [+ `${known} ${operator} missing`,+ `missing ${operator} ${known}`,+ ]);++ it.each([...conditionalCases, ...logicalCases])(+ "projects an unknown field instead of a definite union for %s",+ (expression) => {+ const projected = projectReturns(`return ${expression};`);++ expect(projected.properties.static_return_shapes).toEqual([+ {+ source_range: expect.any(Object),+ value_status: "ambiguous",+ fields: [unknownBranchField],+ property_coverage: [],+ },+ ]);+ // Complete return-site collection does not make its values known.+ expect(projected.properties.return_shape_coverage).toEqual({+ status: "complete",+ retained_return_sites: 1,+ omitted_return_sites: 0,+ omitted_fields: 0,+ omitted_property_coverage: 0,+ projection_complete: true,+ });+ expect(projected.coverage).toEqual(completeApplicationCoverage());+ expect(projected.limitations).toContain(+ "Return shapes are inferred from inert syntax and do not prove runtime behavior.",+ );+ },+ );++ it("keeps an incompatible object field unknown beside a known literal", () => {+ const projected = projectReturns(`+ return {+ kind: "result",+ value: condition ? (choice ? "one" : "two") : missing,+ };+ `);+ expect(projected.properties.static_return_shapes).toEqual([+ {+ source_range: expect.any(Object),+ value_status: "object",+ fields: [+ { path: "/kind", state: "literal", value: "result", reason: null },+ { ...unknownBranchField, path: "/value" },+ ],+ property_coverage: [{ path: "", status: "complete", omitted: 0 }],+ },+ ]);+ });++ it("retains valid nested unions, duplicates, and null alternatives", () => {+ const projected = projectReturns(`+ return condition+ ? (choice ? "two" : "one")+ : (other ? "one" : null);+ `);+ expect(projected.properties.static_return_shapes).toEqual([+ {+ source_range: expect.any(Object),+ value_status: "union",+ fields: [+ {+ path: "",+ state: "union",+ value: [null, "one", "two"],+ reason: null,+ },+ ],+ property_coverage: [],+ },+ ]);+ });++ it("preserves three independent direct returns without merging their values", () => {+ const projected = projectReturns(`+ if (condition) return choice ? "one" : "two";+ if (other) return missing;+ return { kind: "object" };+ `);+ expect(projected.properties.static_return_shapes).toEqual([+ {+ source_range: expect.any(Object),+ value_status: "union",+ fields: [+ { path: "", state: "union", value: ["one", "two"], reason: null },+ ],+ property_coverage: [],+ },+ {+ source_range: expect.any(Object),+ value_status: "unknown",+ fields: [+ {+ path: "",+ state: "unknown",+ value: null,+ reason: "Unbound identifier missing.",+ },+ ],+ property_coverage: [],+ },+ {+ source_range: expect.any(Object),+ value_status: "object",+ fields: [+ { path: "/kind", state: "literal", value: "object", reason: null },+ ],+ property_coverage: [{ path: "", status: "complete", omitted: 0 }],+ },+ ]);+ expect(projected.properties.return_shape_coverage).toMatchObject({+ status: "complete",+ retained_return_sites: 3,+ omitted_return_sites: 0,+ projection_complete: true,+ });+ });+});diff --git a/src/domain/javascriptSemanticAnalysis.unions.test.ts b/src/domain/javascriptSemanticAnalysis.unions.test.tsnew file mode 100644index 000000000..25e02aefa--- /dev/null+++ b/src/domain/javascriptSemanticAnalysis.unions.test.ts@@ -0,0 +1,156 @@+import { describe, expect, it } from "vitest";++import { analyzeJavaScriptSemantics } from "./javascriptSemanticAnalysis.js";+import { topLevelBinding } from "./javascriptSemanticAnalysis.fixture.js";++const conditionalCandidates = [+ '"one"',+ '(choice ? "one" : "two")',+ '(choice ? "one" : other ? "two" : "three")',+];+const incompatibleValue = {+ status: "ambiguous",+ reason: "Branches have incompatible values.",+};++const valueOf = (expression: string) =>+ topLevelBinding(+ analyzeJavaScriptSemantics(`const answer = ${expression};`),+ "answer",+ ).value;++describe("conditional primitive unions", () => {+ const cases = conditionalCandidates.flatMap((known) =>+ [+ "missing",+ "unsupported()",+ '({ key: "value" })',+ '["value"]',+ '+"invalid"',+ "1e309",+ "1e308 + 1e308",+ ].flatMap((other) => [+ `condition ? ${known} : ${other}`,+ `condition ? ${other} : ${known}`,+ ]),+ );++ it.each(cases)("preserves incompatible alternatives in %s", (expression) => {+ expect(valueOf(expression)).toEqual(incompatibleValue);+ });++ it.each([+ [+ 'condition ? (choice ? "two" : "one") : "three"',+ { status: "union", values: ["one", "three", "two"] },+ ],+ [+ 'condition ? "three" : (choice ? "two" : "one")',+ { status: "union", values: ["one", "three", "two"] },+ ],+ [+ 'condition ? (choice ? "two" : "one") : (other ? "one" : "three")',+ { status: "union", values: ["one", "three", "two"] },+ ],+ [+ 'condition ? (choice ? "two" : "one") : (other ? "one" : "two")',+ { status: "union", values: ["one", "two"] },+ ],+ [+ 'condition ? (choice ? "one" : "one") : "one"',+ { status: "literal", value: "one" },+ ],+ [+ 'condition ? (choice ? "one" : "two") : null',+ { status: "union", values: [null, "one", "two"] },+ ],+ [+ 'condition ? null : (choice ? "one" : "two")',+ { status: "union", values: [null, "one", "two"] },+ ],+ ["condition ? null : null", { status: "literal", value: null }],+ ])("retains exact primitive candidates in %s", (expression, expected) => {+ expect(valueOf(expression)).toEqual(expected);+ });++ it("propagates an incompatible nested branch through an outer union", () => {+ expect(+ valueOf(+ 'condition ? (choice ? "one" : "two") : (other ? "three" : missing)',+ ),+ ).toEqual(incompatibleValue);+ });+});++describe("logical primitive unions", () => {+ // Each left-hand set can select the unresolved right-hand operand at runtime.+ const operators = [+ {+ operator: "||",+ alternatives: [+ '""',+ '(choice ? "" : "one")',+ '(choice ? "" : other ? "one" : "two")',+ ],+ },+ {+ operator: "&&",+ alternatives: [+ '"one"',+ '(choice ? 0 : "one")',+ '(choice ? 0 : other ? "one" : "two")',+ ],+ },+ {+ operator: "??",+ alternatives: [+ "null",+ '(choice ? null : "one")',+ '(choice ? null : other ? "one" : "two")',+ ],+ },+ ];+ const cases = operators.flatMap(({ operator, alternatives }) =>+ alternatives.flatMap((known) =>+ ["missing", "unsupported()"].flatMap((other) => [+ `${known} ${operator} ${other}`,+ `${other} ${operator} ${known}`,+ ]),+ ),+ );++ it.each(cases)("preserves unresolved alternatives in %s", (expression) => {+ expect(valueOf(expression)).toEqual(incompatibleValue);+ });++ it.each([+ [+ '(choice ? "" : "one") || "two"',+ { status: "union", values: ["", "one", "two"] },+ ],+ [+ '(choice ? 0 : "one") && "two"',+ { status: "union", values: [0, "one", "two"] },+ ],+ [+ '(choice ? null : "one") ?? "two"',+ { status: "union", values: [null, "one", "two"] },+ ],+ ['"one" || "one"', { status: "literal", value: "one" }],+ ["null ?? null", { status: "literal", value: null }],+ ])(+ "retains the conservative primitive union in %s",+ (expression, expected) => {+ expect(valueOf(expression)).toEqual(expected);+ },+ );++ it.each([+ 'true ? "one" : missing',+ '"one" || missing',+ "false && missing",+ '"one" ?? missing',+ ])("does not introduce short-circuit evaluation for %s", (expression) => {+ expect(valueOf(expression)).toEqual(incompatibleValue);+ });+});diff --git a/src/domain/javascriptSemanticValues.ts b/src/domain/javascriptSemanticValues.tsindex 9e7247016..8b56d6ceb 100644--- a/src/domain/javascriptSemanticValues.ts+++ b/src/domain/javascriptSemanticValues.ts@@ -481,10 +481,9 @@ const mergeValues = (const primitives = values.flatMap((value) => primitiveCandidates(value) ?? [],);- return primitives.length === values.length ||- values.every(- (value) => value.status === "union" || value.status === "literal",- )+ return values.every(+ (value) => value.status === "union" || value.status === "literal",+ )? primitiveSet(primitives): { status: "ambiguous", reason: "Branches have incompatible values." };};