@geastack/compiler 1.0.15

package/dist/targets/cpp/reactive-dependencies.js

@@ -0,0 +1,432 @@
+import { classMemberOf } from '../../projection/fields.js';
+import { operandsOfIrOperation } from '../../ir/queries.js';
+import { fieldDeclaringStructOf, structNameOfReceiver } from './class-layout.js';
+const operationsByResult = (body) => {
+    const byResult = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            const result = 'result' in operation ? operation.result : null;
+            if (result)
+                byResult.set(result.id, operation);
+        }
+    }
+    return byResult;
+};
+/**
+ * Every value in this body that can reach a BRANCH condition.
+ *
+ * The backward slice a node child's dependency narrowing is cut along. A read
+ * that reaches a branch selects which subtree the body produces; a read that
+ * only flows into a value the body hands onward does not, and -- when the body
+ * is a component whose own JSX binds that value -- the caller re-running is
+ * the one thing that cannot be justified by it. Conservative in the safe
+ * direction: a `get`'s receiver is walked too, and an argument of a call whose
+ * result reaches a branch counts as reaching it.
+ */
+const branchInfluencedValues = (body) => {
+    const byResult = operationsByResult(body);
+    const reached = new Set();
+    const pending = [];
+    const visit = (operand) => {
+        if (reached.has(operand.value))
+            return;
+        reached.add(operand.value);
+        pending.push(operand.value);
+    };
+    for (const block of body.blocks.values()) {
+        const terminator = block.terminator;
+        if (terminator.kind === 'branch')
+            visit(terminator.condition);
+        else if (terminator.kind === 'switch') {
+            visit(terminator.discriminant);
+            for (const branch of terminator.cases)
+                visit(branch.test);
+        }
+    }
+    while (pending.length > 0) {
+        const value = pending.pop();
+        const operation = byResult.get(value);
+        if (!operation)
+            continue;
+        for (const operand of operandsOfIrOperation(operation))
+            visit(operand);
+    }
+    return reached;
+};
+const dependenciesOfBody = (body, classes, reactive) => {
+    const byResult = operationsByResult(body);
+    const influenced = branchInfluencedValues(body);
+    const found = [];
+    const at = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind !== 'get')
+                continue;
+            const receiver = operation.receiver.representation;
+            const keyOperation = byResult.get(operation.key.value);
+            if (!keyOperation || keyOperation.kind !== 'constant')
+                continue;
+            const key = keyOperation.text;
+            // A class resolves the DECLARING struct along its inheritance chain; a
+            // record -- an element of a reactive array -- is its own declaring
+            // struct. Both end at the struct name a member pointer must name, which
+            // is what the reactive plan is keyed by, and both are one function.
+            const declaring = fieldDeclaringStructOf(classes, receiver, key);
+            if (declaring === null)
+                continue;
+            const revision = reactive.revisions.get(declaring)?.has(key) === true;
+            if (!revision && reactive.celled.get(declaring)?.has(key) !== true)
+                continue;
+            const receiverOperation = byResult.get(operation.receiver.value);
+            const source = receiverOperation?.kind === 'binding-read'
+                ? { kind: 'binding', declaration: receiverOperation.declaration }
+                : receiverOperation?.kind === 'receiver'
+                    ? { kind: 'receiver' }
+                    : null;
+            if (!source)
+                continue;
+            const structural = influenced.has(operation.result.id);
+            const token = `${declaring}|${key}|${source.kind}|${source.kind === 'binding' ? source.declaration : ''}`;
+            const existing = at.get(token);
+            if (existing !== undefined) {
+                // The same field read twice: structural if EITHER read is. One read
+                // that steers a branch is enough to make the field select structure.
+                if (structural && !found[existing].structural)
+                    found[existing] = { ...found[existing], structural: true };
+                continue;
+            }
+            at.set(token, found.length);
+            found.push({ dependency: { struct: declaring, key, revision, source }, structural });
+        }
+    }
+    return found;
+};
+const tokenOf = (dependency) => `${dependency.struct}|${dependency.key}|${dependency.source.kind}|${dependency.source.kind === 'binding' ? dependency.source.declaration : ''}`;
+/**
+ * One callee dependency as the CALLER owns it, or `null` when the caller has no
+ * expression for its owner.
+ *
+ * A `binding` source survives unchanged: it names a module-scope cell by a
+ * global C++ name, and that name is the same one in every frame. A `receiver`
+ * source is the callee's `this`, which the caller knows only as whatever it
+ * passed -- so it is re-pointed through that operand under the SAME two shapes
+ * `dependenciesOfBody` accepts for a read of its own, and refused otherwise.
+ */
+const throughReceiver = (dependency, receiver, byResult) => {
+    if (dependency.source.kind === 'binding')
+        return dependency;
+    if (!receiver)
+        return null;
+    const receiverOperation = byResult.get(receiver.value);
+    if (receiverOperation?.kind === 'binding-read') {
+        return { ...dependency, source: { kind: 'binding', declaration: receiverOperation.declaration } };
+    }
+    if (receiverOperation?.kind === 'receiver')
+        return { ...dependency, source: { kind: 'receiver' } };
+    return null;
+};
+/**
+ * Every body this one enters with a receiver it names, as (callee, receiver)
+ * edges for the closure below.
+ *
+ * TWO shapes, and the second is the one that matters here. A `call` whose
+ * callee this IR closed is the obvious edge. An ACCESSOR read is not a call in
+ * the IR at all -- `{reader.pageNumberLabel}` is a `get`, and it is
+ * `emit-class-properties.ts` that renders it as a call of the getter's body
+ * (`site.accessor.getter`) -- so a walk that looked only for `call` would miss
+ * every getter in the program, which is exactly the shape a computed JSX slot
+ * takes. The resolution asked here is `classMemberOf`, the same authority that
+ * emitter uses, rather than a second reading of the layout.
+ */
+const receiverEdgesOf = (body, classes) => {
+    const edges = [];
+    const byResult = operationsByResult(body);
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'call') {
+                const closed = operation.closedCallee;
+                if (closed && closed.kind === 'exact')
+                    edges.push({
+                        callee: closed.functionId,
+                        receiver: operation.receiver,
+                        lifted: byResult.get(operation.callee.value)?.kind === 'allocate-callable'
+                    });
+                continue;
+            }
+            if (operation.kind !== 'get')
+                continue;
+            const receiver = operation.receiver.representation;
+            if (receiver.kind !== 'class-ref')
+                continue;
+            const keyOperation = byResult.get(operation.key.value);
+            if (!keyOperation || keyOperation.kind !== 'constant')
+                continue;
+            const site = classMemberOf(classes, receiver.declaration, keyOperation.text);
+            if (site === null || site.kind !== 'accessor' || site.accessor.getter === null)
+                continue;
+            edges.push({ callee: site.accessor.getter, receiver: operation.receiver, lifted: false });
+        }
+    }
+    return edges;
+};
+/**
+ * A seed grown to a fixed point over the call graph.
+ *
+ * Two passes rather than one recursion: a call graph with a cycle (a getter
+ * reading another getter that reads it back) has no bottom to recurse from,
+ * and a monotone worklist over a finite set of (owner, dependency) pairs simply
+ * terminates.
+ */
+const closeOverCalls = (seed, calls, results, callers, admits) => {
+    const grown = new Map();
+    const tokens = new Map();
+    for (const [owner, dependencies] of seed) {
+        grown.set(owner, [...dependencies]);
+        tokens.set(owner, new Set(dependencies.map(tokenOf)));
+    }
+    const pending = [...grown.keys()];
+    while (pending.length > 0) {
+        const callee = pending.pop();
+        const calleeDependencies = grown.get(callee);
+        if (!calleeDependencies || calleeDependencies.length === 0)
+            continue;
+        for (const caller of callers.get(callee) ?? []) {
+            const own = grown.get(caller);
+            const seen = tokens.get(caller);
+            const byResult = results.get(caller);
+            if (!own || !seen || !byResult)
+                continue;
+            let grew = false;
+            for (const call of calls.get(caller) ?? []) {
+                if (call.callee !== callee || !admits(call))
+                    continue;
+                for (const dependency of calleeDependencies) {
+                    const carried = throughReceiver(dependency, call.receiver, byResult);
+                    if (!carried)
+                        continue;
+                    const token = tokenOf(carried);
+                    if (seen.has(token))
+                        continue;
+                    seen.add(token);
+                    own.push(carried);
+                    grew = true;
+                }
+            }
+            if (grew)
+                pending.push(caller);
+        }
+    }
+    return grown;
+};
+export const reactiveDependenciesOfBodies = (bodies, classes, reactive) => {
+    const empty = new Map();
+    if (reactive.cell === null || (reactive.celled.size === 0 && reactive.revisions.size === 0))
+        return { all: empty, node: empty };
+    const direct = new Map();
+    const directStructural = new Map();
+    const calls = new Map();
+    const results = new Map();
+    const callers = new Map();
+    for (const body of bodies) {
+        const owner = body.sourceOwner;
+        const found = dependenciesOfBody(body, classes, reactive);
+        direct.set(owner, found.map((entry) => entry.dependency));
+        directStructural.set(owner, found.filter((entry) => entry.structural).map((entry) => entry.dependency));
+        results.set(owner, operationsByResult(body));
+        const bodyCalls = receiverEdgesOf(body, classes);
+        calls.set(owner, bodyCalls);
+        for (const call of bodyCalls) {
+            const existing = callers.get(call.callee);
+            if (existing)
+                existing.add(owner);
+            else
+                callers.set(call.callee, new Set([owner]));
+        }
+    }
+    const bound = (edge) => !edge.lifted;
+    const all = closeOverCalls(direct, calls, results, callers, () => true);
+    const structural = closeOverCalls(directStructural, calls, results, callers, bound);
+    // The node census: this body's own reads, plus only what its callees BRANCH
+    // on. Assembled here rather than by a third closure because it is not a
+    // fixed point -- it is one step out of `structural`, which already is one.
+    const node = new Map();
+    for (const [owner, own] of direct) {
+        const merged = [...own];
+        const seen = new Set(merged.map(tokenOf));
+        const byResult = results.get(owner);
+        if (!byResult)
+            continue;
+        for (const call of calls.get(owner) ?? []) {
+            if (!bound(call))
+                continue;
+            for (const dependency of structural.get(call.callee) ?? []) {
+                const carried = throughReceiver(dependency, call.receiver, byResult);
+                if (!carried)
+                    continue;
+                const token = tokenOf(carried);
+                if (seen.has(token))
+                    continue;
+                seen.add(token);
+                merged.push(carried);
+            }
+        }
+        if (merged.length > 0)
+            node.set(owner, merged);
+    }
+    const allByOwner = new Map();
+    for (const [owner, dependencies] of all) {
+        if (dependencies.length > 0)
+            allByOwner.set(owner, dependencies);
+    }
+    return { all: allByOwner, node };
+};
+/**
+ * Which RECORD fields a JSX site actually binds, keyed by struct name.
+ *
+ * The elements of a reactive array are only worth celling when a rendered row
+ * reads them -- `records.ts` cells exactly this set. Celling every element
+ * record of every array field instead is not merely wasteful, it is wrong:
+ * `Signal<T>` is not the field's declared carrier, so a struct that is also
+ * read by something carrier-sensitive stops compiling. `gea-bench` holds both
+ * `rows` (rendered) and `items` (parsed out of JSON), and celling `Item.id`
+ * made `gea_json_read(reader, out.id)` an error -- a real defect found by the
+ * corpus, not a hypothetical.
+ *
+ * Two shapes reach a JSX slot, and both are recorded:
+ *
+ *   - a DIRECT read -- `id={cell.id}` -- whose `get` result is the operand of
+ *     an `element-prop`/`element-child`, possibly through the record that a
+ *     `style={{...}}` object is built up as.
+ *   - a THUNK read -- `width={cell.filled ? a : b}`, which
+ *     `plugins/gea/reactive-slots.ts` rewrites to an immediately-called arrow.
+ *     The operand is then the CALL, and the fields live in the callee's own
+ *     body, which is a separate `IrBody`. The callee is recognised by its
+ *     `allocate-callable` defining the callee operand -- the shape only an
+ *     IIFE has -- and its body is swept in a second pass.
+ *
+ * Deliberately computed WITHOUT consulting `ReactiveCellPlan.celled`: that map
+ * is derived from this one, so asking it here would be a cycle. This answers
+ * the prior question -- what does the program bind -- and celling follows.
+ */
+export const reactiveBoundRecordFields = (bodies) => {
+    const bound = new Map();
+    const thunks = new Set();
+    const noteRead = (operation, byResult) => {
+        if (operation.kind !== 'get')
+            return;
+        // Only RECORD receivers. A class field is celled by the plugin's own
+        // `ReactiveCellPlan.fields`, which states the component's reactive members
+        // directly; this map exists solely to narrow the ELEMENT records derived
+        // from those fields.
+        const representation = operation.receiver.representation;
+        if (representation.kind !== 'record' && representation.kind !== 'native-record-ref')
+            return;
+        const struct = structNameOfReceiver(representation);
+        const keyOperation = byResult.get(operation.key.value);
+        if (struct === null || !keyOperation || keyOperation.kind !== 'constant')
+            return;
+        const keys = bound.get(struct) ?? new Set();
+        keys.add(keyOperation.text);
+        bound.set(struct, keys);
+    };
+    const noteThunk = (operation, byResult) => {
+        if (operation.kind !== 'call')
+            return;
+        const callee = byResult.get(operation.callee.value);
+        if (callee && callee.kind === 'allocate-callable')
+            thunks.add(callee.functionId);
+    };
+    // Which values a `style={{...}}` record is built out of. The members of an
+    // object literal in a JSX attribute do not arrive as `allocate-record`
+    // fields -- they are installed as separate stores onto the allocated result
+    // -- so reaching them means following the receiver, not the constructor.
+    const storedInto = (body) => {
+        const byReceiver = new Map();
+        for (const block of body.blocks.values()) {
+            for (const operation of block.operations) {
+                if (operation.kind !== 'set' && operation.kind !== 'define-own-property')
+                    continue;
+                const target = byReceiver.get(operation.receiver.value) ?? [];
+                target.push(operation.value.value);
+                byReceiver.set(operation.receiver.value, target);
+            }
+        }
+        return byReceiver;
+    };
+    // Pass one: what each body binds DIRECTLY into a JSX slot, and which thunks
+    // those slots call.
+    for (const body of bodies) {
+        const byResult = operationsByResult(body);
+        const stores = storedInto(body);
+        const queue = [];
+        for (const block of body.blocks.values()) {
+            for (const operation of block.operations) {
+                if (operation.kind === 'element-prop')
+                    queue.push(operation.value.value);
+                else if (operation.kind === 'element-child')
+                    queue.push(operation.child.value);
+            }
+        }
+        const seen = new Set();
+        while (queue.length > 0) {
+            const value = queue.pop();
+            if (value === undefined || seen.has(value))
+                continue;
+            seen.add(value);
+            for (const stored of stores.get(value) ?? [])
+                queue.push(stored);
+            const operation = byResult.get(value);
+            if (!operation)
+                continue;
+            noteRead(operation, byResult);
+            noteThunk(operation, byResult);
+            if (operation.kind === 'allocate-record')
+                for (const field of operation.fields)
+                    queue.push(field.value.value);
+            // A store THREADS its receiver: `style={{a, b}}` is
+            // `allocate-record -> v29`, `set(v29,'a') -> v30`, `set(v30,'b') -> v31`,
+            // and the attribute's operand is v31. Reaching the members means walking
+            // back down that chain -- taking each store's own value AND its receiver
+            // -- not looking up v31 as a receiver, which it never is.
+            if (operation.kind === 'set' || operation.kind === 'define-own-property') {
+                queue.push(operation.value.value);
+                queue.push(operation.receiver.value);
+            }
+            // A carrier change is not a new value. Since lowering owns conversions,
+            // a thunk call whose `double` lands in a style member's
+            // `Optional<double>` is a `convert` between the call and the store, and
+            // stopping here left the call unseen: the thunk was never swept, the
+            // fields it reads were never bound, and so never celled -- every row of
+            // button-tetris's settled stack rendered once and a locked piece
+            // vanished, while the `key={cell.id}` read beside it, which needs no
+            // conversion, was celled as before.
+            if (operation.kind === 'convert')
+                queue.push(operation.source.value);
+        }
+    }
+    // Pass two: a thunk's whole body is its dependency set -- every field it
+    // reads is one the slot re-reads when it re-runs -- so there is nothing to
+    // trace inside it. Repeated to a fixpoint because a thunk can call another
+    // (a style member's slot inside a row's slot), and a callee's body may sit
+    // anywhere in `bodies` relative to its caller's.
+    const swept = new Set();
+    for (;;) {
+        let grew = false;
+        for (const body of bodies) {
+            if (!thunks.has(body.sourceOwner) || swept.has(body.sourceOwner))
+                continue;
+            swept.add(body.sourceOwner);
+            grew = true;
+            const byResult = operationsByResult(body);
+            for (const block of body.blocks.values()) {
+                for (const operation of block.operations) {
+                    noteRead(operation, byResult);
+                    noteThunk(operation, byResult);
+                }
+            }
+        }
+        if (!grew)
+            break;
+    }
+    return bound;
+};

