rea-agents 6.4.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticObjectReferences.js

@@ -1,9 +1,10 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { semanticCallableResultExpressions } from "./javascriptSemanticCallableResults.js";
 import { semanticStaticPropertyKey, unwrapJavaScriptExpression, } from "./javascriptAstValues.js";
 import { semanticPropertyPathKeyMatches, } from "./javascriptSemanticPropertyPaths.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { SemanticGetterQuery, } from "./javascriptSemanticGetterQueries.js";
+import { expandSemanticGetterResult } from "./javascriptSemanticGetterResults.js";
 export const semanticClassCandidates = (root, state) => {
     const pending = [root];
     const seenNodes = new Set();
@@ -44,7 +45,7 @@ export const semanticClassCandidates = (root, state) => {
     }
     return classes;
 };
-const instanceFieldReferences = (root, propertyName, path, state) => {
+const instanceFieldReferences = (root, propertyName, path, state, initializedBefore) => {
     const references = [];
     const pending = [{ klass: root, excluded: new Set() }];
     const selections = new Map();
@@ -63,7 +64,13 @@ const instanceFieldReferences = (root, propertyName, path, state) => {
             continue;
         selections.set(current.klass, excluded);
         const shadowed = new Set(excluded);
-        for (const member of [...current.klass.body.body].reverse()) {
+        const before = initializedBefore === undefined
+            ? -1
+            : current.klass.body.body.indexOf(initializedBefore);
+        const members = before < 0
+            ? current.klass.body.body
+            : current.klass.body.body.slice(0, before);
+        for (const member of [...members].reverse()) {
             if (!t.isClassProperty(member) || member.static)
                 continue;
             const key = semanticStaticPropertyKey(member.key, member.computed);
@@ -88,12 +95,17 @@ const instanceFieldReferences = (root, propertyName, path, state) => {
     }
     return { references, definiteNames: definiteNames ?? new Set() };
 };
-const classPropertyDescriptors = (klass, propertyName, kind) => {
+const classPropertyDescriptors = (klass, propertyName, kind, initializedBefore) => {
     const isStatic = kind === "static";
     const selectedGetters = [];
     const fields = [];
     const indexedMembers = [];
+    const before = initializedBefore === undefined
+        ? -1
+        : klass.body.body.indexOf(initializedBefore);
     klass.body.body.forEach((member, index) => {
+        if (before >= 0 && index >= before && t.isClassProperty(member))
+            return;
         if ((t.isClassMethod(member) ||
             (kind === "static" && t.isClassProperty(member))) &&
             member.static === isStatic)
@@ -144,48 +156,75 @@ const classPropertyDescriptors = (klass, propertyName, kind) => {
         inherits: matchingMembers.length === 0,
     };
 };
-export const semanticClassPropertyReferences = (lookup, selection, state, activeGetters = new Map()) => {
-    const root = lookup.owner;
-    const receiver = lookup.receiver ?? root;
-    const [key, ...path] = selection;
-    const propertyName = key == null || typeof key === "object" ? null : String(key);
-    const pending = [root];
-    const seen = new Set();
-    const possibleResults = [];
-    // Instance fields are own properties, including fields initialized by base
-    // constructors. They take precedence over every prototype descriptor.
-    let instanceFields = new Set();
-    if (lookup.kind === "instance") {
-        const fields = instanceFieldReferences(root, propertyName, path, state);
-        possibleResults.push(...fields.references);
-        instanceFields = fields.definiteNames;
-        if (propertyName !== null && instanceFields.has(propertyName))
-            return possibleResults;
+export const semanticClassPropertyReferences = (lookup, selection, state) => {
+    const query = new SemanticGetterQuery(state);
+    return query.run(() => classPropertyReferences(lookup, selection, state, { query }), (job) => expandGetterResult(job, query));
+};
+class ClassReferenceWalk {
+    lookup;
+    state;
+    context;
+    #references = [];
+    #pending;
+    #seen = new Set();
+    #name;
+    #path;
+    #fields = new Set();
+    constructor(lookup, selection, state, context) {
+        this.lookup = lookup;
+        this.state = state;
+        this.context = context;
+        const [key, ...path] = selection;
+        this.#name = key == null || typeof key === "object" ? null : String(key);
+        this.#path = path;
+        this.#pending = [lookup.owner];
     }
-    for (let cursor = 0; cursor < pending.length; cursor++) {
-        const klass = pending[cursor];
-        if (klass === undefined || seen.has(klass))
-            continue;
-        seen.add(klass);
-        const descriptors = classPropertyDescriptors(klass, propertyName, lookup.kind);
+    #instanceFields() {
+        if (this.lookup.kind !== "instance")
+            return false;
+        // Own fields, including inherited constructor fields, suppress prototype descriptors.
+        const fields = instanceFieldReferences(this.lookup.owner, this.#name, this.#path, this.state, this.lookup.initializedBefore);
+        for (const reference of fields.references)
+            this.#references.push(reference);
+        this.#fields = fields.definiteNames;
+        return this.#name !== null && this.#fields.has(this.#name);
+    }
+    #getter(klass, getter) {
+        const key = semanticStaticPropertyKey(getter.key, getter.computed);
+        if (key !== null && this.#fields.has(key))
+            return;
+        this.context.query.schedule({
+            getter,
+            owner: klass,
+            receiver: this.lookup.receiver ?? this.lookup.owner,
+        }, this.#path, this.context.escapes);
+    }
+    #visit(klass) {
+        const descriptors = classPropertyDescriptors(klass, this.#name, this.lookup.kind, this.lookup.initializedBefore);
         for (const field of descriptors.fields)
             if (field.value != null)
-                possibleResults.push({ node: field.value, path });
-        for (const getter of descriptors.getters) {
-            const key = semanticStaticPropertyKey(getter.key, getter.computed);
-            if (key !== null && instanceFields.has(key))
+                this.#references.push({ node: field.value, path: this.#path });
+        for (const getter of this.lookup.fieldsOnly ? [] : descriptors.getters)
+            this.#getter(klass, getter);
+        // Only a definite own descriptor can suppress possible superclass results.
+        if (descriptors.inherits && klass.superClass != null)
+            for (const base of semanticClassCandidates(klass.superClass, this.state))
+                this.#pending.push(base);
+    }
+    run() {
+        if (this.#instanceFields())
+            return this.#references;
+        for (let cursor = 0; cursor < this.#pending.length; cursor++) {
+            const klass = this.#pending[cursor];
+            if (klass === undefined || this.#seen.has(klass))
                 continue;
-            possibleResults.push(...getterResultReferences({ getter, owner: klass, receiver }, path, state, activeGetters));
+            this.#seen.add(klass);
+            this.#visit(klass);
         }
-        // An exact own descriptor suppresses inherited lookup. Dynamic computed
-        // descriptors may or may not match, so retain possible superclass results.
-        if (descriptors.inherits &&
-            klass.superClass !== null &&
-            klass.superClass !== undefined)
-            pending.push(...semanticClassCandidates(klass.superClass, state));
+        return this.#references;
     }
-    return possibleResults;
-};
+}
+const classPropertyReferences = (lookup, selection, state, context) => new ClassReferenceWalk(lookup, selection, state, context).run();
 const objectReceiverReference = (object, path, state) => {
     // A literal's enclosing binding owns its slots. Returning the literal
     // itself would bypass invalidation of that binding's observed properties.
@@ -196,7 +235,42 @@ const objectReceiverReference = (object, path, state) => {
         if (t.isVariableDeclarator(parent) &&
             parent.init === current &&
             t.isIdentifier(parent.id))
-            return [{ node: parent.id, path: [...projection, ...path] }];
+            return [
+                {
+                    node: parent.id,
+                    path: [...projection, ...path],
+                    ownerInitializer: current,
+                },
+            ];
+        if (t.isAssignmentExpression(parent, { operator: "=" }) &&
+            parent.right === current &&
+            t.isIdentifier(parent.left))
+            return [
+                {
+                    node: parent.left,
+                    path: [...projection, ...path],
+                    ownerInitializer: current,
+                },
+            ];
+        if (t.isArrayExpression(parent)) {
+            let minimumIndex = 0;
+            let uncertainIndex = false;
+            for (const element of parent.elements) {
+                if (element === current)
+                    break;
+                if (t.isSpreadElement(element))
+                    uncertainIndex = true;
+                else
+                    minimumIndex++;
+            }
+            // A spread contributes an unknown number of slots. Retain the known
+            // prefix without treating the element's syntax position as its index.
+            projection.unshift(uncertainIndex
+                ? { excludedKeys: [], startIndex: minimumIndex }
+                : minimumIndex);
+            current = parent;
+            continue;
+        }
         if (t.isObjectProperty(parent) && parent.value === current) {
             projection.unshift(semanticStaticPropertyKey(parent.key, parent.computed));
             const container = state.parentsByNode.get(parent);
@@ -209,151 +283,280 @@ const objectReceiverReference = (object, path, state) => {
     }
     return [{ node: object, path }];
 };
-const getterResultReferences = (invocation, path, state, activeGetters = new Map()) => {
-    const { getter, owner, receiver = owner } = invocation;
-    const previousLength = activeGetters.get(getter);
-    if (previousLength !== undefined && previousLength <= path.length)
-        return [];
-    // Repeated receiver reads may revisit a getter while consuming a finite
-    // path; recursive getters that preserve or grow that path cannot progress.
-    const active = new Map(activeGetters).set(getter, path.length);
-    const isStatic = t.isClassMethod(getter) && getter.static;
-    const resolve = (node, remaining) => {
-        const expression = unwrapJavaScriptExpression(node).node;
-        if (t.isThisExpression(expression)) {
-            if (t.isClass(receiver)) {
-                return semanticClassPropertyReferences({ owner: receiver, kind: isStatic ? "static" : "instance" }, remaining, state, active);
-            }
-            return objectReceiverReference(receiver, remaining, state);
-        }
-        if (t.isMemberExpression(expression) ||
-            t.isOptionalMemberExpression(expression)) {
-            if (t.isPrivateName(expression.property) &&
-                t.isThisExpression(expression.object) &&
-                t.isClass(owner)) {
-                const privateName = expression.property.id.name;
-                return owner.body.body.flatMap((member) => t.isClassPrivateProperty(member) &&
-                    member.static === isStatic &&
-                    member.key.id.name === privateName &&
-                    member.value != null
-                    ? [{ node: member.value, path: remaining }]
-                    : []);
-            }
-            const key = semanticStaticPropertyKey(expression.property, expression.computed);
-            if (t.isSuper(expression.object) &&
-                t.isClass(owner) &&
-                owner.superClass != null) {
-                return semanticClassCandidates(owner.superClass, state).flatMap((base) => semanticClassPropertyReferences({
-                    owner: base,
-                    receiver: t.isClass(receiver) ? receiver : owner,
-                    kind: isStatic ? "static" : "prototype",
-                }, [key, ...remaining], state, active));
-            }
-            return resolve(expression.object, [key, ...remaining]);
-        }
-        if (t.isConditionalExpression(expression))
-            return [
-                ...resolve(expression.consequent, remaining),
-                ...resolve(expression.alternate, remaining),
-            ];
-        if (t.isLogicalExpression(expression))
-            return [
-                ...resolve(expression.left, remaining),
-                ...resolve(expression.right, remaining),
-            ];
-        if (t.isSequenceExpression(expression)) {
-            const last = expression.expressions.at(-1);
-            return last === undefined ? [] : resolve(last, remaining);
-        }
-        return [{ node: expression, path: remaining }];
+// Getter return expressions use the receiver of the property read. Keep that
+// identity when translating `this`, private fields, and superclass reads into
+// the same reference paths used by ordinary member mutations.
+/** Follow only data fields whose initializers retain a class receiver. */
+const privateReceiverProjection = (receiver, owner, path, isStatic, state) => {
+    if (path.some((key) => key === null || typeof key === "object"))
+        return false;
+    const pending = [
+        {
+            receiver,
+            path: path.map((key) => ({ key: String(key) })),
+            visits: new Map(),
+        },
+    ];
+    const seen = new Set();
+    const declaringClass = (field) => {
+        const body = state.parentsByNode.get(field);
+        return body === undefined ? undefined : state.parentsByNode.get(body);
     };
-    return semanticCallableResultExpressions(getter).flatMap(({ node }) => node === null ? [] : resolve(node, path));
-};
-export const semanticObjectPropertyReferences = (node, path, state) => {
-    const [key, ...remaining] = path;
-    const references = [];
-    const overwritten = new Set();
-    const dataOverwritten = new Set();
-    const accessorNames = new Set();
-    const getterNames = new Set();
-    const setterNames = new Set();
-    for (const property of [...node.properties].reverse()) {
-        if (t.isSpreadElement(property)) {
-            const selected = key ?? null;
-            if (typeof selected !== "object" && overwritten.has(String(selected)))
-                continue;
-            references.push({
-                node: property.argument,
-                path: [
-                    typeof selected === "object"
-                        ? {
-                            ...selected,
-                            excludedKeys: [
-                                ...new Set([
-                                    ...(selected?.excludedKeys ?? []),
-                                    ...overwritten,
-                                ]),
-                            ].sort(compareUnicodeCodePoints),
-                        }
-                        : selected,
-                    ...remaining,
-                ],
-            });
-            if (selected !== null &&
-                typeof selected !== "object" &&
-                t.isObjectExpression(property.argument) &&
-                objectExpressionDefinesKey(property.argument, String(selected))) {
-                overwritten.add(String(selected));
-                dataOverwritten.add(String(selected));
-            }
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+        const current = pending[cursor];
+        if (current === undefined)
+            break;
+        const [selection, ...remaining] = current.path;
+        if (selection === undefined) {
+            if (!isStatic || current.receiver === owner)
+                return true;
             continue;
         }
-        const name = semanticStaticPropertyKey(property.key, property.computed);
-        const isGetter = t.isObjectMethod(property) && property.kind === "get";
-        const isSetter = t.isObjectMethod(property) && property.kind === "set";
-        if (name !== null &&
-            (isGetter || isSetter
-                ? dataOverwritten.has(name) ||
-                    (isGetter ? getterNames.has(name) : setterNames.has(name))
-                : dataOverwritten.has(name) || accessorNames.has(name)))
+        const origin = JSON.stringify([
+            current.receiver.start,
+            selection.key,
+            selection.before?.start,
+        ]);
+        const previous = current.visits.get(origin);
+        // Repeated fields may consume a finite getter path. An initializer cycle
+        // that preserves or grows it cannot establish another receiver identity.
+        if (previous !== undefined && previous <= current.path.length)
             continue;
-        if (name === null || semanticPropertyPathKeyMatches(key ?? null, name)) {
-            if (t.isObjectMethod(property) && property.kind === "get") {
-                references.push(...getterResultReferences({ getter: property, owner: node }, remaining, state));
-            }
-            else if (t.isObjectMethod(property) && property.kind === "set") {
-                // A setter contributes no readable reference. A paired getter is
-                // handled independently when it appears earlier in this object.
-            }
-            else {
-                references.push({
-                    node: t.isObjectProperty(property) ? property.value : property,
-                    path: remaining,
-                });
+        const visits = new Map(current.visits).set(origin, current.path.length);
+        const identity = JSON.stringify([
+            current.receiver.start,
+            current.path.map(({ key, before }) => [key, before?.start]),
+        ]);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        const lookupOwner = selection.before === undefined
+            ? current.receiver
+            : declaringClass(selection.before);
+        if (!t.isClass(lookupOwner))
+            continue;
+        for (const reference of semanticClassPropertyReferences({
+            owner: lookupOwner,
+            receiver: current.receiver,
+            kind: isStatic ? "static" : "instance",
+            fieldsOnly: true,
+            ...(selection.before === undefined
+                ? {}
+                : { initializedBefore: selection.before }),
+        }, [selection.key], state)) {
+            const field = state.parentsByNode.get(reference.node);
+            if (!t.isClassProperty(field))
+                continue;
+            const fieldOwner = declaringClass(field);
+            if (!t.isClass(fieldOwner))
+                continue;
+            const projection = [];
+            let value = unwrapJavaScriptExpression(reference.node).node;
+            while (t.isMemberExpression(value) ||
+                t.isOptionalMemberExpression(value)) {
+                const key = semanticStaticPropertyKey(value.property, value.computed);
+                if (key === null || t.isPrivateName(value.property))
+                    break;
+                projection.unshift({ key, before: field });
+                value = unwrapJavaScriptExpression(value.object).node;
             }
+            if (!t.isThisExpression(value))
+                continue;
+            // Instance fields retain the actual instance. Static field `this` belongs
+            // to its declaring class, even when a subclass inherits the field.
+            pending.push({
+                receiver: isStatic ? fieldOwner : current.receiver,
+                path: [...projection, ...remaining],
+                visits,
+            });
         }
-        if (name !== null) {
-            if (isGetter) {
-                getterNames.add(name);
-                accessorNames.add(name);
-                overwritten.add(name);
-            }
-            else if (isSetter) {
-                setterNames.add(name);
-                accessorNames.add(name);
-                overwritten.add(name);
-            }
-            else if (!(t.isObjectProperty(property) &&
+    }
+    return false;
+};
+const expandGetterResult = (job, query) => {
+    const state = query.state;
+    expandSemanticGetterResult(job, query, {
+        classReferences: (lookup, path, escapes) => classPropertyReferences(lookup, path, state, { query, escapes }),
+        objectReferences: (receiver, path) => objectReceiverReference(receiver, path, state),
+        privateReceiver: (receiver, owner, path, isStatic) => privateReceiverProjection(receiver, owner, path, isStatic, state),
+        bases: (node) => semanticClassCandidates(node, state),
+    });
+};
+// Mutation tracking resolves one key of the same literal per write, so the
+// index removes the per-write scan of every property.
+const propertyIndexes = new WeakMap();
+const objectPropertyIndex = (node) => {
+    const cached = propertyIndexes.get(node);
+    if (cached !== undefined)
+        return cached;
+    const keyIndependent = [];
+    const byName = new Map();
+    node.properties.forEach((property, index) => {
+        const name = t.isSpreadElement(property)
+            ? null
+            : semanticStaticPropertyKey(property.key, property.computed);
+        if (name === null ||
+            (t.isObjectProperty(property) &&
                 !property.computed &&
                 !property.shorthand &&
                 name === "__proto__")) {
-                overwritten.add(name);
-                dataOverwritten.add(name);
-            }
+            keyIndependent.push(index);
+            return;
         }
+        const positions = byName.get(name);
+        if (positions === undefined)
+            byName.set(name, [index]);
+        else
+            positions.push(index);
+    });
+    const index = { keyIndependent, byName };
+    propertyIndexes.set(node, index);
+    return index;
+};
+/**
+ * Properties in reverse source order that can affect `key`. For an exact key,
+ * another static name only updates bookkeeping for that other name, which
+ * this key never reads, so only same-name and key-independent entries remain.
+ */
+const relevantPropertiesInReverse = (node, key) => {
+    if (typeof key !== "string" && typeof key !== "number")
+        return [...node.properties].reverse();
+    const { keyIndependent, byName } = objectPropertyIndex(node);
+    const named = byName.get(String(key)) ?? [];
+    const relevant = [];
+    let left = keyIndependent.length - 1;
+    let right = named.length - 1;
+    while (left >= 0 || right >= 0) {
+        const fromLeft = right < 0 ||
+            (left >= 0 && (keyIndependent[left] ?? -1) > (named[right] ?? -1));
+        const position = fromLeft ? keyIndependent[left--] : named[right--];
+        const property = position === undefined ? undefined : node.properties[position];
+        if (property !== undefined)
+            relevant.push(property);
     }
-    return references;
+    return relevant;
 };
+export const semanticObjectPropertyReferences = (node, path, state) => {
+    const query = new SemanticGetterQuery(state);
+    return query.run(() => objectPropertyReferences(node, path, query), (job) => expandGetterResult(job, query));
+};
+class ObjectReferenceWalk {
+    node;
+    query;
+    #references = [];
+    #overwritten = new Set();
+    #data = new Set();
+    #accessors = new Set();
+    #getters = new Set();
+    #setters = new Set();
+    #key;
+    #remaining;
+    constructor(node, path, query) {
+        this.node = node;
+        this.query = query;
+        [this.#key, ...this.#remaining] = path;
+    }
+    #spreadKey() {
+        const selected = this.#key ?? null;
+        return typeof selected !== "object"
+            ? selected
+            : {
+                ...selected,
+                excludedKeys: [
+                    ...new Set([
+                        ...(selected?.excludedKeys ?? []),
+                        ...this.#overwritten,
+                    ]),
+                ].sort(compareUnicodeCodePoints),
+            };
+    }
+    #spread(property) {
+        const selected = this.#key ?? null;
+        if (typeof selected !== "object" && this.#overwritten.has(String(selected)))
+            return;
+        this.#references.push({
+            node: property.argument,
+            path: [this.#spreadKey(), ...this.#remaining],
+        });
+        if (selected !== null &&
+            typeof selected !== "object" &&
+            t.isObjectExpression(property.argument) &&
+            objectExpressionDefinesKey(property.argument, String(selected))) {
+            this.#overwritten.add(String(selected));
+            this.#data.add(String(selected));
+        }
+    }
+    #prototype(property, name) {
+        if (!t.isObjectProperty(property) ||
+            property.computed ||
+            property.shorthand ||
+            name !== "__proto__")
+            return false;
+        const selected = this.#key ?? null;
+        if (t.isExpression(property.value) &&
+            (selected === null ||
+                typeof selected === "object" ||
+                (typeof selected === "string" &&
+                    !objectExpressionDefinesKey(this.node, selected))))
+            this.#references.push({
+                node: property.value,
+                path: [selected, ...this.#remaining],
+            });
+        return true;
+    }
+    #read(property, name) {
+        if (name !== null &&
+            !semanticPropertyPathKeyMatches(this.#key ?? null, name))
+            return;
+        if (t.isObjectMethod(property)) {
+            if (property.kind === "get")
+                this.query.schedule({ getter: property, owner: this.node }, this.#remaining);
+            // A paired getter remains readable even when its setter appears later.
+            if (property.kind === "get" || property.kind === "set")
+                return;
+        }
+        this.#references.push({
+            node: t.isObjectProperty(property) ? property.value : property,
+            path: this.#remaining,
+        });
+    }
+    #record(name, kind) {
+        this.#overwritten.add(name);
+        if (kind === "data")
+            this.#data.add(name);
+        else {
+            this.#accessors.add(name);
+            (kind === "get" ? this.#getters : this.#setters).add(name);
+        }
+    }
+    #visit(property) {
+        if (t.isSpreadElement(property)) {
+            this.#spread(property);
+            return;
+        }
+        const name = semanticStaticPropertyKey(property.key, property.computed);
+        if (this.#prototype(property, name))
+            return;
+        const kind = t.isObjectMethod(property) && property.kind !== "method"
+            ? property.kind
+            : "data";
+        if (name !== null &&
+            (kind === "data"
+                ? this.#data.has(name) || this.#accessors.has(name)
+                : this.#data.has(name) ||
+                    (kind === "get" ? this.#getters : this.#setters).has(name)))
+            return;
+        this.#read(property, name);
+        if (name !== null)
+            this.#record(name, kind);
+    }
+    run() {
+        for (const property of relevantPropertiesInReverse(this.node, this.#key))
+            this.#visit(property);
+        return this.#references;
+    }
+}
+const objectPropertyReferences = (node, path, query) => new ObjectReferenceWalk(node, path, query).run();
 const objectExpressionDefinesKey = (root, key) => {
     const pending = [root];
     const seen = new Set();