rea-agents 6.2.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticMutationInitializers.js

@@ -0,0 +1,190 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
+const statementPosition = (statement, parents, declarator) => {
+    const parent = parents.get(statement);
+    if (!t.isProgram(parent) && !t.isBlockStatement(parent))
+        return null;
+    const index = parent.body.indexOf(statement);
+    return index < 0
+        ? null
+        : {
+            body: parent.body,
+            index,
+            declaratorIndex: t.isVariableDeclaration(statement) && declarator !== undefined
+                ? statement.declarations.indexOf(declarator)
+                : -1,
+        };
+};
+const positionPrecedes = (left, right) => left.body === right.body &&
+    (left.index < right.index ||
+        (left.index === right.index &&
+            left.declaratorIndex >= 0 &&
+            left.declaratorIndex < right.declaratorIndex));
+const directInitializerPosition = (node, parents) => {
+    const parent = parents.get(node);
+    if (t.isVariableDeclarator(parent) && parent.init === node) {
+        const declaration = parents.get(parent);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, parent)
+            : null;
+    }
+    if (t.isAssignmentExpression(parent) &&
+        parent.operator === "=" &&
+        parent.right === node &&
+        t.isIdentifier(parent.left)) {
+        const statement = parents.get(parent);
+        return t.isExpressionStatement(statement) && statement.expression === parent
+            ? statementPosition(statement, parents)
+            : null;
+    }
+    return null;
+};
+const directMutationPosition = (node, parents) => {
+    if (t.isForOfStatement(node))
+        return statementPosition(node, parents);
+    if (t.isVariableDeclarator(node)) {
+        const declaration = parents.get(node);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents, node)
+            : null;
+    }
+    if (t.isSpreadElement(node)) {
+        const array = parents.get(node);
+        return t.isArrayExpression(array)
+            ? semanticCapturePosition(array, parents)
+            : null;
+    }
+    if (!t.isAssignmentExpression(node) &&
+        !t.isUpdateExpression(node) &&
+        !t.isUnaryExpression(node, { operator: "delete" }) &&
+        !t.isCallExpression(node) &&
+        !t.isOptionalCallExpression(node) &&
+        !t.isNewExpression(node) &&
+        !t.isTaggedTemplateExpression(node))
+        return null;
+    let current = node;
+    while (true) {
+        const parent = parents.get(current);
+        if (parent === undefined ||
+            t.isFunction(parent) ||
+            (t.isLogicalExpression(parent) && parent.right === current) ||
+            (t.isConditionalExpression(parent) && parent.test !== current))
+            return null;
+        if (t.isStatement(parent))
+            return statementPosition(parent, parents);
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+const referenceInitializerPosition = (node, parents) => {
+    // Defaults live inside the declaration pattern rather than its initializer.
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (parent === undefined || t.isStatement(parent) || t.isFunction(parent))
+            return null;
+        if (t.isVariableDeclarator(parent)) {
+            const declaration = parents.get(parent);
+            return t.isVariableDeclaration(declaration)
+                ? statementPosition(declaration, parents, parent)
+                : null;
+        }
+        current = parent;
+    }
+};
+/** Resolve origins at their use or capture, never at a later transitive effect. */
+export const semanticMutationInitializers = (binding, mutation, parents) => {
+    const mutationPosition = directMutationPosition(mutation, parents) ??
+        referenceInitializerPosition(mutation, parents);
+    if (mutationPosition === null)
+        return binding;
+    const origins = [
+        ...binding.initializers.map((initializer) => ({
+            initializer,
+            position: initializer.entryBody === undefined
+                ? directInitializerPosition(initializer.node, parents)
+                : {
+                    body: initializer.entryBody.body,
+                    index: -1,
+                    declaratorIndex: -1,
+                },
+        })),
+        ...binding.referenceInitializers.map((initializer) => ({
+            initializer,
+            position: referenceInitializerPosition(initializer.node, parents),
+        })),
+    ];
+    if (origins.some(({ position }) => position === null || !positionPrecedes(position, mutationPosition)))
+        return binding;
+    const latest = origins.reduce((latest, { position }) => position !== null &&
+        (latest === null || positionPrecedes(latest, position))
+        ? position
+        : latest, null);
+    const retained = new Set(origins
+        .filter(({ position }) => position?.index === latest?.index &&
+        position?.declaratorIndex === latest?.declaratorIndex)
+        .map(({ initializer }) => initializer));
+    return {
+        initializers: binding.initializers.filter((initializer) => retained.has(initializer)),
+        referenceInitializers: binding.referenceInitializers.filter((initializer) => retained.has(initializer)),
+    };
+};
+/** Locate a capture only in an unconditional declaration or literal initializer. */
+export const semanticCapturePosition = (node, parents) => {
+    let current = node;
+    while (true) {
+        const direct = directInitializerPosition(current, parents);
+        if (direct !== null)
+            return direct;
+        const parent = parents.get(current);
+        if (t.isObjectProperty(parent) &&
+            parent.value === current &&
+            semanticStaticPropertyKey(parent.key, parent.computed) !== null)
+            current = parent;
+        else if (t.isObjectExpression(parent) || t.isArrayExpression(parent))
+            current = parent;
+        else
+            return null;
+    }
+};
+/** Intermediate values must themselves have been initialized before capture. */
+export const semanticBindingPrecedesCapture = (binding, capture, parents) => {
+    const initializer = binding.initializers[0];
+    if (binding.initializers.length !== 1 || initializer === undefined)
+        return false;
+    const sourcePosition = directInitializerPosition(initializer.node, parents);
+    const capturePosition = semanticCapturePosition(capture, parents);
+    return (sourcePosition !== null &&
+        capturePosition !== null &&
+        positionPrecedes(sourcePosition, capturePosition));
+};
+/** Ignore later escapes only while reading earlier references in one activation. */
+export const semanticEscapeFollowsCapture = (binding, capture, escape, parents) => {
+    const initializer = binding.initializers[0];
+    if (escape === undefined ||
+        initializer === undefined ||
+        !semanticBindingPrecedesCapture(binding, capture, parents))
+        return false;
+    // A literal allocates here. Aliases are evaluated at the same capture point,
+    // so an outer/persistent origin still receives all of its own escape effects.
+    const origin = unwrapJavaScriptExpression(initializer.node).node;
+    if (!t.isObjectExpression(origin) &&
+        !t.isArrayExpression(origin) &&
+        !t.isIdentifier(origin) &&
+        !t.isMemberExpression(origin) &&
+        !t.isOptionalMemberExpression(origin))
+        return false;
+    const capturePosition = semanticCapturePosition(capture, parents);
+    const escapePosition = directMutationPosition(escape, parents);
+    return (capturePosition !== null &&
+        escapePosition !== null &&
+        positionPrecedes(capturePosition, escapePosition));
+};

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -1,47 +1,104 @@
-/** Invalidate only slots that an explicit mutation can affect. */
-export const invalidateSemanticMutationPath = (value, path) => {
+import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
+/** Invalidate escaped object references without rewriting their containing slots. */
+export const invalidateSemanticEscapedPath = (value, path) => {
+    if (value.status !== "object" && value.status !== "array")
+        return value;
     const [key, ...remaining] = path;
-    const unknown = {
-        status: "unknown",
-        reason: "This property may have been mutated.",
+    if (key === undefined)
+        return {
+            status: "unknown",
+            reason: "This object reference may have been mutated by a call.",
+        };
+    const invalidateChild = (property) => semanticPropertyPathKeyMatches(key, property.name)
+        ? {
+            ...property,
+            value: invalidateSemanticEscapedPath(property.value, remaining),
+        }
+        : property;
+    return value.status === "object"
+        ? { ...value, properties: value.properties.map(invalidateChild) }
+        : { ...value, items: value.items.map(invalidateChild) };
+};
+/**
+ * Invalidate only slots that explicit mutations can affect, as if applying each
+ * path in order. Paths are grouped per slot so that many writes to one object
+ * cost one pass over its slots rather than one pass per write.
+ */
+export const invalidateSemanticMutationPaths = (value, paths) => {
+    if (paths.length === 0)
+        return value;
+    // An unknown key or a replaced value leaves nothing that a later path can
+    // restore, wherever it occurs in the sequence.
+    if ((value.status !== "object" && value.status !== "array") ||
+        paths.some(([key]) => key === undefined || key === null))
+        return {
+            status: "unknown",
+            reason: "This property may have been mutated.",
+        };
+    // Writing an array length discards every item known before it.
+    const reset = value.status === "array"
+        ? paths.findLastIndex(([key]) => key === "length")
+        : -1;
+    const base = reset < 0
+        ? value
+        : { status: "array", items: [], unknownItems: true, omittedItems: null };
+    const slots = base.status === "object" ? base.properties : base.items;
+    const slotsByName = new Map();
+    slots.forEach((property, index) => {
+        const indexes = slotsByName.get(property.name) ?? [];
+        indexes.push(index);
+        slotsByName.set(property.name, indexes);
+    });
+    const slotPaths = new Map();
+    const replacedSlots = new Set();
+    const select = (index, remaining) => {
+        const selected = slotPaths.get(index) ?? [];
+        selected.push(remaining);
+        slotPaths.set(index, selected);
+        if (remaining.length === 0)
+            replacedSlots.add(index);
     };
-    if (key === undefined || key === null)
-        return unknown;
-    if (value.status === "object") {
-        const name = String(key);
-        const observed = value.properties.some((property) => property.name === name);
-        const properties = value.properties.map((property) => property.name === name
-            ? {
+    // An added slot is already unknown, so later paths that select it are inert.
+    const added = new Set();
+    for (const [key, ...remaining] of paths.slice(reset + 1)) {
+        if (key === undefined || key === null)
+            continue;
+        if (typeof key === "object") {
+            slots.forEach((property, index) => {
+                if (semanticPropertyPathKeyMatches(key, property.name))
+                    select(index, remaining);
+            });
+            continue;
+        }
+        const indexes = slotsByName.get(String(key));
+        if (indexes === undefined)
+            added.add(String(key));
+        else
+            for (const index of indexes)
+                select(index, remaining);
+    }
+    const properties = slots.map((property, index) => {
+        const selected = slotPaths.get(index);
+        return selected === undefined
+            ? property
+            : {
                 ...property,
-                ...(remaining.length === 0
+                ...(replacedSlots.has(index)
                     ? { presence: "unknown-coverage" }
                     : {}),
-                value: invalidateSemanticMutationPath(property.value, remaining),
-            }
-            : property);
-        if (!observed)
-            properties.push({ name, value: unknown, presence: "unknown-coverage" });
-        return { ...value, properties };
-    }
-    if (value.status === "array") {
-        const name = String(key);
-        // Array length writes can remove every index; ordinary named properties
-        // and sparse indices affect only their own slot.
-        if (name === "length")
-            return unknown;
-        const observed = value.items.some((item) => item.name === name);
-        const items = value.items.map((item) => item.name === name
-            ? {
-                ...item,
-                presence: remaining.length === 0
-                    ? "unknown-coverage"
-                    : item.presence,
-                value: invalidateSemanticMutationPath(item.value, remaining),
-            }
-            : item);
-        if (!observed)
-            items.push({ name, presence: "unknown-coverage", value: unknown });
-        return { ...value, items };
-    }
-    return unknown;
+                value: invalidateSemanticMutationPaths(property.value, selected),
+            };
+    });
+    for (const name of added)
+        properties.push({
+            name,
+            value: {
+                status: "unknown",
+                reason: "This property may have been mutated.",
+            },
+            presence: "unknown-coverage",
+        });
+    return base.status === "object"
+        ? { ...base, properties }
+        : { ...base, items: properties };
 };