package/dist/targets/cpp/reactive-origins.d.ts

@@ -0,0 +1,44 @@
+import type { IrBody } from '../../ir/model.js';
+import type { DeclarationId, IrValueId } from '../../identity/ids.js';
+import type { EmitContext, ReactiveRevisionOrigin } from './emit-context.js';
+export interface ReactiveOrigins {
+    readonly origins: ReadonlyMap<IrValueId, ReactiveRevisionOrigin>;
+    readonly bindingOrigins: ReadonlyMap<DeclarationId, ReactiveRevisionOrigin>;
+    readonly fieldReads: ReadonlyMap<IrValueId, ReactiveRevisionOrigin>;
+}
+/**
+ * Which values in one body carry a reactive revision cell, and which reads owe
+ * a subscription -- settled before the body renders a line.
+ *
+ * Distinct from `reactive-dependencies.ts`, which answers a whole-program
+ * question for the JSX caller (which fields does this THUNK read, and through
+ * what nameable owner). This is the per-body flow: which SSA values in THIS
+ * body came out of reactive state, so that a store through one of them ticks
+ * the right cell.
+ *
+ * The channel used to be five render-time side effects: two seeds inside
+ * resolvers deep in the get ladder, and three relays (`emitGet`,
+ * `arrayMemberText`, `emitBindingRead`/`emitBindingWrite`) that copied an
+ * origin from one value to the next as each happened to render. That made the
+ * printer's own visiting order the authority over a dataflow fact, and it made
+ * the seeds conditional on which rung of the ladder answered the access --
+ * exactly the way a fact goes missing.
+ *
+ * The seeds are now two claims (`reactiveClassFieldClaim`,
+ * `reactiveRecordFieldClaim`) living with the layout each asks about, and this
+ * is their single walk. The relay is stated once, here: an origin is a property
+ * of the VALUE, so anything read THROUGH a value that came out of reactive
+ * array state keeps that state's revision cell -- `this.cells[i]` is the
+ * element, `cell.color` is a field of it, and a write to either has to tick the
+ * same cell. It survives the local a program parks it in, which is what the
+ * binding pair carries.
+ *
+ * Deliberately ONE forward pass in `blockOrder`, not a fixed point. A fixed
+ * point is the stronger dataflow answer and would additionally reach a binding
+ * whose only write is later in the body than its read -- around a loop back
+ * edge, say. That is a real difference in what gets subscribed, so it is a
+ * change to make on its own evidence and gate on its own, not something to
+ * smuggle in under a refactor whose whole claim is that the emitted set does
+ * not move.
+ */
+export declare const reactiveOriginsOf: (ctx: EmitContext, body: IrBody) => ReactiveOrigins;

