@geastack/compiler 1.0.15

package/dist/ir/class-static-fields.js

@@ -0,0 +1,108 @@
+import { classStaticMemberOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+/**
+ * Which class of a `constructor-family`'s members owns `key`'s static storage.
+ *
+ * The one selection rule, so the census and every later lookup name the same
+ * class for the same receiver. A key no static member declares is the
+ * assignment-only idiom and belongs to the first member that could hold it. A
+ * declared static FIELD has the same storage requirement, since its
+ * class-lifecycle event has already become an ordinary `set` at the exact
+ * evaluation point. Methods and accessors remain callable members and must not
+ * acquire a second storage location.
+ */
+export const staticFieldOwnerOf = (classes, members, key) => {
+    const member = members.find((candidate) => {
+        if (!classes.has(candidate))
+            return false;
+        const site = classStaticMemberOf(classes, candidate, key);
+        return site === null || site.kind === 'field';
+    });
+    // Through `staticOwner`: the physical layouts of one generic are several
+    // structs and ONE constructor object, so `Box.count` is one cell whether it
+    // is written inside `Box<number>`'s constructor, inside `Box<string>`'s,
+    // or through the class binding itself. Keying storage on the struct would
+    // give one `count` per layout, and `Box.count` would read whichever the
+    // last write happened to land in.
+    return member === undefined ? undefined : staticStorageOwnerOf(classes, member);
+};
+/** The class one class's static storage lives in: itself, or the generic root whose layouts it is one of. */
+export const staticStorageOwnerOf = (classes, declaration) => classes.get(declaration)?.staticOwner ?? declaration;
+/** The carrier `ClassName.KEY` is stored in, or null when the census proved none. */
+export const staticFieldSlotOf = (census, classes, members, key) => {
+    const owner = staticFieldOwnerOf(classes, members, key);
+    return owner === undefined ? null : (census.slots.get(owner)?.get(key) ?? null);
+};
+export const censusClassStaticFieldSlots = (bodies, classes) => {
+    const byDeclaration = new Map();
+    const conflicts = new Set();
+    const declaredFields = new Set();
+    for (const [declaration, layout] of classes) {
+        // Keyed by the storage owner, which for one physical layout of a generic
+        // is the root every layout shares; the layouts carry identical static
+        // members, so the repeats agree by construction.
+        const owner = staticStorageOwnerOf(classes, declaration);
+        for (const field of layout.staticFields) {
+            if (field.representation === null || field.representation.kind === 'unresolved' || field.representation.kind === 'void')
+                continue;
+            const perClass = byDeclaration.get(owner) ?? new Map();
+            byDeclaration.set(owner, perClass);
+            perClass.set(field.key, field.representation);
+            declaredFields.add(`${owner}.${field.key}`);
+        }
+    }
+    for (const body of bodies) {
+        // Whole-body first pass: a `constant` operation feeding a later block's
+        // key is exactly as legitimate as one in the same block, and a single
+        // forward-only scan would miss it across a back edge.
+        const constants = new Map();
+        for (const blockId of body.blockOrder) {
+            const block = body.blocks.get(blockId);
+            if (!block)
+                continue;
+            for (const operation of block.operations)
+                if (operation.kind === 'constant')
+                    constants.set(operation.result.id, operation.text);
+        }
+        for (const blockId of body.blockOrder) {
+            const block = body.blocks.get(blockId);
+            if (!block)
+                continue;
+            for (const operation of block.operations) {
+                if (operation.kind !== 'set' && operation.kind !== 'define-own-property')
+                    continue;
+                const receiver = operation.receiver.representation;
+                if (receiver.kind !== 'constructor-family')
+                    continue;
+                const key = constants.get(operation.key.value);
+                if (key === undefined)
+                    continue;
+                const declaration = staticFieldOwnerOf(classes, receiver.members, key);
+                if (declaration === undefined)
+                    continue;
+                const representation = operation.value.representation;
+                const perClass = byDeclaration.get(declaration) ?? new Map();
+                byDeclaration.set(declaration, perClass);
+                const existing = perClass.get(key);
+                const conflictId = `${declaration}.${key}`;
+                if (conflicts.has(conflictId))
+                    continue;
+                if (existing !== undefined) {
+                    // A declared field's own carrier is the storage authority. Each
+                    // write is converted against it by the property emitter; differing
+                    // source carriers such as `Uint8Array` stored into
+                    // `Uint8Array | null` are expected and do not redefine the cell.
+                    if (declaredFields.has(conflictId))
+                        continue;
+                    if (representationKey(existing) === representationKey(representation))
+                        continue;
+                    perClass.delete(key);
+                    conflicts.add(conflictId);
+                    continue;
+                }
+                perClass.set(key, representation);
+            }
+        }
+    }
+    return { slots: byDeclaration, conflicts: [...conflicts] };
+};

package/dist/ir/construct-entry.d.ts

@@ -0,0 +1,26 @@
+import type { CallableAbi, Representation } from '../representation/model.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { ConstructOperation, IrBody } from './model.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+/** The allocation owns the receiver; explicit arguments and result use its construct ABI. */
+export declare const constructMatchesAbi: (operation: ConstructOperation, abi: CallableAbi, conversions?: Pick<ConversionCensus, "nodeById">) => boolean;
+/** The class allocation supplies this receiver before entering the source constructor. */
+export declare const classConstructorBodyMatches: (layout: ClassLayout, body: IrBody) => boolean;
+/** The native ordinary construct thunk allocates its receiver and forwards
+ * the construct frame into the source body. An explicit return needs its own
+ * entry proof. A void body or an authenticated return of this preserves the
+ * allocated receiver; a matching return type alone does not prove identity. */
+export declare const ordinaryConstructBodyMatches: (operation: ConstructOperation, body: Pick<IrBody, "sourceOwner" | "abi" | "construct" | "blocks">, conversions?: Pick<ConversionCensus, "nodeById">) => boolean;
+/** Allocation and body entry must share one native receiver representation.
+ * Both provenance and the construct thunk consume this same admission. */
+export declare const nativeOrdinaryConstructInstanceMatches: (abi: CallableAbi, instance: Representation) => instance is Extract<Representation, {
+    kind: "record" | "record-with-index" | "native-record-ref";
+}>;
+/**
+ * Publish the call entry used by a receiver-free ordinary constructor that
+ * always returns an object. The semantic target authenticates [[Construct]];
+ * the carrier alone cannot distinguish ordinary functions from arrows. Both
+ * the body and the held closure must agree on the entry convention. Keeping
+ * the invocation indirect preserves the actual closure's captures.
+ */
+export declare const explicitObjectConstructEntryOf: (operation: ConstructOperation, bodyAbi: CallableAbi | null) => ConstructOperation["entry"];

package/dist/ir/construct-entry.js

@@ -0,0 +1,117 @@
+import { abiKey, representationKey } from '../representation/model.js';
+import { nativeArgumentsMatch } from './call-entry.js';
+/** The allocation owns the receiver; explicit arguments and result use its construct ABI. */
+export const constructMatchesAbi = (operation, abi, conversions) => abi.receiver === null &&
+    representationKey(operation.result.representation) === representationKey(abi.result) &&
+    nativeArgumentsMatch(abi, operation.arguments, conversions);
+/** The class allocation supplies this receiver before entering the source constructor. */
+export const classConstructorBodyMatches = (layout, body) => {
+    const abi = body.abi;
+    const construct = layout.construct;
+    return (abi !== null &&
+        abi.result.kind === 'void' &&
+        layout.instance !== null &&
+        abi.receiver !== null &&
+        representationKey(abi.receiver) === representationKey(layout.instance) &&
+        construct !== null &&
+        construct.receiver === null &&
+        abi.restFrom === construct.restFrom &&
+        abi.parameters.length === construct.parameters.length &&
+        abi.parameters.every((parameter, index) => representationKey(parameter.value) === representationKey(construct.parameters[index].value)));
+};
+/** The native ordinary construct thunk allocates its receiver and forwards
+ * the construct frame into the source body. An explicit return needs its own
+ * entry proof. A void body or an authenticated return of this preserves the
+ * allocated receiver; a matching return type alone does not prove identity. */
+export const ordinaryConstructBodyMatches = (operation, body, conversions) => {
+    const { abi, construct } = body;
+    const callee = operation.callee.representation;
+    const target = operation.target;
+    if (abi === null ||
+        construct === null ||
+        callee.kind !== 'function-and-constructor' ||
+        operation.callee.value !== operation.newTarget.value ||
+        target.kind !== 'exact' ||
+        target.target.kind !== 'function' ||
+        !target.target.constructable ||
+        target.target.functionId !== body.sourceOwner ||
+        abiKey(callee.call) !== abiKey(abi) ||
+        abiKey(callee.construct) !== abiKey(construct) ||
+        abiKey({ ...abi, receiver: null, result: construct.result }) !== abiKey(construct) ||
+        !constructMatchesAbi(operation, construct, conversions))
+        return false;
+    if (abi.result.kind !== 'void') {
+        if (abi.receiver === null || representationKey(abi.result) !== representationKey(abi.receiver))
+            return false;
+        const receivers = new Set([...body.blocks.values()].flatMap((block) => block.operations.flatMap((operation) => (operation.kind === 'receiver' ? [operation.result.id] : []))));
+        const returns = [...body.blocks.values()].flatMap((block) => (block.terminator.kind === 'return' ? [block.terminator] : []));
+        if (returns.length === 0 || returns.some((operation) => operation.value === null || !receivers.has(operation.value.value)))
+            return false;
+    }
+    return nativeOrdinaryConstructInstanceMatches(abi, construct.result);
+};
+/** Allocation and body entry must share one native receiver representation.
+ * Both provenance and the construct thunk consume this same admission. */
+export const nativeOrdinaryConstructInstanceMatches = (abi, instance) => {
+    return ((instance.kind === 'record' || instance.kind === 'record-with-index' || instance.kind === 'native-record-ref') &&
+        (instance.ownership === 'owned' || instance.ownership === 'shared-refcount') &&
+        (abi.receiver === null || representationKey(abi.receiver) === representationKey(instance)));
+};
+/** ECMA-262 ordinary [[Construct]] uses an explicit Object return instead of its receiver. */
+const alwaysReturnsObject = (representation) => {
+    switch (representation.kind) {
+        case 'array-buffer':
+        case 'shared-array-buffer':
+        case 'array-object':
+        case 'class-ref':
+        case 'constructor-family':
+        case 'constructor-value-dispatch':
+        case 'data-view':
+        case 'dense-buffer':
+        case 'dictionary':
+        case 'function':
+        case 'function-and-constructor':
+        case 'function-family':
+        case 'function-value-dispatch':
+        case 'generic-function-set':
+        case 'iterator':
+        case 'keyed-collection':
+        case 'native-handle':
+        case 'native-record-ref':
+        case 'native-sequence':
+        case 'promise':
+        case 'proxy-object':
+        case 'record':
+        case 'record-with-index':
+        case 'typed-array':
+            return true;
+        case 'function-value-family':
+            return !representation.optional;
+        case 'tagged-union':
+            return representation.arms.length > 0 && representation.arms.every((arm) => alwaysReturnsObject(arm.value));
+        default:
+            return false;
+    }
+};
+/**
+ * Publish the call entry used by a receiver-free ordinary constructor that
+ * always returns an object. The semantic target authenticates [[Construct]];
+ * the carrier alone cannot distinguish ordinary functions from arrows. Both
+ * the body and the held closure must agree on the entry convention. Keeping
+ * the invocation indirect preserves the actual closure's captures.
+ */
+export const explicitObjectConstructEntryOf = (operation, bodyAbi) => {
+    const callee = operation.callee.representation;
+    const target = operation.target;
+    if (operation.newTarget.value !== operation.callee.value ||
+        callee.kind !== 'function-value-dispatch' ||
+        target.kind !== 'exact' ||
+        target.target.kind !== 'function' ||
+        !target.target.constructable ||
+        bodyAbi === null ||
+        callee.abi.receiver !== null ||
+        !alwaysReturnsObject(callee.abi.result) ||
+        representationKey(callee) !== representationKey({ kind: 'function-value-dispatch', abi: bodyAbi }))
+        return undefined;
+    return { kind: 'explicit-object-return', functionId: target.target.functionId, abi: bodyAbi };
+};

package/dist/ir/dead-values.d.ts

@@ -0,0 +1,90 @@
+import type { IrValueId } from '../identity/ids.js';
+import type { ConstructOperation, GetOperation, IrBody, IrNonTerminatorOperation } from './model.js';
+/**
+ * Which results nothing reads, and whose operations may therefore render
+ * nothing at all.
+ *
+ * The IR is three-address form and every producer publishes a result, whether
+ * or not the program goes on to read it. A component's render body reads a
+ * field the plugin then re-reads through a reactive thunk; a key literal is
+ * spelled inline by the member access it keys; a callee that is only ever
+ * called by name never needs the function object built for it. Each of those
+ * left a statement behind -- `v20 = gea_this->cities;` with no reader,
+ * `v13 = "length";`, `v7 = gea::CallableObject<...>{&body, nullptr};` --
+ * which the C++ compiler may or may not remove (a `Ref` copy is an atomic
+ * increment it may not) and which a reader of the output has to prove dead
+ * by hand. `examples/apps/weather` carried 142 unread literal temporaries and
+ * 18 unread field reads in one unit.
+ *
+ * Deletion is a fixed point: an operation whose only reader was itself dead
+ * becomes dead in turn, so a chain of pure operations feeding one unread
+ * value disappears whole.
+ *
+ * Only an operation that neither writes nor runs program code may go. The
+ * whitelist is by kind, with three exceptions decided per operation:
+ *
+ * - a `get` is a pure load off an Array, a string, or a record field with no
+ *   accessor, and a call into the program through an accessor -- the emitter
+ *   answers which, since it alone knows the receiver's layout;
+ * - `compute` and `convert` are arithmetic on primitives and `ToPrimitive`
+ *   (which runs `valueOf`) on anything else, so they qualify only over
+ *   primitive operands;
+ * - `test` is a comparison, pure on every carrier but the boxed one, where it
+ *   may reach `valueOf` through loose equality.
+ *
+ * A `call` reads its callee -- unless the emitter reaches the body by name,
+ * in which case the callee's carrier is never spelled. `directCallee` says
+ * which producers those are (see `targets/cpp/emit-context.ts`'s
+ * `directCallees`), so a function object that exists only to be called
+ * directly counts as unread. The name itself is registered up front for
+ * every callee `ir/call-dispatch.ts`'s `CallOperation.target` resolved
+ * (`emit.ts`'s `emitBody`), independent of whether this producer ends up
+ * dead -- what `emit.ts` still has to do where it skips the dead operation is
+ * only the handful of side effects genuinely tied to the skipped RENDER
+ * itself (a reactive thunk's stashed value, a method read's stashed
+ * receiver), never the direct-callee name.
+ */
+export interface DeadValueRules {
+    /** Whether this member read is a plain load rather than a call into the program. `key` is the IR's own text for a string-literal key, or `null`. */
+    readonly pureGet: (operation: GetOperation, key: string | null) => boolean;
+    /** Whether a call through this producer's result reaches the body by name, never spelling the carrier. */
+    readonly directCallee: (producer: IrNonTerminatorOperation) => boolean;
+    /** Whether a construction through this producer reaches the class constructor by name, never spelling the carrier. */
+    readonly directConstructor: (producer: IrNonTerminatorOperation) => boolean;
+    /**
+     * Whether constructing this operation's result has no consequence anything
+     * else can observe -- `ir/instantiation.ts`'s
+     * `classesConstructedUnobservably`, asked of the class the result carries.
+     */
+    readonly pureConstruct: (operation: ConstructOperation) => boolean;
+    /**
+     * Whether the body this call reaches never names its receiver, so the
+     * receiver operand is not a read of it.
+     *
+     * A stateless gea component is the case: its render ignores `this`, but the
+     * call still has to hand it one, so a `construct` runs to manufacture a
+     * receiver nothing looks at. Combined with `pureConstruct`, that whole
+     * construction goes. The emitter then spells a default-constructed receiver
+     * at the call, because the callee's SIGNATURE still declares the formal --
+     * this drops the argument's value, not the parameter.
+     */
+    readonly ignoresReceiver: (callee: IrNonTerminatorOperation | undefined) => boolean;
+}
+/** Every string-literal constant's text by value, for member-read purity: a `get` keyed by `"width"` is asked about the member `width`. */
+export declare const stringConstantsOf: (body: IrBody) => ReadonlyMap<IrValueId, string>;
+/** Every boolean-literal constant by value, so a branch on one renders as the jump it is. */
+export declare const booleanConstantsOf: (body: IrBody) => ReadonlyMap<IrValueId, boolean>;
+/**
+ * Results no later operation or terminator reads, including effectful
+ * producers whose operation must remain.
+ *
+ * `deadValuesOf` is deliberately narrower: it identifies whole operations
+ * the emitter may delete. A call with an unread result is different. The call
+ * still runs, but assigning its return value into a temporary pays carrier
+ * work that the source program never observes (a returned `Ref`, for example,
+ * performs reference-count traffic). Keeping this census separate prevents
+ * an effectful operation from ever being mistaken for a deletable one while
+ * still letting its backend discard the C++ return value directly.
+ */
+export declare const unreadValuesOf: (body: IrBody) => ReadonlySet<IrValueId>;
+export declare const deadValuesOf: (body: IrBody, rules: DeadValueRules) => ReadonlySet<IrValueId>;

package/dist/ir/dead-values.js

@@ -0,0 +1,184 @@
+import { arrayAllocationDrainsDynamicIterator, operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+const alwaysPureKinds = new Set([
+    'constant',
+    'binding-read',
+    'parameter',
+    'receiver',
+    'has-property',
+    'allocate-callable',
+    'allocate-constructor',
+    'phi'
+]);
+const primitiveKinds = new Set(['scalar', 'string', 'null', 'undefined', 'symbol']);
+const isPrimitive = (operand) => primitiveKinds.has(operand.representation.kind);
+const isEffectFree = (operation, rules, keyTextOf) => {
+    if (alwaysPureKinds.has(operation.kind))
+        return true;
+    // A `gather` element drains a genuinely dynamic iterator, which can invoke
+    // a user-defined method -- see `queries.ts`'s
+    // `arrayAllocationDrainsDynamicIterator`. An ordinary literal or a native
+    // `spread` range-copy stays pure; only that one arm is not "read nothing,
+    // run nothing" the way this operation is for every other array shape.
+    if (operation.kind === 'allocate-array-object')
+        return !arrayAllocationDrainsDynamicIterator(operation);
+    if (operation.kind === 'get')
+        return rules.pureGet(operation, keyTextOf(operation.key));
+    if (operation.kind === 'compute' &&
+        (operation.form === 'require-object-coercible' ||
+            operation.form === 'require-iterable-present' ||
+            operation.form === 'require-tagged-union-arm'))
+        return false;
+    if (operation.kind === 'compute' || operation.kind === 'convert')
+        return operandsOfIrOperation(operation).every(isPrimitive);
+    if (operation.kind === 'test')
+        return operandsOfIrOperation(operation).every((operand) => operand.representation.kind !== 'dynamic');
+    if (operation.kind === 'construct')
+        return rules.pureConstruct(operation);
+    return false;
+};
+/** Every string-literal constant's text by value, for member-read purity: a `get` keyed by `"width"` is asked about the member `width`. */
+export const stringConstantsOf = (body) => {
+    const texts = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'constant' && operation.literal === 'string')
+                texts.set(operation.result.id, operation.text);
+        }
+    }
+    return texts;
+};
+/** Every boolean-literal constant by value, so a branch on one renders as the jump it is. */
+export const booleanConstantsOf = (body) => {
+    const known = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'constant' && operation.literal === 'boolean')
+                known.set(operation.result.id, operation.text === 'true');
+        }
+    }
+    return known;
+};
+/**
+ * Results no later operation or terminator reads, including effectful
+ * producers whose operation must remain.
+ *
+ * `deadValuesOf` is deliberately narrower: it identifies whole operations
+ * the emitter may delete. A call with an unread result is different. The call
+ * still runs, but assigning its return value into a temporary pays carrier
+ * work that the source program never observes (a returned `Ref`, for example,
+ * performs reference-count traffic). Keeping this census separate prevents
+ * an effectful operation from ever being mistaken for a deletable one while
+ * still letting its backend discard the C++ return value directly.
+ */
+export const unreadValuesOf = (body) => {
+    const produced = new Set();
+    const read = new Set();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            const result = resultOfIrOperation(operation);
+            if (result !== null)
+                produced.add(result.id);
+            for (const operand of operandsOfIrOperation(operation))
+                read.add(operand.value);
+        }
+        for (const operand of operandsOfIrOperation(block.terminator))
+            read.add(operand.value);
+    }
+    for (const region of body.iteratorCloseRegions ?? [])
+        read.add(region.iterator.value);
+    return new Set([...produced].filter((value) => !read.has(value)));
+};
+export const deadValuesOf = (body, rules) => {
+    const producers = new Map();
+    const readers = new Map();
+    const count = (value, by) => {
+        readers.set(value, (readers.get(value) ?? 0) + by);
+    };
+    // A call/construct's callee is read by the operation -- except when the body
+    // is reached by name, in which case the carrier is never spelled and its
+    // producer is as unread as if the invocation were not there. Guarded on the
+    // operand being non-optional: `f?.()` unwraps an `Optional` first, and the
+    // call site spells THAT value, not the one the producer published.
+    const readsOf = (operation) => {
+        const operands = operandsOfIrOperation(operation);
+        if (operation.kind === 'construct') {
+            const producer = producers.get(operation.callee.value);
+            if (operation.callee.representation.kind !== 'optional' && producer !== undefined && rules.directConstructor(producer)) {
+                // An ordinary `new C()` publishes C as both [[Construct]]'s callee and
+                // its newTarget. The named constructor path spells neither carrier;
+                // filtering by value drops both roles when they are that same value,
+                // while a distinct Reflect.construct newTarget remains a real read.
+                return operands.filter((operand) => operand.value !== operation.callee.value);
+            }
+            return operands;
+        }
+        if (operation.kind !== 'call')
+            return operands;
+        const producer = producers.get(operation.callee.value);
+        const ignored = new Set();
+        // The callee is read unless the body is reached by name. Guarded on the
+        // operand being the callee itself: `f?.()` unwraps an `Optional` first, and
+        // the call site spells THAT value, not the one the producer published.
+        // A producer may name a body directly while a later conversion exposes it
+        // as a boxed dynamic callable. That call necessarily reads the box through
+        // `callAsFunction`; deleting the producer under the direct-body rule leaves
+        // the emitter with a real callee use and no definition. The callable's
+        // carrier at THIS call site decides whether the value is spelled.
+        if (operation.callee.representation.kind !== 'optional' &&
+            operation.callee.representation.kind !== 'dynamic' &&
+            producer !== undefined &&
+            rules.directCallee(producer))
+            ignored.add(operation.callee);
+        if (operation.receiver !== null && rules.ignoresReceiver(producer))
+            ignored.add(operation.receiver);
+        if (ignored.size === 0)
+            return operands;
+        return operands.filter((operand) => !ignored.has(operand));
+    };
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            const result = resultOfIrOperation(operation);
+            if (result !== null)
+                producers.set(result.id, operation);
+        }
+    }
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations)
+            for (const operand of readsOf(operation))
+                count(operand.value, 1);
+        for (const operand of operandsOfIrOperation(block.terminator))
+            count(operand.value, 1);
+    }
+    for (const region of body.iteratorCloseRegions ?? [])
+        count(region.iterator.value, 1);
+    const strings = stringConstantsOf(body);
+    const keyTextOf = (operand) => strings.get(operand.value) ?? null;
+    const pure = (value) => {
+        const producer = producers.get(value);
+        return producer !== undefined && isEffectFree(producer, rules, keyTextOf);
+    };
+    const dead = new Set();
+    const pending = [...producers.keys()].filter((value) => (readers.get(value) ?? 0) === 0 && pure(value));
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (value === undefined || dead.has(value))
+            continue;
+        dead.add(value);
+        const producer = producers.get(value);
+        if (producer === undefined)
+            continue;
+        for (const operand of readsOf(producer)) {
+            // A direct class-method read is deleted as a materialized callable, but
+            // its receiver is retained beside the result for the later direct call.
+            // The call therefore still reads this operand even though it does not
+            // read the method carrier. Decrementing it here can delete the receiver
+            // and leave the direct call naming an SSA value with no definition.
+            if (producer.kind === 'get' && rules.directCallee(producer) && operand === producer.receiver)
+                continue;
+            count(operand.value, -1);
+            if (readers.get(operand.value) === 0 && pure(operand.value))
+                pending.push(operand.value);
+        }
+    }
+    return dead;
+};

