rea-agents 6.5.0 → 6.7.0

package/dist/domain/javascript/javascriptSemanticObjectReferences.js

@@ -1,11 +1,10 @@
 import * as t from "@babel/types";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
-import { semanticCallableResultExpressions } from "./javascriptSemanticCallableResults.js";
-import { semanticReadInitializers } from "./javascriptSemanticMutationInitializers.js";
-import { semanticReferenceSourcesInactive } from "./javascriptSemanticReferenceSources.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();
@@ -157,48 +156,75 @@ const classPropertyDescriptors = (klass, propertyName, kind, initializedBefore)
         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, lookup.initializedBefore);
-        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, lookup.initializedBefore);
+    #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 lookup.fieldsOnly ? [] : 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.
@@ -257,6 +283,9 @@ const objectReceiverReference = (object, path, state) => {
     }
     return [{ node: object, path }];
 };
+// 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"))
@@ -344,306 +373,190 @@ const privateReceiverProjection = (receiver, owner, path, isStatic, state) => {
     }
     return false;
 };
-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 pending = semanticCallableResultExpressions(getter).flatMap(({ node }) => node === null ? [] : [{ node, path, aliases: undefined }]);
-    const references = [];
-    const expandedAliases = new Map();
-    const getterScope = state.scopeByNode.get(getter)?.scopeId;
-    for (let cursor = 0; cursor < pending.length; cursor++) {
-        const current = pending[cursor];
-        if (current === undefined)
-            break;
-        const { path: remaining } = current;
-        const expression = unwrapJavaScriptExpression(current.node).node;
-        const retain = (reference) => {
-            references.push(current.escapes ? { ...reference, escapes: true } : reference);
-        };
-        const retainPrivateRead = () => {
-            if (current.privateRead !== undefined)
-                retain({
-                    node: current.privateRead.node,
-                    path: current.escapes ? [] : current.privateRead.path,
-                });
-        };
-        if (t.isIdentifier(expression)) {
-            const binding = resolveSemanticBindingState(state, expression, expression.name);
-            let scope = binding === undefined
-                ? undefined
-                : state.scopesById.get(binding.scopeId);
-            while (scope !== undefined && scope.scopeId !== getterScope) {
-                if (scope.kind === "function" || scope.parentScopeId === null) {
-                    scope = undefined;
-                    break;
-                }
-                scope = state.scopesById.get(scope.parentScopeId);
-            }
-            if (binding !== undefined &&
-                scope !== undefined &&
-                binding.referenceInitializers.every((initializer) => initializer.copyKind === undefined)) {
-                const identity = JSON.stringify([
-                    binding.bindingId,
-                    expression.start,
-                    expression.end,
-                ]);
-                const known = expandedAliases.get(identity);
-                const key = JSON.stringify([
-                    remaining,
-                    current.privateRead?.name,
-                    current.privateRead?.path,
-                    current.escapes,
-                ]);
-                let cyclic = false;
-                let growing = false;
-                if (known !== undefined)
-                    for (let visit = current.aliases; visit !== undefined; visit = visit.parent)
-                        if (visit.identity === identity) {
-                            cyclic = true;
-                            growing = remaining.length > visit.pathLength;
-                            break;
-                        }
-                if (cyclic) {
-                    // A repeated alias can select arbitrarily deep children. Revisit its
-                    // roots as escapes rather than enumerating iterations or dropping them.
-                    if (growing && !current.escapes)
-                        pending.push({
-                            ...current,
-                            path: [],
-                            aliases: undefined,
-                            escapes: true,
-                        });
-                    continue;
-                }
-                if (known?.has(key))
-                    continue;
-                const selections = known ?? new Set();
-                selections.add(key);
-                expandedAliases.set(identity, selections);
-                const aliases = {
-                    identity,
-                    pathLength: remaining.length,
-                    parent: current.aliases,
-                };
-                const origins = semanticReadInitializers(binding, expression, state.parentsByNode);
-                for (const initializer of [
-                    ...origins.initializers,
-                    ...origins.referenceInitializers.filter((initializer) => !semanticReferenceSourcesInactive(initializer, state)),
-                ])
-                    pending.push({
-                        ...current,
-                        node: initializer.node,
-                        path: [...initializer.projection, ...remaining],
-                        aliases,
-                    });
-                continue;
-            }
+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__")) {
+            keyIndependent.push(index);
+            return;
         }
-        if (t.isThisExpression(expression)) {
-            // An outer binding or a nested ordinary function has a different receiver.
-            let ownerNode = state.parentsByNode.get(expression);
-            while (ownerNode !== undefined &&
-                !t.isClass(ownerNode) &&
-                !(t.isFunction(ownerNode) && !t.isArrowFunctionExpression(ownerNode)))
-                ownerNode = state.parentsByNode.get(ownerNode);
-            if (ownerNode !== getter)
-                continue;
-            if (current.privateRead !== undefined && t.isClass(owner)) {
-                if (!t.isClass(receiver) ||
-                    !privateReceiverProjection(receiver, owner, remaining, isStatic, state)) {
-                    retainPrivateRead();
-                    continue;
-                }
-                for (const member of owner.body.body)
-                    if (t.isClassPrivateProperty(member) &&
-                        member.static === isStatic &&
-                        member.key.id.name === current.privateRead.name &&
-                        member.value != null)
-                        retain({
-                            node: member.value,
-                            path: current.escapes ? [] : current.privateRead.path,
-                        });
-                continue;
-            }
-            for (const reference of t.isClass(receiver)
-                ? semanticClassPropertyReferences({ owner: receiver, kind: isStatic ? "static" : "instance" }, remaining, state, active)
-                : objectReceiverReference(receiver, remaining, state))
-                retain(reference);
-            continue;
+        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 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));
         }
