fix(javascript): honor computed keys when naming callables, exports, requests and options (#536)

This commit is contained in:
morluto
2026-10-05 15:52:06 +08:00
committed by GitHub
parent d40502aa3b
commit 4c8dc39f43
6 changed files with 84 additions and 9 deletions
@@ -84,6 +84,24 @@ describe("JavaScript semantic analysis: runtime boundaries 1", () => {
expect(ir.timerOperations).toEqual([]);
});
it("does not invent request fields or option keys from dynamic properties", () => {
const ir = analyzeJavaScriptSemantics(`
const key = resolveKey();
fetch("https://example.test", { [key]: 1, body: "x" });
spawn("/bin/tool", { [key]: vars });
`);
expect(
ir.requestOperations.flatMap(({ fields }) =>
fields.map(({ name }) => name),
),
).toEqual(["body"]);
expect(
ir.childProcessSpawns.some(
({ environmentSupplied }) => environmentSupplied,
),
).toBe(false);
});
it("retains every added semantic effect family", () => {
const ir = analyzeJavaScriptSemantics(
`
@@ -319,6 +319,28 @@ describe("JavaScript semantic analysis: structure 2", () => {
);
});
it("does not invent export or method names from dynamic keys", () => {
const ir = analyzeJavaScriptSemantics(`
const key = resolveKey();
exports[key] = addon;
module.exports[key] = addon;
const target = { [key]() { return 1; } };
class Holder { [key]() { return 2; } }
`);
// The assignment is real, but its name is not knowable, so the only
// honest exported_name is the wildcard.
expect(
ir.moduleLinks
.filter(({ kind }) => kind === "commonjs-export")
.map(({ exportedName }) => exportedName),
).toEqual(["*", "*"]);
const names = ir.callables.map(({ name }) => name);
expect(names).not.toContain("key");
expect(names.filter((name) => name?.startsWith("[computed@")).length).toBe(
2,
);
});
it("keeps function, class, and method identities separate from bindings", () => {
const ir = analyzeJavaScriptSemantics(`
class Service {
@@ -317,7 +317,9 @@ const objectProperty = (
object?.properties.find(
(property): property is t.ObjectMethod | t.ObjectProperty =>
(t.isObjectMethod(property) || t.isObjectProperty(property)) &&
propertyName(property.key) === name,
// `{[env]: vars}` has a dynamic key; treating it as `env` would claim
// the caller supplied an environment when the real key is unknown.
semanticStaticPropertyName(property.key, property.computed) === name,
) ?? null;
const objectBinding = (
+3 -1
View File
@@ -370,7 +370,9 @@ const requestFields = (
if (!t.isObjectExpression(candidate)) return [];
return candidate.properties.flatMap((property) => {
if (!t.isObjectProperty(property)) return [];
const name = propertyName(property.key);
// `{[key]: 1}` sends no knowable field name; reporting `key` would invent
// a request field that may not exist.
const name = semanticStaticPropertyName(property.key, property.computed);
if (name.length === 0) return [];
return [
{
+25 -6
View File
@@ -226,7 +226,12 @@ const callableName = (node: t.Node, parent: t.Node | null): string | null => {
t.isObjectMethod(node)
) {
if (t.isPrivateName(node.key)) return `#${node.key.id.name}`;
return propertyName(node.key) || `[computed@${String(node.start ?? -1)}]`;
// `{[key]() {}}` names nothing statically; reading `key` off the key node
// would report the variable name as the method name.
return (
semanticStaticPropertyName(node.key, node.computed) ||
`[computed@${String(node.start ?? -1)}]`
);
}
if (
parent !== null &&
@@ -490,18 +495,32 @@ const commonJsExportName = (node: t.Node): string | undefined => {
if (t.isIdentifier(node, { name: "exports" })) return "default";
if (!t.isMemberExpression(node) && !t.isOptionalMemberExpression(node))
return undefined;
const name = propertyName(node.property);
if (t.isIdentifier(node.object, { name: "exports" })) return name || "*";
const key = memberKey(node);
// `exports[key]`/`module.exports[key]` assign an export whose name is not
// knowable. Report the wildcard rather than the variable name, and never
// collapse it into `default`, which would claim a real default export.
if (key === null) return "*";
if (t.isIdentifier(node.object, { name: "exports" })) return key || "*";
if (
t.isMemberExpression(node.object) &&
t.isIdentifier(node.object.object, { name: "module" }) &&
propertyName(node.object.property) === "exports"
memberKey(node.object) === "exports"
)
return name || "default";
return key || "default";
if (
t.isIdentifier(node.object, { name: "module" }) &&
propertyName(node.property) === "exports"
memberKey(node) === "exports"
)
return "default";
return undefined;
};
/** Exact member key, or null when a computed key commits no name. */
const memberKey = (
node: t.MemberExpression | t.OptionalMemberExpression,
): string | null =>
node.computed &&
!t.isStringLiteral(node.property) &&
!t.isNumericLiteral(node.property)
? null
: propertyName(node.property);
+13 -1
View File
@@ -296,12 +296,24 @@ const calleeNameAt = (node: t.Node): string => {
if (t.isImport(node)) return "import";
if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
const object = t.isNode(node.object) ? calleeNameAt(node.object) : "";
const property = propertyName(node.property);
// A dynamic key commits no name: `target[method]()` must not be reported as
// `target.method`, which would fabricate a runtime call shape.
const property = memberPropertyName(node);
return object === "" ? property : `${object}.${property}`;
}
return "";
};
/** Read a member property only when its syntax commits an exact name. */
const memberPropertyName = (
node: t.MemberExpression | t.OptionalMemberExpression,
): string =>
node.computed &&
!t.isStringLiteral(node.property) &&
!t.isNumericLiteral(node.property)
? `[computed@${String(node.property.start ?? -1)}]`
: propertyName(node.property);
/** Return a string literal value without evaluating an expression. */
export const stringValue = (
node: t.Node | null | undefined,