package/dist/ir/deferral.d.ts

@@ -0,0 +1,99 @@
+import type { DeclarationId, IrValueId } from '../identity/ids.js';
+import type { BindingReadOperation, BindingWriteOperation, CallOperation, ConstructOperation, GetOperation, IrBody, IrOperand, ReturnOperation, SetOperation } from './model.js';
+/**
+ * The consumers a forwarded call may land in. Every one of them is audited to
+ * spell the forwarded operand ONCE per executed path -- an operand a renderer
+ * spells twice would run the call twice -- and the target's policy narrows
+ * each further to the renderings it can vouch for (`ForwardingPolicy`).
+ */
+export type CallSink = CallOperation | ConstructOperation | SetOperation | BindingWriteOperation | ReturnOperation;
+/**
+ * What only the target can answer about a forwarding: which of its renderers
+ * spell an operand exactly once, and which cells are private enough to lose.
+ */
+export interface ForwardingPolicy {
+    /**
+     * Whether the target's rendering of `consumer` spells `value` exactly once
+     * on every path, with no conversion that could spell it again. The census
+     * has already established that `value` is the consumer's argument, stored
+     * element, written value or returned value, that nothing sits between the
+     * two, and -- for an Array element store -- that the element carrier is the
+     * value's own.
+     */
+    readonly forwardsCallInto: (consumer: CallSink, value: IrOperand) => boolean;
+    /**
+     * Whether `write`'s cell is a private local of this body -- unboxed,
+     * captured by nothing, holding exactly the carrier both the write and
+     * `read` carry -- so that the one write may render nothing and the one
+     * read may spell the written value. Integer-narrowed and type-query cells
+     * are excluded by the census itself, which owns both of those facts.
+     */
+    readonly forwardsBinding: (write: BindingWriteOperation, read: BindingReadOperation) => boolean;
+}
+export declare const noForwarding: ForwardingPolicy;
+/** A cell whose one write renders nothing and whose one read spells `value` instead: see `deferrableValuesOf`. */
+export interface ForwardedBinding {
+    readonly value: IrOperand;
+    readonly read: IrValueId;
+}
+/**
+ * Which values may render at their single use instead of into a temporary of
+ * their own.
+ *
+ * The IR is three-address form, and for a `double` that costs nothing: the C++
+ * compiler propagates the copy away. For a `std::shared_ptr` it is an atomic
+ * increment and a matching decrement, and for a `std::string` it is a heap
+ * allocation -- neither of which any optimizer may remove, because both are
+ * observable through the refcount and the allocator. An array indexed in a
+ * loop was paying one atomic pair per iteration purely to name the array the
+ * cell was already holding.
+ *
+ * Four conditions, and each one is load-bearing. Compound sum conversions
+ * additionally retain their named result to bound composition of projections:
+ *
+ * 1. exactly one use, so the expression is not evaluated twice;
+ * 2. that use in the same block, so no `goto` can reach the use without
+ *    passing the definition;
+ * 3. the defining operation side-effect-free (`isDeferrableOperation`); and
+ * 4. every operation between the two also deferred.
+ *
+ * (4) is what makes (3) sufficient. Everything between the definition and the
+ * use emitted no statement of its own, so the window contains no write at all
+ * -- which is why the order these reads end up in inside the use's own
+ * expression, which C++ leaves unspecified for most operators, cannot be
+ * observed by the program.
+ *
+ * Two forwardings ride on the same census, each with a narrower proof:
+ *
+ * - a `call`, `construct` or `allocate-callable` result whose single reader
+ *   is the IMMEDIATELY following operation (`forwardableProducerKinds`,
+ *   `callSinkOf`): no window, so nothing is crossed, and the producer keeps
+ *   bounding everyone else's windows;
+ * - a cell written once and read once in one block, the read itself
+ *   deferrable, every operation between the two effect-free, and the read
+ *   consumed where it is copied or called rather than borrowed
+ *   (`forwardedReadPositionAllowed`): the write renders nothing and the read
+ *   spells the written value (`forwardedBindings`).
+ *
+ * The target's `ForwardingPolicy` has the last word on both, because both
+ * depend on how a renderer spells its operand and on whose storage a cell is.
+ *
+ * A use recorded for a merge (`phi`) belongs to the PREDECESSOR block at the
+ * position `emitBody` writes merges at -- after that block's operations and
+ * before its terminator -- not to the block the phi is written in. Recording
+ * it where the phi sits would let a value move across the whole block.
+ */
+/**
+ * `pureGet` widens the `get` rule past Arrays and strings to whatever the
+ * emitter can prove is a plain field load (`emit-properties.ts`'s
+ * `isPlainMemberRead`): `v20 = gea_this->cities; if (b0 < v20->length())`
+ * is a `Ref` copy -- an atomic pair -- made only to name the field once, and
+ * with the read deferred the comparison spells the field itself. The default
+ * refuses every such read, which is the answer the census gave before it was
+ * asked.
+ */
+export declare const deferrableValuesOf: (body: IrBody, pureGet?: (operation: GetOperation) => boolean, forwarding?: ForwardingPolicy) => {
+    readonly values: Set<IrValueId>;
+    readonly consumedByCall: Set<IrValueId>;
+    readonly forwardedBindings: Map<DeclarationId, ForwardedBinding>;
+};