-        if (t.isMemberExpression(expression) ||
-            t.isOptionalMemberExpression(expression)) {
-            if (current.privateRead !== undefined &&
-                t.isPrivateName(expression.property)) {
-                retainPrivateRead();
-                continue;
-            }
-            if (t.isPrivateName(expression.property) && t.isClass(owner)) {
-                pending.push({
-                    ...current,
-                    node: expression.object,
-                    path: [],
-                    privateRead: {
-                        node: expression,
-                        name: expression.property.id.name,
-                        path: remaining,
-                    },
-                });
-                continue;
-            }
-            const key = semanticStaticPropertyKey(expression.property, expression.computed);
-            if (t.isSuper(expression.object) &&
-                t.isClass(owner) &&
-                owner.superClass != null) {
-                for (const base of semanticClassCandidates(owner.superClass, state))
-                    for (const reference of semanticClassPropertyReferences({
-                        owner: base,
-                        receiver: t.isClass(receiver) ? receiver : owner,
-                        kind: isStatic ? "static" : "prototype",
-                    }, [key, ...remaining], state, active))
-                        retain(reference);
-                continue;
-            }
-            pending.push({
-                ...current,
-                node: expression.object,
-                path: [key, ...remaining],
+    }
+    #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;
         }
-        else if (t.isConditionalExpression(expression))
-            pending.push({ ...current, node: expression.consequent }, { ...current, node: expression.alternate });
-        else if (t.isLogicalExpression(expression))
-            pending.push({ ...current, node: expression.left }, { ...current, node: expression.right });
-        else if (t.isSequenceExpression(expression)) {
-            const last = expression.expressions.at(-1);
-            if (last !== undefined)
-                pending.push({ ...current, node: last });
+        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);
         }
-        else if (t.isAssignmentExpression(expression, { operator: "=" }))
-            pending.push({ ...current, node: expression.right });
-        else if (t.isAssignmentExpression(expression) &&
-            ["&&=", "||=", "??="].includes(expression.operator))
-            pending.push({ ...current, node: expression.left }, { ...current, node: expression.right });
-        else if (current.privateRead !== undefined)
-            retainPrivateRead();
-        else
-            retain({ node: expression, path: remaining });
     }
-    return references;
-};
-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()) {
+    #visit(property) {
         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));
-            }
-            continue;
+            this.#spread(property);
+            return;
         }
         const name = semanticStaticPropertyKey(property.key, property.computed);
-        if (t.isObjectProperty(property) &&
-            !property.computed &&
-            !property.shorthand &&
-            name === "__proto__") {
-            const selected = key ?? null;
-            if ((selected === null || typeof selected === "object") &&
-                t.isExpression(property.value)) {
-                references.push({
-                    node: property.value,
-                    path: [selected, ...remaining],
-                });
-            }
-            else if (typeof selected === "string" &&
-                !objectExpressionDefinesKey(node, selected) &&
-                t.isExpression(property.value)) {
-                references.push({
-                    node: property.value,
-                    path: [selected, ...remaining],
-                });
-            }
-            continue;
-        }
-        const isGetter = t.isObjectMethod(property) && property.kind === "get";
-        const isSetter = t.isObjectMethod(property) && property.kind === "set";
+        if (this.#prototype(property, name))
+            return;
+        const kind = t.isObjectMethod(property) && property.kind !== "method"
+            ? property.kind
+            : "data";
         if (name !== null &&
-            (isGetter || isSetter
-                ? dataOverwritten.has(name) ||
-                    (isGetter ? getterNames.has(name) : setterNames.has(name))
-                : dataOverwritten.has(name) || accessorNames.has(name)))
-            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,
-                });
-            }
-        }
-        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) &&
-                !property.computed &&
-                !property.shorthand &&
-                name === "__proto__")) {
-                overwritten.add(name);
-                dataOverwritten.add(name);
-            }
-        }
+            (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);
     }
-    return references;
-};
+    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();