Skip to content

armgit / rea

Public Imported from GitHub
0

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

refactor(javascript): normalize erased expression syntax once

morlutob628bba1fa65
diff --git a/src/application/javascript/JavaScriptApplicationDeclarations.test.ts b/src/application/javascript/JavaScriptApplicationDeclarations.test.ts
deleted file mode 100644
index 30a80bb62..000000000
--- a/src/application/javascript/JavaScriptApplicationDeclarations.test.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { expect, it } from "vitest";
-
-import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js";
-import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js";
-import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
-import { analyzeJavaScriptApplication } from "./JavaScriptApplicationService.js";
-
-it.each(["types.d.ts", "types.d.mts", "types.d.cts"])(
- "keeps valid ambient declarations complete in %s",
- async (path) => {
- const root = await createTestTempDirectory("rea-declaration-file-");
- const source = "export const value: number;\n";
- await writeFile(join(root, path), source);
- const result = await analyzeJavaScriptApplication({
- input_path: root,
- format: "directory",
- });
- if (!result.ok) throw result.error;
- const analysis = javascriptApplicationAnalysisResultSchema.parse(
- result.value.normalized_result,
- );
- expect(analysis.graph.coverage.status).toBe("complete");
- expect(parseJavaScriptSource(source, path)?.errors).toEqual([]);
- },
-);
-
-it("retains the missing-initializer diagnostic for ordinary TypeScript", () => {
- const errors = parseJavaScriptSource(
- "export const value: number;",
- "types.ts",
- )?.errors;
- expect(errors?.map(({ message }) => message)).toContain(
- "Missing initializer in const declaration. (1:26)",
- );
-});
-
-it("keeps CommonJS TypeScript angle-bracket assertions complete", async () => {
- const root = await createTestTempDirectory("rea-cts-assertion-");
- const source = "export const value = <number>42;\n";
- await writeFile(join(root, "app.cts"), source);
- const result = await analyzeJavaScriptApplication({
- input_path: root,
- format: "directory",
- });
- if (!result.ok) throw result.error;
- const analysis = javascriptApplicationAnalysisResultSchema.parse(
- result.value.normalized_result,
- );
- expect(analysis.graph.coverage.status).toBe("complete");
- expect(parseJavaScriptSource(source, "app.cts")?.errors).toEqual([]);
-});
diff --git a/src/application/javascript/JavaScriptApplicationSatisfies.test.ts b/src/application/javascript/JavaScriptApplicationSatisfies.test.ts
deleted file mode 100644
index 8507180f1..000000000
--- a/src/application/javascript/JavaScriptApplicationSatisfies.test.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-import { expect, it } from "vitest";
-
-import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js";
-import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js";
-import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
-import { topLevelBinding } from "../../domain/javascript/javascriptSemanticAnalysis.fixture.js";
-import { analyzeJavaScriptApplication } from "./JavaScriptApplicationService.js";
-
-it.each([
- '"ready" satisfies string',
- '("ready" satisfies string) as string',
- '("ready" satisfies string)!',
-])("retains the runtime primitive through %s", (expression) => {
- const ir = analyzeJavaScriptSemantics(`const value = ${expression};`);
- expect(topLevelBinding(ir, "value").value).toEqual({
- status: "literal",
- value: "ready",
- });
-});
-
-it("retains exported constant evidence through a type-only satisfies expression", async () => {
- const root = await createTestTempDirectory("rea-ts-satisfies-");
- await writeFile(
- join(root, "app.ts"),
- 'export const value = "ready" satisfies string;\n',
- );
- const result = await analyzeJavaScriptApplication({
- input_path: root,
- format: "directory",
- });
- if (!result.ok) throw result.error;
- const analysis = javascriptApplicationAnalysisResultSchema.parse(
- result.value.normalized_result,
- );
- expect(
- analysis.semantic_graph.nodes.filter(
- ({ kind, properties }) =>
- kind === "literal" && properties.value === "ready",
- ),
- ).toHaveLength(1);
-});
-
-it("retains local call targets and exported callable links through satisfies", () => {
- const ir = analyzeJavaScriptSemantics(
- 'export const render = (() => "ready") satisfies (() => string); render();',
- );
- const callable = ir.callables[0];
- if (callable === undefined) throw new Error("Missing callable");
- expect(
- ir.moduleLinks.find(({ localName }) => localName === "render")?.callableId,
- ).toBe(callable.callableId);
- expect(ir.callSites[0]?.calleeCallableIds).toEqual([callable.callableId]);
- expect(ir.callSites[0]?.resolution).toBe("exact");
-});
diff --git a/src/application/javascript/JavaScriptApplicationTypeScript.test.ts b/src/application/javascript/JavaScriptApplicationTypeScript.test.ts
new file mode 100644
index 000000000..6d59578e7
--- /dev/null
+++ b/src/application/javascript/JavaScriptApplicationTypeScript.test.ts
@@ -0,0 +1,144 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect, it } from "vitest";
+
+import { canonicalJson } from "../../domain/comparisonSemantics.js";
+import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js";
+import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
+import { analyzeJavaScriptApplication } from "./JavaScriptApplicationService.js";
+
+type ApplicationAnalysis = ReturnType<
+ typeof javascriptApplicationAnalysisResultSchema.parse
+>;
+
+const analyzeFiles = async (
+ files: ReadonlyMap<string, string>,
+): Promise<ApplicationAnalysis> => {
+ const root = await createTestTempDirectory("rea-typescript-application-");
+ await Promise.all(
+ [...files].map(([path, source]) => writeFile(join(root, path), source)),
+ );
+ const result = await analyzeJavaScriptApplication({
+ input_path: root,
+ format: "directory",
+ });
+ if (!result.ok) throw result.error;
+ const analysis = javascriptApplicationAnalysisResultSchema.parse(
+ result.value.normalized_result,
+ );
+ return javascriptApplicationAnalysisResultSchema.parse(
+ JSON.parse(canonicalJson(analysis, "TypeScript application analysis")),
+ );
+};
+
+it.each(["types.d.ts", "types.d.mts", "types.d.cts"])(
+ "keeps valid ambient declarations complete in %s",
+ async (path) => {
+ const source = "export const value: number;\n";
+ const analysis = await analyzeFiles(new Map([[path, source]]));
+
+ expect(analysis.graph.coverage.status).toBe("complete");
+ expect(parseJavaScriptSource(source, path)?.errors).toEqual([]);
+ },
+);
+
+it("retains the missing-initializer diagnostic for ordinary TypeScript", () => {
+ const errors = parseJavaScriptSource(
+ "export const value: number;",
+ "types.ts",
+ )?.errors;
+ expect(errors?.map(({ message }) => message)).toContain(
+ "Missing initializer in const declaration. (1:26)",
+ );
+});
+
+it("keeps CommonJS TypeScript angle-bracket assertions complete", async () => {
+ const source = "export const value = <number>42;\n";
+ const analysis = await analyzeFiles(new Map([["app.cts", source]]));
+
+ expect(analysis.graph.coverage.status).toBe("complete");
+ expect(parseJavaScriptSource(source, "app.cts")?.errors).toEqual([]);
+});
+
+it("retains exported constant evidence through a type-only satisfies expression", async () => {
+ const analysis = await analyzeFiles(
+ new Map([["app.ts", 'export const value = "ready" satisfies string;\n']]),
+ );
+
+ expect(
+ analysis.semantic_graph.nodes.filter(
+ ({ kind, properties }) =>
+ kind === "literal" && properties.value === "ready",
+ ),
+ ).toHaveLength(1);
+});
+
+it("resolves erased wrappers through the composed application graph", async () => {
+ const source = `
+ const dependency = require("./dependency.ts")["value" as const] satisfies number;
+ export { dependency };
+ function render<T>() { return "ready"; }
+ export const specialized = render<string> satisfies () => string;
+ specialized();
+ `;
+ const analysis = await analyzeFiles(
+ new Map([
+ ["app.mts", source],
+ ["dependency.ts", "export const value = 1;\n"],
+ ]),
+ );
+
+ expect(analysis.graph.edges).toContainEqual(
+ expect.objectContaining({
+ relation: "imports",
+ properties: expect.objectContaining({
+ specifier: "./dependency.ts",
+ imported_path: ["value"],
+ resolved_path: "dependency.ts",
+ resolution_status: "resolved",
+ }),
+ }),
+ );
+ expect(analysis.semantic_graph.relations).toContainEqual(
+ expect.objectContaining({ relation: "calls", resolution: "resolved" }),
+ );
+ expect(
+ analysis.graph.nodes.flatMap(({ observations }) => observations),
+ ).toContainEqual(
+ expect.objectContaining({
+ properties: expect.objectContaining({
+ semantic_role: "export-return-shapes",
+ exported_name: "specialized",
+ static_return_shapes: expect.arrayContaining([
+ expect.objectContaining({
+ value_status: "literal",
+ fields: expect.arrayContaining([
+ expect.objectContaining({ path: "", value: "ready" }),
+ ]),
+ }),
+ ]),
+ }),
+ }),
+ );
+ expect(parseJavaScriptSource(source, "app.mts")?.errors).toEqual([]);
+});
+
+it("applies TypeScript .mts ambiguity rules while retaining unambiguous generics", () => {
+ expect(
+ parseJavaScriptSource(
+ "export const identity = <T,>(value: T) => value;",
+ "app.mts",
+ )?.errors,
+ ).toEqual([]);
+ expect(
+ parseJavaScriptSource(
+ "export const identity = <T>(value: T) => value;",
+ "app.mts",
+ )?.errors.map(({ reasonCode }) => reasonCode),
+ ).toContain("ReservedArrowTypeParam");
+ expect(parseJavaScriptSource("const value = <Widget />;", "app.mts")).toBe(
+ null,
+ );
+});
diff --git a/src/domain/javascript/javascriptAstValues.ts b/src/domain/javascript/javascriptAstValues.ts
index b7f8d0efc..f0a0528c0 100644
--- a/src/domain/javascript/javascriptAstValues.ts
+++ b/src/domain/javascript/javascriptAstValues.ts
@@ -1,12 +1,38 @@
import * as t from "@babel/types";
import type { JavaScriptSemanticPrimitive } from "./javascriptSemanticValueTypes.js";
+/**
+ * Remove wrappers that affect TypeScript or Flow checking but not runtime
+ * expression identity. The returned depth lets bounded evaluators account for
+ * syntax that normalization would otherwise skip.
+ */
+export const unwrapJavaScriptExpression = (
+ node: t.Node,
+): { readonly node: t.Node; readonly depth: number } => {
+ let current = node;
+ let depth = 0;
+ while (
+ t.isParenthesizedExpression(current) ||
+ t.isTSAsExpression(current) ||
+ t.isTSTypeAssertion(current) ||
+ t.isTSNonNullExpression(current) ||
+ t.isTSSatisfiesExpression(current) ||
+ t.isTSInstantiationExpression(current) ||
+ t.isTypeCastExpression(current)
+ ) {
+ current = current.expression;
+ depth += 1;
+ }
+ return { node: current, depth };
+};
+
/** Read one syntax-level primitive only when its value is exact. */
export const readExactJavaScriptLiteral = (
node: t.Node,
):
| { readonly found: true; readonly value: JavaScriptSemanticPrimitive }
| { readonly found: false } => {
+ node = unwrapJavaScriptExpression(node).node;
if (t.isStringLiteral(node)) return { found: true, value: node.value };
if (t.isNumericLiteral(node) && Number.isFinite(node.value))
return { found: true, value: node.value };
@@ -44,6 +70,7 @@ export const semanticStaticPropertyKey = (
property: t.Node,
computed: boolean,
): string | null => {
+ property = unwrapJavaScriptExpression(property).node;
if (t.isStringLiteral(property) || t.isNumericLiteral(property))
return String(property.value);
return !computed && t.isIdentifier(property) ? property.name : null;
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts b/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
index 24bbb1707..9e02cdb00 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.unions.test.ts
@@ -390,6 +390,26 @@ describe("semantic expression depth bounds", () => {
});
});
+ it("counts erased TypeScript wrappers against expression depth", () => {
+ const parsed = parseJavaScriptSource("const answer = true;");
+ const declaration = parsed?.program.body[0];
+ const declarator = t.isVariableDeclaration(declaration)
+ ? declaration.declarations[0]
+ : undefined;
+ if (parsed === null || !t.isVariableDeclarator(declarator))
+ throw new Error("Expected parsed binding initializer");
+ let expression: t.Expression = t.booleanLiteral(true);
+ for (let index = 0; index < 300; index += 1)
+ expression = t.tsAsExpression(expression, t.tsStringKeyword());
+ declarator.init = expression;
+
+ const ir = analyzeParsedJavaScriptSemantics(parsed);
+ expect(topLevelBinding(ir, "answer").value).toMatchObject({
+ status: "unknown",
+ resourceLimit: "expression-depth",
+ });
+ });
+
it("preserves exact shallow addition alternatives", () => {
expect(valueOf('(choice ? "a" : "b") + (other ? "1" : "2")')).toEqual({
status: "union",
diff --git a/src/domain/javascript/javascriptSemanticCallResolution.ts b/src/domain/javascript/javascriptSemanticCallResolution.ts
index 24673279a..08453a651 100644
--- a/src/domain/javascript/javascriptSemanticCallResolution.ts
+++ b/src/domain/javascript/javascriptSemanticCallResolution.ts
@@ -6,6 +6,7 @@ import type {
} from "./javascriptSemanticIr.js";
import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { unwrapJavaScriptExpression } from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
type JavaScriptSemanticAnalysisState,
@@ -51,6 +52,8 @@ const resolveCallables = (
node: t.Node,
context: CallResolutionContext,
): LocalCallableResolution => {
+ const unwrapped = unwrapJavaScriptExpression(node).node;
+ if (unwrapped !== node) return resolveCallables(unwrapped, context);
const direct = semanticCallableIdForNode(node);
if (direct !== null && context.callableById.has(direct))
return {
@@ -59,13 +62,6 @@ const resolveCallables = (
reason: "Direct local callable.",
};
if (t.isIdentifier(node)) return resolveIdentifier(node, context);
- if (
- t.isTSAsExpression(node) ||
- t.isTSTypeAssertion(node) ||
- t.isTSNonNullExpression(node) ||
- t.isTSSatisfiesExpression(node)
- )
- return resolveCallables(node.expression, context);
if (t.isConditionalExpression(node) || t.isLogicalExpression(node))
return resolveAlternatives(
t.isConditionalExpression(node) ? node.consequent : node.left,
diff --git a/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts b/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts
index f98b791dc..5485fcde9 100644
--- a/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts
+++ b/src/domain/javascript/javascriptSemanticDataEffectHelpers.ts
@@ -14,6 +14,7 @@ import {
readExactJavaScriptLiteral,
semanticStaticPropertyKey,
semanticStaticPropertyName,
+ unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
export interface SemanticProjectedBinding {
@@ -56,15 +57,11 @@ const assignedSourceIs = (node: t.Node, source: t.Node): boolean => {
let value = source;
while (true) {
if (t.isAwaitExpression(value)) value = value.argument;
- else if (
- t.isParenthesizedExpression(value) ||
- t.isTSAsExpression(value) ||
- t.isTSTypeAssertion(value) ||
- t.isTypeCastExpression(value) ||
- t.isTSSatisfiesExpression(value)
- )
- value = value.expression;
- else break;
+ else {
+ const unwrapped = unwrapJavaScriptExpression(value).node;
+ if (unwrapped === value) break;
+ value = unwrapped;
+ }
}
return value === node;
};
diff --git a/src/domain/javascript/javascriptSemanticDataEffects.ts b/src/domain/javascript/javascriptSemanticDataEffects.ts
index 83afd13d7..445cd2e5e 100644
--- a/src/domain/javascript/javascriptSemanticDataEffects.ts
+++ b/src/domain/javascript/javascriptSemanticDataEffects.ts
@@ -12,6 +12,7 @@ import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import {
semanticStaticPropertyKey,
semanticStaticPropertyName,
+ unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
@@ -178,16 +179,7 @@ const collectDefaults = (
(node.operator !== "??" && node.operator !== "||")
)
return;
- let source = node.left;
- while (
- t.isParenthesizedExpression(source) ||
- t.isTSAsExpression(source) ||
- t.isTSTypeAssertion(source) ||
- t.isTypeCastExpression(source) ||
- t.isTSSatisfiesExpression(source) ||
- t.isTSNonNullExpression(source)
- )
- source = source.expression;
+ const source = unwrapJavaScriptExpression(node.left).node;
const candidate = configurationsByNode.get(source);
if (candidate === undefined) return;
output.push({
diff --git a/src/domain/javascript/javascriptSemanticMemberMutations.ts b/src/domain/javascript/javascriptSemanticMemberMutations.ts
index 622d9f630..0d3a00f22 100644
--- a/src/domain/javascript/javascriptSemanticMemberMutations.ts
+++ b/src/domain/javascript/javascriptSemanticMemberMutations.ts
@@ -7,7 +7,10 @@ import {
} from "./javascriptSemanticState.js";
import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";
import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import {
+ semanticStaticPropertyKey,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
type PropertyPath = readonly (string | number | null)[];
@@ -28,6 +31,11 @@ export const collectSemanticMemberMutations = (
bindings: ReadonlySet<string>,
mutation: t.Node,
): void => {
+ const unwrapped = unwrapJavaScriptExpression(node).node;
+ if (unwrapped !== node) {
+ markValue(unwrapped, path, bindings, mutation);
+ return;
+ }
if (t.isIdentifier(node)) {
const binding = resolveSemanticBindingState(state, node, node.name);
if (binding === undefined || bindings.has(binding.bindingId)) return;
@@ -224,13 +232,6 @@ const referencedValues = (
: [];
});
}
- if (
- t.isTSAsExpression(node) ||
- t.isTSTypeAssertion(node) ||
- t.isTSSatisfiesExpression(node) ||
- t.isTSNonNullExpression(node)
- )
- return [{ node: node.expression, path }];
if (t.isConditionalExpression(node))
return [
{ node: node.consequent, path },
diff --git a/src/domain/javascript/javascriptSemanticObjects.ts b/src/domain/javascript/javascriptSemanticObjects.ts
index a7872efb0..27f5d73b3 100644
--- a/src/domain/javascript/javascriptSemanticObjects.ts
+++ b/src/domain/javascript/javascriptSemanticObjects.ts
@@ -8,7 +8,10 @@ import {
semanticCallableIdForNode,
semanticReadsBeforeWrite,
} from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import {
+ semanticStaticPropertyKey,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
type JavaScriptSemanticAnalysisState,
@@ -205,6 +208,7 @@ const expressionObjectIdentity = (
let current = node;
let staticPath = true;
while (current !== null && current !== undefined) {
+ current = unwrapJavaScriptExpression(current).node;
if (
t.isMemberExpression(current) ||
t.isOptionalMemberExpression(current)
@@ -216,14 +220,7 @@ const expressionObjectIdentity = (
if (name === null) staticPath = false;
else path.push(name);
current = current.object;
- } else if (
- t.isTSAsExpression(current) ||
- t.isTSTypeAssertion(current) ||
- t.isTSNonNullExpression(current) ||
- t.isTSSatisfiesExpression(current)
- )
- current = current.expression;
- else break;
+ } else break;
}
return {
bindingId: t.isIdentifier(current)
diff --git a/src/domain/javascript/javascriptSemanticPromises.ts b/src/domain/javascript/javascriptSemanticPromises.ts
index d956d68f7..524d3d0ff 100644
--- a/src/domain/javascript/javascriptSemanticPromises.ts
+++ b/src/domain/javascript/javascriptSemanticPromises.ts
@@ -5,7 +5,10 @@ import type {
JavaScriptSemanticPromiseOperation,
} from "./javascriptSemanticIr.js";
import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
-import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import {
+ semanticStaticPropertyName,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
semanticResolutionBlocked,
@@ -173,7 +176,9 @@ const isUnshadowedGlobalPromise = (
const isPromiseProducer = (
node: t.Node,
state: JavaScriptSemanticAnalysisState,
-): boolean => promiseCandidateDetails(unwrapExpression(node), state) !== null;
+): boolean =>
+ promiseCandidateDetails(unwrapJavaScriptExpression(node).node, state) !==
+ null;
const semanticPromiseId = (kind: PromiseKind, node: t.Node): string =>
`promise:${kind}:${String(node.start ?? -1)}:${String(node.end ?? -1)}`;
@@ -207,7 +212,7 @@ const ownershipAtAncestor = (
): PromiseOwnership | "boundary" | null => {
const { candidate, candidateByNode, state, returnSiteIdFor } = context;
if (t.isAwaitExpression(ancestor))
- return unwrapExpression(ancestor.argument) === candidate.node
+ return unwrapJavaScriptExpression(ancestor.argument).node === candidate.node
? emptyOwnership("awaited")
: "boundary";
const outer = candidateByNode.get(ancestor);
@@ -230,7 +235,7 @@ const ownershipAtAncestor = (
if (t.isReturnStatement(ancestor)) {
if (
ancestor.argument == null ||
- unwrapExpression(ancestor.argument) !== candidate.node
+ unwrapJavaScriptExpression(ancestor.argument).node !== candidate.node
)
return "boundary";
return returnedPromiseOwnership(
@@ -240,14 +245,15 @@ const ownershipAtAncestor = (
);
}
if (t.isExpressionStatement(ancestor))
- return unwrapExpression(ancestor.expression) === candidate.node
+ return unwrapJavaScriptExpression(ancestor.expression).node ===
+ candidate.node
? emptyOwnership("detached")
: "boundary";
const callableId = semanticCallableIdForNode(ancestor);
if (callableId === null || callableId !== candidate.ownerCallableId)
return null;
return t.isArrowFunctionExpression(ancestor) &&
- unwrapExpression(ancestor.body) === candidate.node
+ unwrapJavaScriptExpression(ancestor.body).node === candidate.node
? returnedPromiseOwnership(
candidate.ownerCallableId,
range(ancestor.body),
@@ -276,7 +282,7 @@ const assignedPromiseBinding = (
? ancestor.init
: ancestor.right;
if (source == null) return undefined;
- if (unwrapExpression(source) !== candidate) return undefined;
+ if (unwrapJavaScriptExpression(source).node !== candidate) return undefined;
return scalarAssignedResultBinding(
assignedSemanticResultBindings(source, [ancestor], state),
);
@@ -302,7 +308,8 @@ const outerConsumesCandidate = (
) {
const member = dataEffectMemberCallee(outer.node);
return (
- member !== null && unwrapExpression(member.object) === candidate.node
+ member !== null &&
+ unwrapJavaScriptExpression(member.object).node === candidate.node
);
}
if (
@@ -316,7 +323,7 @@ const outerConsumesCandidate = (
(element) =>
element !== null &&
!t.isSpreadElement(element) &&
- unwrapExpression(element) === candidate.node,
+ unwrapJavaScriptExpression(element).node === candidate.node,
)
);
}
@@ -441,7 +448,7 @@ const resolvePromiseExpression = (
context: PromiseExpressionResolutionContext,
): PromiseResolution => {
const { current, candidateByNode, state, seenBindings } = context;
- const node = unwrapExpression(rawNode);
+ const node = unwrapJavaScriptExpression(rawNode).node;
const direct = candidateByNode.get(node);
if (direct !== undefined && direct.promiseId !== current.promiseId)
return { promiseIds: [direct.promiseId], status: "complete" };
@@ -476,18 +483,6 @@ const promiseResolutionContext = (
seenBindings: new Set(),
});
-const unwrapExpression = (node: t.Node): t.Node => {
- if (
- t.isParenthesizedExpression(node) ||
- t.isTSAsExpression(node) ||
- t.isTSSatisfiesExpression(node) ||
- t.isTSNonNullExpression(node) ||
- t.isTypeCastExpression(node)
- )
- return unwrapExpression(node.expression);
- return node;
-};
-
const combinePromiseResolutions = (
resolutions: readonly PromiseResolution[],
): PromiseResolution => ({
diff --git a/src/domain/javascript/javascriptSemanticRequireOrigin.ts b/src/domain/javascript/javascriptSemanticRequireOrigin.ts
index e0bf54046..b5159afc8 100644
--- a/src/domain/javascript/javascriptSemanticRequireOrigin.ts
+++ b/src/domain/javascript/javascriptSemanticRequireOrigin.ts
@@ -6,7 +6,10 @@ import {
semanticResolutionBlocked,
type JavaScriptSemanticAnalysisState,
} from "./javascriptSemanticState.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import {
+ semanticStaticPropertyKey,
+ unwrapJavaScriptExpression,
+} from "./javascriptAstValues.js";
import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
/** Recover an unshadowed literal require origin and its exact member path. */
@@ -15,23 +18,34 @@ export const semanticRequireOrigin = (
state: JavaScriptSemanticAnalysisState,
): JavaScriptModuleOrigin | undefined => {
const members: string[] = [];
- while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
- const member = semanticStaticPropertyKey(node.property, node.computed);
- if (member === null || !t.isNode(node.object)) return undefined;
+ let current = node;
+ while (current !== null && current !== undefined) {
+ current = unwrapJavaScriptExpression(current).node;
+ if (
+ !t.isMemberExpression(current) &&
+ !t.isOptionalMemberExpression(current)
+ )
+ break;
+ const member = semanticStaticPropertyKey(
+ current.property,
+ current.computed,
+ );
+ if (member === null || !t.isNode(current.object)) return undefined;
members.push(member);
- node = node.object;
+ current = current.object;
}
if (
- !t.isCallExpression(node) ||
- !t.isIdentifier(node.callee, { name: "require" })
+ !t.isCallExpression(current) ||
+ !t.isIdentifier(current.callee, { name: "require" })
)
return undefined;
if (
- resolveSemanticBindingState(state, node.callee, "require") !== undefined ||
- semanticResolutionBlocked(state, node.callee, "require")
+ resolveSemanticBindingState(state, current.callee, "require") !==
+ undefined ||
+ semanticResolutionBlocked(state, current.callee, "require")
)
return undefined;
- const specifier = stringValue(node.arguments[0]);
+ const specifier = stringValue(current.arguments[0]);
return specifier === undefined
? undefined
: { specifier, importedPath: members.reverse() };
diff --git a/src/domain/javascript/javascriptSemanticReturns.ts b/src/domain/javascript/javascriptSemanticReturns.ts
index 13e68279a..95228ea3e 100644
--- a/src/domain/javascript/javascriptSemanticReturns.ts
+++ b/src/domain/javascript/javascriptSemanticReturns.ts
@@ -17,6 +17,7 @@ import type {
} from "./javascriptExportShapeComparisonSchemas.js";
import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { unwrapJavaScriptExpression } from "./javascriptAstValues.js";
import {
resolveSemanticBindingState,
type JavaScriptSemanticAnalysisState,
@@ -177,6 +178,9 @@ const callableIdsForNode = (
admitted: ReadonlySet<string>,
seen: ReadonlySet<string>,
): string[] => {
+ const unwrapped = unwrapJavaScriptExpression(node).node;
+ if (unwrapped !== node)
+ return callableIdsForNode(unwrapped, state, admitted, seen);
const direct = semanticCallableIdForNode(node);
if (direct !== null && admitted.has(direct)) return [direct];
if (t.isIdentifier(node)) {
@@ -185,13 +189,6 @@ const callableIdsForNode = (
? []
: callableIdsForBinding(binding, state, admitted, seen);
}
- if (
- t.isTSAsExpression(node) ||
- t.isTSTypeAssertion(node) ||
- t.isTSNonNullExpression(node) ||
- t.isTSSatisfiesExpression(node)
- )
- return callableIdsForNode(node.expression, state, admitted, seen);
return [];
};
diff --git a/src/domain/javascript/javascriptSemanticValues.ts b/src/domain/javascript/javascriptSemanticValues.ts
index d0eb007b5..39380a9c0 100644
--- a/src/domain/javascript/javascriptSemanticValues.ts
+++ b/src/domain/javascript/javascriptSemanticValues.ts
@@ -20,6 +20,7 @@ import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
import {
readExactJavaScriptLiteral,
semanticStaticPropertyKey,
+ unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
import {
semanticAmbiguousProvenance,
@@ -170,6 +171,18 @@ const evaluateExpression = (
): JavaScriptSemanticValue => {
if (context.expressionDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT)
return semanticResourceLimitUnknown("expression-depth");
+ const unwrapped = unwrapJavaScriptExpression(node);
+ if (unwrapped.depth > 0) {
+ if (
+ context.expressionDepth + unwrapped.depth >
+ SEMANTIC_EXPRESSION_DEPTH_LIMIT
+ )
+ return semanticResourceLimitUnknown("expression-depth");
+ return evaluateExpression(unwrapped.node, {
+ ...context,
+ expressionDepth: context.expressionDepth + unwrapped.depth,
+ });
+ }
const literal = readExactJavaScriptLiteral(node);
if (literal.found)
return typeof literal.value === "number"
@@ -199,14 +212,6 @@ const evaluateExpression = (
if (t.isBinaryExpression(node, { operator: "+" }))
return evaluateAddition(node, context);
if (t.isUnaryExpression(node)) return evaluateUnary(node, context);
- if (
- (t.isTSAsExpression(node) ||
- t.isTSTypeAssertion(node) ||
- t.isTSNonNullExpression(node) ||
- t.isTSSatisfiesExpression(node)) &&
- t.isExpression(node.expression)
- )
- return evaluateExpression(node.expression, nestedContext(context));
return { status: "unknown", reason: `Unsupported ${node.type} value.` };
};
@@ -531,6 +536,21 @@ const provenanceForExpression = (
"unknown",
semanticResourceLimitReason("expression-depth"),
);
+ const unwrapped = unwrapJavaScriptExpression(node);
+ if (unwrapped.depth > 0) {
+ if (
+ context.expressionDepth + unwrapped.depth >
+ SEMANTIC_EXPRESSION_DEPTH_LIMIT
+ )
+ return semanticUnresolvedProvenance(
+ "unknown",
+ semanticResourceLimitReason("expression-depth"),
+ );
+ return provenanceForExpression(unwrapped.node, {
+ ...context,
+ expressionDepth: context.expressionDepth + unwrapped.depth,
+ });
+ }
const required = semanticRequireOrigin(node, context.state);
if (required !== undefined) return semanticOriginsProvenance([required]);
if (t.isIdentifier(node)) {
diff --git a/src/domain/javascript/javascriptSourceParser.ts b/src/domain/javascript/javascriptSourceParser.ts
index 86d030bc3..e413e0cb4 100644
--- a/src/domain/javascript/javascriptSourceParser.ts
+++ b/src/domain/javascript/javascriptSourceParser.ts
@@ -8,9 +8,14 @@ export const parseJavaScriptSource = (
source: string,
sourcePath?: string,
): ParsedJavaScriptSource | null => {
+ const path = sourcePath ?? "";
+ const isMts = /\.mts$/iu.test(path);
const typescript: ParserPlugin = [
"typescript",
- { dts: /\.d\.(?:ts|mts|cts)$/iu.test(sourcePath ?? "") },
+ {
+ dts: /\.d\.(?:ts|mts|cts)$/iu.test(path),
+ ...(isMts ? { disallowAmbiguousJSXLike: true } : {}),
+ },
];
try {
return parse(source, {
@@ -21,9 +26,10 @@ export const parseJavaScriptSource = (
// forms, including parameter decorators. Without it a decorated
// TypeScript source fails to parse at all rather than reporting
// recovered syntax, which loses every fact derived from that source.
+ // TypeScript's .mts mode disables JSX and rejects ambiguous angle syntax.
// Plain .ts and .cts artifacts admit angle-bracket type assertions instead of JSX.
// Unknown paths retain the existing JSX-capable parser contract.
- plugins: /\.(?:ts|cts)$/iu.test(sourcePath ?? "")
+ plugins: /\.(?:ts|cts|mts)$/iu.test(path)
? ["decorators-legacy", typescript]
: ["decorators-legacy", "jsx", typescript],
});
diff --git a/src/domain/javascript/javascriptStaticAnalysisHelpers.ts b/src/domain/javascript/javascriptStaticAnalysisHelpers.ts
index ed1cd8e21..25cd0fcbc 100644
--- a/src/domain/javascript/javascriptStaticAnalysisHelpers.ts
+++ b/src/domain/javascript/javascriptStaticAnalysisHelpers.ts
@@ -14,6 +14,7 @@ import type {
import {
readExactJavaScriptLiteral,
semanticStaticPropertyName,
+ unwrapJavaScriptExpression,
} from "./javascriptAstValues.js";
import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
@@ -100,8 +101,8 @@ const findChunkRuntime = (node: t.Node): string | undefined => {
pending.push(current.right, current.left);
continue;
}
- if (t.isParenthesizedExpression(current) || t.isTSAsExpression(current))
- pending.push(current.expression);
+ const unwrapped = unwrapJavaScriptExpression(current).node;
+ if (unwrapped !== current) pending.push(unwrapped);
}
return undefined;
};
diff --git a/src/domain/javascript/javascriptStaticAnalysisModuleIndex.test.ts b/src/domain/javascript/javascriptStaticAnalysisModuleIndex.test.ts
index 075597a70..4c585786c 100644
--- a/src/domain/javascript/javascriptStaticAnalysisModuleIndex.test.ts
+++ b/src/domain/javascript/javascriptStaticAnalysisModuleIndex.test.ts
@@ -67,3 +67,15 @@ it("keeps module references attributed across many real factory ranges", () => {
)?.module_key,
).toBe("module-0");
});
+
+it("retains the chunk runtime through a TypeScript-only expression wrapper", () => {
+ const analysis = analyzeJavaScriptStaticSource(
+ '(globalThis.webpackChunkApp satisfies unknown).push([[1], { "entry": function () {} }]);',
+ );
+ expect(analysis.bundler_registrations).toEqual([
+ expect.objectContaining({
+ runtime: "webpackChunkApp",
+ modules: [expect.objectContaining({ module_key: "entry" })],
+ }),
+ ]);
+});