package/dist/targets/cpp/reactive-origins.js

@@ -0,0 +1,82 @@
+import { allOperationsOf } from '../../ir/model.js';
+import { reactiveClassFieldClaim } from './class-properties/emit-class-properties.js';
+import { reactiveRecordFieldClaim } from './emit-properties.js';
+/**
+ * Which values in one body carry a reactive revision cell, and which reads owe
+ * a subscription -- settled before the body renders a line.
+ *
+ * Distinct from `reactive-dependencies.ts`, which answers a whole-program
+ * question for the JSX caller (which fields does this THUNK read, and through
+ * what nameable owner). This is the per-body flow: which SSA values in THIS
+ * body came out of reactive state, so that a store through one of them ticks
+ * the right cell.
+ *
+ * The channel used to be five render-time side effects: two seeds inside
+ * resolvers deep in the get ladder, and three relays (`emitGet`,
+ * `arrayMemberText`, `emitBindingRead`/`emitBindingWrite`) that copied an
+ * origin from one value to the next as each happened to render. That made the
+ * printer's own visiting order the authority over a dataflow fact, and it made
+ * the seeds conditional on which rung of the ladder answered the access --
+ * exactly the way a fact goes missing.
+ *
+ * The seeds are now two claims (`reactiveClassFieldClaim`,
+ * `reactiveRecordFieldClaim`) living with the layout each asks about, and this
+ * is their single walk. The relay is stated once, here: an origin is a property
+ * of the VALUE, so anything read THROUGH a value that came out of reactive
+ * array state keeps that state's revision cell -- `this.cells[i]` is the
+ * element, `cell.color` is a field of it, and a write to either has to tick the
+ * same cell. It survives the local a program parks it in, which is what the
+ * binding pair carries.
+ *
+ * Deliberately ONE forward pass in `blockOrder`, not a fixed point. A fixed
+ * point is the stronger dataflow answer and would additionally reach a binding
+ * whose only write is later in the body than its read -- around a loop back
+ * edge, say. That is a real difference in what gets subscribed, so it is a
+ * change to make on its own evidence and gate on its own, not something to
+ * smuggle in under a refactor whose whole claim is that the emitted set does
+ * not move.
+ */
+export const reactiveOriginsOf = (ctx, body) => {
+    const origins = new Map();
+    const bindingOrigins = new Map();
+    const fieldReads = new Map();
+    for (const blockId of body.blockOrder) {
+        const block = body.blocks.get(blockId);
+        if (block === undefined)
+            continue;
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind === 'get') {
+                // The relay runs BEFORE the seeds: a field that is itself reactive
+                // state names its own cell, and that outranks the one it was reached
+                // through -- `cell.filled = 1` notifies the props that read that field,
+                // not every row of the list the cell belongs to.
+                const inherited = origins.get(operation.receiver.value);
+                if (inherited !== undefined)
+                    origins.set(operation.result.id, inherited);
+                const classField = reactiveClassFieldClaim(ctx, operation);
+                if (classField !== null) {
+                    if (classField.kind === 'revision')
+                        origins.set(operation.result.id, classField.origin);
+                    else
+                        fieldReads.set(operation.result.id, classField.origin);
+                }
+                const recordField = reactiveRecordFieldClaim(ctx, operation);
+                if (recordField !== null)
+                    fieldReads.set(operation.result.id, recordField);
+                continue;
+            }
+            if (operation.kind === 'binding-read') {
+                const origin = bindingOrigins.get(operation.declaration);
+                if (origin !== undefined)
+                    origins.set(operation.result.id, origin);
+                continue;
+            }
+            if (operation.kind === 'binding-write') {
+                const written = origins.get(operation.value.value);
+                if (written !== undefined)
+                    bindingOrigins.set(operation.declaration, written);
+            }
+        }
+    }
+    return { origins, bindingOrigins, fieldReads };
+};