@geastack/compiler 1.0.15

package/dist/ir/static-callables.d.ts

@@ -0,0 +1,11 @@
+import type { DeclarationId, IrValueId } from '../identity/ids.js';
+import type { BindingPlacement } from '../projection/bindings.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { CallCalleeIdentity, IrBody } from './model.js';
+/**
+ * Static methods have projected implementation identities just like instance
+ * methods. Publish them only while the constructor object stays inside uses
+ * that cannot replace its members. This is a callable identity proof, not a
+ * request to bypass the callable's environment or receiver convention.
+ */
+export declare const closedStaticCallablesOf: (bodies: readonly IrBody[], placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>) => ReadonlyMap<IrValueId, CallCalleeIdentity>;

package/dist/ir/static-callables.js

@@ -0,0 +1,163 @@
+import { classMemberOf, classStaticMemberOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+/**
+ * Static methods have projected implementation identities just like instance
+ * methods. Publish them only while the constructor object stays inside uses
+ * that cannot replace its members. This is a callable identity proof, not a
+ * request to bypass the callable's environment or receiver convention.
+ */
+export const closedStaticCallablesOf = (bodies, placements, classes) => {
+    const operations = bodies.flatMap((body) => body.blockOrder.flatMap((id) => {
+        const block = body.blocks.get(id);
+        return block ? [...block.operations, block.terminator] : [];
+    }));
+    const producers = new Map();
+    const writes = new Map();
+    for (const operation of operations) {
+        const result = resultOfIrOperation(operation);
+        if (result)
+            producers.set(result.id, operation);
+        if (operation.kind === 'binding-write') {
+            const values = writes.get(operation.declaration) ?? [];
+            values.push(operation.value.value);
+            writes.set(operation.declaration, values);
+        }
+    }
+    const nativeConstructor = (id, declaration, visiting = new Set()) => {
+        if (visiting.has(id))
+            return false;
+        const operation = producers.get(id);
+        if (!operation)
+            return false;
+        if (operation.kind === 'allocate-constructor')
+            return operation.declaration === declaration;
+        let sources = null;
+        if (operation.kind === 'binding-read') {
+            const storage = placements.get(operation.declaration)?.storage.kind;
+            if (storage === 'local' || storage === 'region')
+                sources = writes.get(operation.declaration) ?? null;
+        }
+        else if (operation.kind === 'phi')
+            sources = operation.incoming.map((incoming) => incoming.value.value);
+        else if (operation.kind === 'convert' &&
+            representationKey(operation.source.representation) === representationKey(operation.result.representation))
+            sources = [operation.source.value];
+        if (!sources?.length)
+            return false;
+        visiting.add(id);
+        const closed = sources.every((source) => nativeConstructor(source, declaration, visiting));
+        visiting.delete(id);
+        return closed;
+    };
+    const membersOf = (value) => {
+        if (value.kind === 'constructor-family')
+            return value.members;
+        // An escaped instance exposes its constructor through its prototype.
+        // Treat it as another route to mutation, not as an unrelated payload.
+        if (value.kind === 'class-ref')
+            return [value.declaration];
+        if (value.kind === 'optional')
+            return membersOf(value.payload);
+        if (value.kind === 'borrowed-ref')
+            return membersOf(value.referent);
+        if (value.kind === 'tagged-union')
+            return value.arms.flatMap((arm) => membersOf(arm.value));
+        return [];
+    };
+    const candidates = new Map();
+    for (const operation of operations) {
+        if (operation.kind !== 'get' || operation.receiver.representation.kind !== 'constructor-family')
+            continue;
+        const members = operation.receiver.representation.members;
+        // A family with different static implementations needs its own dispatch
+        // recipe; the existing static member renderer selects one declaration.
+        if (members.length !== 1)
+            continue;
+        const key = producers.get(operation.key.value);
+        if (key?.kind !== 'constant' || key.literal !== 'string')
+            continue;
+        const receiver = members[0];
+        if (!nativeConstructor(operation.receiver.value, receiver))
+            continue;
+        const site = classStaticMemberOf(classes, receiver, key.text);
+        if (site?.kind !== 'method' || site.method.callable === null)
+            continue;
+        candidates.set(operation.result.id, {
+            receiver,
+            owner: site.owner,
+            identity: { kind: 'exact', functionId: site.method.callable }
+        });
+    }
+    const untrusted = new Set();
+    for (const operation of operations) {
+        for (const operand of operandsOfIrOperation(operation)) {
+            const members = membersOf(operand.representation);
+            if (members.length === 0)
+                continue;
+            if (operand.representation.kind === 'class-ref' &&
+                (operation.kind === 'get' || operation.kind === 'set') &&
+                operand.value === operation.receiver.value &&
+                (operation.kind !== 'set' || operation.value.value !== operand.value)) {
+                const key = producers.get(operation.key.value);
+                const member = key?.kind === 'constant' && key.literal === 'string' ? classMemberOf(classes, operand.representation.declaration, key.text) : null;
+                if (member?.kind === 'field' || (operation.kind === 'get' && member?.kind === 'method'))
+                    continue;
+            }
+            if (operation.kind === 'get' && operand.value === operation.receiver.value && candidates.has(operation.result.id))
+                continue;
+            if (operation.kind === 'binding-write') {
+                const placement = placements.get(operation.declaration);
+                if ((placement?.storage.kind === 'local' || placement?.storage.kind === 'region') &&
+                    placement.representation !== null &&
+                    representationKey(placement.representation) === representationKey(operand.representation))
+                    continue;
+            }
+            if (operation.kind === 'construct' &&
+                (operand.value === operation.callee.value || operand.value === operation.newTarget.value) &&
+                !operation.arguments.some((argument) => argument.value === operand.value))
+                continue;
+            if (operation.kind === 'call' &&
+                operand.value === operation.receiver?.value &&
+                candidates.has(operation.callee.value) &&
+                !operation.arguments.some((argument) => argument.value === operand.value))
+                continue;
+            if ((operation.kind === 'convert' &&
+                representationKey(operation.source.representation) === representationKey(operation.result.representation)) ||
+                (operation.kind === 'phi' &&
+                    operation.incoming.every((incoming) => representationKey(incoming.value.representation) === representationKey(operation.result.representation))) ||
+                operation.kind === 'test' ||
+                (operation.kind === 'compute' &&
+                    (operation.form === 'typeof' ||
+                        (operation.form === 'unary' && (operation.operator === 'void' || operation.operator === '!')) ||
+                        (operation.form === 'equality' && (operation.operator === '===' || operation.operator === '!==')))))
+                continue;
+            // An unknown consumer can walk the constructor's prototype chain and
+            // replace an inherited member on an ancestor as well.
+            for (const member of members) {
+                let declaration = member;
+                const seen = new Set();
+                while (declaration !== null && !seen.has(declaration)) {
+                    untrusted.add(declaration);
+                    seen.add(declaration);
+                    declaration = classes.get(declaration)?.base ?? null;
+                }
+            }
+        }
+    }
+    return new Map([...candidates].flatMap(([id, candidate]) => {
+        // An intermediate constructor can shadow the inherited method without
+        // mutating either the receiver or the original declaring constructor.
+        let declaration = candidate.receiver;
+        const seen = new Set();
+        while (declaration !== null && !seen.has(declaration)) {
+            if (untrusted.has(declaration))
+                return [];
+            if (declaration === candidate.owner)
+                return [[id, candidate.identity]];
+            seen.add(declaration);
+            declaration = classes.get(declaration)?.base ?? null;
+        }
+        return [];
+    }));
+};

package/dist/ir/string-layout-reuse.d.ts

@@ -0,0 +1,13 @@
+import type { IrValueId } from '../identity/ids.js';
+import type { HoistPlan } from './hoist.js';
+import type { IrBody } from './model.js';
+export interface SharedStringLayout {
+    readonly ordinal: number;
+    readonly initialize: boolean;
+}
+/** Share the scan only among reads already proved invariant and relocated to
+ * the same preheader. Binding identities are interchangeable only when their
+ * reads occur in that same relocation list: a matching declaration elsewhere
+ * could observe a different value. This consumes the hoist proof instead of
+ * inventing another alias or callback-effect analysis. */
+export declare const sharedStringLayoutsOf: (body: IrBody, hoists: HoistPlan, excluded: ReadonlySet<IrValueId>) => ReadonlyMap<IrValueId, SharedStringLayout>;

package/dist/ir/string-layout-reuse.js

@@ -0,0 +1,39 @@
+import { stringConstantsOf } from './dead-values.js';
+/** Share the scan only among reads already proved invariant and relocated to
+ * the same preheader. Binding identities are interchangeable only when their
+ * reads occur in that same relocation list: a matching declaration elsewhere
+ * could observe a different value. This consumes the hoist proof instead of
+ * inventing another alias or callback-effect analysis. */
+export const sharedStringLayoutsOf = (body, hoists, excluded) => {
+    const layouts = new Map();
+    const keys = stringConstantsOf(body);
+    let ordinal = 0;
+    for (const operations of hoists.into.values()) {
+        const receivers = new Map();
+        for (const operation of operations) {
+            if (operation.kind === 'binding-read')
+                receivers.set(operation.result.id, `binding:${operation.declaration}`);
+        }
+        const groups = new Map();
+        for (const operation of operations) {
+            if (operation.kind !== 'get' || operation.receiver.representation.kind !== 'string' || excluded.has(operation.result.id))
+                continue;
+            const key = keys.get(operation.key.value);
+            if (key !== 'length' && key !== 'charCodeAt')
+                continue;
+            const identity = receivers.get(operation.receiver.value) ?? `value:${operation.receiver.value}`;
+            const group = groups.get(identity) ?? [];
+            group.push(operation);
+            groups.set(identity, group);
+        }
+        for (const group of groups.values()) {
+            if (group.length < 2 || !group.some((operation) => keys.get(operation.key.value) === 'charCodeAt'))
+                continue;
+            for (const [index, operation] of group.entries()) {
+                layouts.set(operation.result.id, { ordinal, initialize: index === 0 });
+            }
+            ordinal++;
+        }
+    }
+    return layouts;
+};

package/dist/ir/string-length-reuse.d.ts

@@ -0,0 +1,8 @@
+import type { DeclarationId, IrValueId } from '../identity/ids.js';
+import type { IrBody, IrOperand } from './model.js';
+/** Reuse a dominating native string length. The receiver must be the same
+ * SSA value, or a read of a cell the caller proves aliases an unchanged
+ * formal. No object getters, mutable cells, or assumptions about callees.
+ * Relocated/dead reads are excluded: their original CFG position no longer
+ * states where (or whether) their result will be available. */
+export declare const stringLengthReuseOf: (body: IrBody, stableFormals: ReadonlySet<DeclarationId>, excluded: ReadonlySet<IrValueId>) => ReadonlyMap<IrValueId, IrOperand>;

package/dist/ir/string-length-reuse.js

@@ -0,0 +1,47 @@
+import { dominatorTreeOf } from './dominance.js';
+import { stringConstantsOf } from './dead-values.js';
+/** Reuse a dominating native string length. The receiver must be the same
+ * SSA value, or a read of a cell the caller proves aliases an unchanged
+ * formal. No object getters, mutable cells, or assumptions about callees.
+ * Relocated/dead reads are excluded: their original CFG position no longer
+ * states where (or whether) their result will be available. */
+export const stringLengthReuseOf = (body, stableFormals, excluded) => {
+    const reuse = new Map();
+    if (body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+        return reuse;
+    const keys = stringConstantsOf(body);
+    const receivers = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'binding-read' && stableFormals.has(operation.declaration))
+                receivers.set(operation.result.id, `formal:${operation.declaration}`);
+            if (operation.kind === 'parameter')
+                receivers.set(operation.result.id, `parameter:${operation.ordinal}`);
+        }
+    }
+    const dominance = dominatorTreeOf(body);
+    const available = 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 !== 'get' ||
+                operation.receiver.representation.kind !== 'string' ||
+                keys.get(operation.key.value) !== 'length' ||
+                excluded.has(operation.result.id))
+                continue;
+            // Non-formal binding reads deliberately keep their distinct SSA IDs.
+            const identity = receivers.get(operation.receiver.value) ?? `value:${operation.receiver.value}`;
+            const prior = available.get(identity) ?? [];
+            const dominating = prior.find((candidate) => dominance.dominates(candidate.block, blockId));
+            if (dominating)
+                reuse.set(operation.result.id, dominating.operand);
+            else {
+                prior.push({ block: blockId, operand: { value: operation.result.id, representation: operation.result.representation } });
+                available.set(identity, prior);
+            }
+        }
+    }
+    return reuse;
+};

package/dist/ir/transfer.d.ts

@@ -0,0 +1,78 @@
+import type { IrValueId } from '../identity/ids.js';
+import type { IrBody, ValueTransfer } from './model.js';
+/**
+ * Relocated from `targets/cpp/captures.ts` per
+ * the `IrOperand.transfer` step that moved this fact out of the target: the
+ * move pipeline reasons only about the lowered IR (SSA uses, cells, control
+ * flow), never about how the target renders anything, so it belongs here
+ * rather than beside the printer. `cppTypeOf` stays a target import for now
+ * -- `ownedFormalInputsOf`'s optional-unwrap check compares two carriers by
+ * their C++ SPELLING, which is the target's own historical answer to "does
+ * this conversion actually change the representation"; swapping it for
+ * `representationKey` would be a behavior change (two representations can
+ * share a spelling while differing in fields this key tracks, e.g.
+ * `shapeId`), and this refactor's contract is byte-identical output, not a
+ * better answer. Collapsing that comparison onto a pure representation
+ * predicate is future work, not this step's.
+ */
+/**
+ * Argument reads whose value is DYING at the call that takes it: the cell is
+ * read ONCE in the whole unit, that read is the argument's only use, and every
+ * write to the cell is in the body that reads it. Nothing can observe the cell
+ * after the call, so the argument MOVES into the callee rather than copying.
+ *
+ * The copy is not free. A `gea::Ref` argument passed by value increments on the
+ * way in and releases on the way out, and the release is a decrement, a branch,
+ * and -- on the taken side -- an out-of-line destructor call clang cannot prove
+ * unreachable. `binary_trees`' `build` pays that pair twice per node, for the
+ * two subtrees it has just built and will never look at again. Measured on
+ * `binary_trees` at 1M nodes: 41.9ms as emitted, 40.8ms with the two subtree
+ * arguments moved.
+ *
+ * Each condition is a way the move would be OBSERVED, so none of them can be
+ * relaxed for a bigger catch:
+ *  - a second read anywhere in the unit -- a module-scope cell two bodies read,
+ *    a cell a closure captures by reference -- would see the emptied cell.
+ *  - a second use of the same read, `f(x, x)`, moves the first argument out
+ *    from under the second.
+ *  - a read or its single use that a loop re-enters moves once and passes an
+ *    empty `Ref` on every iteration after. A loop-invariant read can live in
+ *    an acyclic preheader while its SSA value is consumed in the cyclic body,
+ *    so both blocks must be acyclic.
+ *  - a write in ANOTHER body means the cell outlives this frame: the read is
+ *    local but the storage is not.
+ */
+export declare const buildDyingArgumentIndex: (bodies: readonly IrBody[]) => ReadonlySet<IrValueId>;
+/**
+ * Single-use SSA storage can move across a branch if the consumer cannot run
+ * twice without its defining operation running again. Removing the definition
+ * block from the CFG makes that loop-carried-use question explicit. Binding
+ * aliases and borrowed formals are excluded later by the emitter's actual
+ * storage ownership, rather than inferred from a read's source type.
+ */
+export declare const ownedDyingValuesOf: (body: IrBody) => ReadonlySet<IrValueId>;
+/** Last uses of by-value ABI inputs, grouped by formal rather than SSA read. */
+export declare const ownedFormalInputsOf: (body: IrBody) => {
+    readonly arguments: ReadonlySet<IrValueId>;
+    readonly conversions: ReadonlySet<IrValueId>;
+};
+/**
+ * The single decision `emit-narrowing.ts`'s `movedValueText` and
+ * `emit-callable.ts`'s stable-borrow-entry check used to make twice, verbatim,
+ * against the same two whole-program facts above plus the target's own
+ * storage-ownership census (`EmitContext.ownedValues` -- carrier ownership
+ * class for a capture is a separate, still target-computed Phase 3 step per
+ * a program fact of the IR, not of this one). A dying read moves
+ * outright (`buildDyingArgumentIndex`); an SSA-dying temporary
+ * (`ownedDyingValuesOf`) moves only once storage ownership is proven, since
+ * that census alone cannot tell a physical owner from a borrowed alias.
+ */
+export declare const transferOf: (dyingArguments: ReadonlySet<IrValueId>, ownedValues: ReadonlySet<IrValueId>, ownedDyingValues: ReadonlySet<IrValueId>, value: IrValueId) => ValueTransfer;
+/**
+ * The formal-conversion half of the same pipeline (`ownedFormalInputsOf`'s
+ * `conversions`): a dying by-value parameter that reaches its one use through
+ * an optional-unwrap `convert` moves at the CONVERT's result, not at a read of
+ * the parameter itself -- `emit.ts`'s `emitConvert` is the one renderer that
+ * ever sees that result id, so this is keyed by result rather than by operand.
+ */
+export declare const transfersFormalConversion: (consumingFormalConversions: ReadonlySet<IrValueId>, resultValue: IrValueId) => ValueTransfer;

package/dist/ir/transfer.js

@@ -0,0 +1,270 @@
+import { cppTypeOf } from '../targets/cpp/types.js';
+import { controlFlowGraphOf, cyclicBlocksOf } from './dominance.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+/**
+ * Relocated from `targets/cpp/captures.ts` per
+ * the `IrOperand.transfer` step that moved this fact out of the target: the
+ * move pipeline reasons only about the lowered IR (SSA uses, cells, control
+ * flow), never about how the target renders anything, so it belongs here
+ * rather than beside the printer. `cppTypeOf` stays a target import for now
+ * -- `ownedFormalInputsOf`'s optional-unwrap check compares two carriers by
+ * their C++ SPELLING, which is the target's own historical answer to "does
+ * this conversion actually change the representation"; swapping it for
+ * `representationKey` would be a behavior change (two representations can
+ * share a spelling while differing in fields this key tracks, e.g.
+ * `shapeId`), and this refactor's contract is byte-identical output, not a
+ * better answer. Collapsing that comparison onto a pure representation
+ * predicate is future work, not this step's.
+ */
+/**
+ * Argument reads whose value is DYING at the call that takes it: the cell is
+ * read ONCE in the whole unit, that read is the argument's only use, and every
+ * write to the cell is in the body that reads it. Nothing can observe the cell
+ * after the call, so the argument MOVES into the callee rather than copying.
+ *
+ * The copy is not free. A `gea::Ref` argument passed by value increments on the
+ * way in and releases on the way out, and the release is a decrement, a branch,
+ * and -- on the taken side -- an out-of-line destructor call clang cannot prove
+ * unreachable. `binary_trees`' `build` pays that pair twice per node, for the
+ * two subtrees it has just built and will never look at again. Measured on
+ * `binary_trees` at 1M nodes: 41.9ms as emitted, 40.8ms with the two subtree
+ * arguments moved.
+ *
+ * Each condition is a way the move would be OBSERVED, so none of them can be
+ * relaxed for a bigger catch:
+ *  - a second read anywhere in the unit -- a module-scope cell two bodies read,
+ *    a cell a closure captures by reference -- would see the emptied cell.
+ *  - a second use of the same read, `f(x, x)`, moves the first argument out
+ *    from under the second.
+ *  - a read or its single use that a loop re-enters moves once and passes an
+ *    empty `Ref` on every iteration after. A loop-invariant read can live in
+ *    an acyclic preheader while its SSA value is consumed in the cyclic body,
+ *    so both blocks must be acyclic.
+ *  - a write in ANOTHER body means the cell outlives this frame: the read is
+ *    local but the storage is not.
+ */
+export const buildDyingArgumentIndex = (bodies) => {
+    const reads = new Map();
+    const readCounts = new Map();
+    const writeBodies = new Map();
+    const uses = new Map();
+    const passed = new Set();
+    const definedIn = new Map();
+    const usedIn = new Map();
+    for (const body of bodies) {
+        for (const [blockId, block] of body.blocks) {
+            for (const operation of [...block.operations, block.terminator]) {
+                const produced = resultOfIrOperation(operation);
+                if (produced !== null)
+                    definedIn.set(produced.id, blockId);
+                for (const operand of operandsOfIrOperation(operation)) {
+                    uses.set(operand.value, (uses.get(operand.value) ?? 0) + 1);
+                    usedIn.set(operand.value, blockId);
+                }
+                if (operation.kind === 'binding-read') {
+                    reads.set(operation.result.id, { declaration: operation.declaration, body, block: blockId });
+                    readCounts.set(operation.declaration, (readCounts.get(operation.declaration) ?? 0) + 1);
+                }
+                if (operation.kind === 'binding-write') {
+                    const bodiesOfCell = writeBodies.get(operation.declaration) ?? new Set();
+                    bodiesOfCell.add(body);
+                    writeBodies.set(operation.declaration, bodiesOfCell);
+                }
+                if (operation.kind === 'call' || operation.kind === 'construct') {
+                    for (const argument of operation.arguments)
+                        passed.add(argument.value);
+                }
+                // A field store hands the value over exactly as an argument does, and so
+                // does a write into a cell -- the cell keeps what the value held, and a
+                // value with one use has nothing left to keep.
+                if (operation.kind === 'set' || operation.kind === 'define-own-property')
+                    passed.add(operation.value.value);
+                if (operation.kind === 'binding-write')
+                    passed.add(operation.value.value);
+            }
+        }
+    }
+    const cyclic = new Map();
+    const dying = new Set();
+    // A value the SAME BLOCK defines and then passes is the simplest dying shape
+    // there is, and needs no cell reasoning at all: straight-line code redefines
+    // it before every use, so a loop cannot carry an emptied one into the next
+    // iteration and no other block can name it. `binary_trees`' `build` is
+    // exactly this -- the two subtrees it has just recursed for.
+    for (const [value, block] of definedIn) {
+        if (reads.has(value) || !passed.has(value) || uses.get(value) !== 1)
+            continue;
+        if (usedIn.get(value) === block)
+            dying.add(value);
+    }
+    for (const [value, read] of reads) {
+        if (!passed.has(value) || uses.get(value) !== 1)
+            continue;
+        if (readCounts.get(read.declaration) !== 1)
+            continue;
+        const written = writeBodies.get(read.declaration);
+        if (written === undefined || written.size !== 1 || !written.has(read.body))
+            continue;
+        const blocks = cyclic.get(read.body) ?? cyclicBlocksOf(read.body);
+        cyclic.set(read.body, blocks);
+        const useBlock = usedIn.get(value);
+        if (blocks.has(read.block) || (useBlock !== undefined && blocks.has(useBlock)))
+            continue;
+        dying.add(value);
+    }
+    return dying;
+};
+/**
+ * Single-use SSA storage can move across a branch if the consumer cannot run
+ * twice without its defining operation running again. Removing the definition
+ * block from the CFG makes that loop-carried-use question explicit. Binding
+ * aliases and borrowed formals are excluded later by the emitter's actual
+ * storage ownership, rather than inferred from a read's source type.
+ */
+export const ownedDyingValuesOf = (body) => {
+    const definitions = new Map();
+    const uses = new Map();
+    for (const [blockId, block] of body.blocks) {
+        for (const operation of [...block.operations, block.terminator]) {
+            const result = resultOfIrOperation(operation);
+            if (result)
+                definitions.set(result.id, blockId);
+            for (const operand of operandsOfIrOperation(operation)) {
+                const readers = uses.get(operand.value) ?? [];
+                readers.push(blockId);
+                uses.set(operand.value, readers);
+            }
+        }
+    }
+    const graph = controlFlowGraphOf(body);
+    const cyclic = cyclicBlocksOf(body);
+    const dying = new Set();
+    for (const [value, definition] of definitions) {
+        const readers = uses.get(value);
+        if (readers?.length !== 1)
+            continue;
+        const use = readers[0];
+        if (use === undefined)
+            continue;
+        // A value defined outside a loop can still have its sole SSA use inside
+        // the loop. Moving at that use empties the storage on the first iteration
+        // and every later iteration observes a null Ref. The CFG re-entry check
+        // below only handles distinct definition/use blocks, so exclude cyclic
+        // uses before the same-block fast path as well.
+        if (cyclic.has(use))
+            continue;
+        if (use === definition) {
+            dying.add(value);
+            continue;
+        }
+        // Exceptional region edges are not represented by this CFG.
+        if (body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+            continue;
+        const pending = [...(graph.successors.get(use) ?? [])];
+        const visited = new Set();
+        let reentered = false;
+        while (pending.length > 0) {
+            const next = pending.pop();
+            if (next === undefined || next === definition || visited.has(next))
+                continue;
+            if (next === use) {
+                reentered = true;
+                break;
+            }
+            visited.add(next);
+            pending.push(...(graph.successors.get(next) ?? []));
+        }
+        if (!reentered)
+            dying.add(value);
+    }
+    return dying;
+};
+/** Last uses of by-value ABI inputs, grouped by formal rather than SSA read. */
+export const ownedFormalInputsOf = (body) => {
+    const arguments_ = new Set();
+    const conversions = new Set();
+    if (body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+        return { arguments: arguments_, conversions };
+    const parameters = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'parameter' && body.abi?.parameters[operation.ordinal]?.ownership !== 'borrowed')
+                parameters.set(operation.result.id, operation.ordinal);
+        }
+    }
+    const uses = new Map();
+    for (const [blockId, block] of body.blocks) {
+        for (const [index, operation] of [...block.operations, block.terminator].entries()) {
+            for (const operand of operandsOfIrOperation(operation)) {
+                const ordinal = parameters.get(operand.value);
+                if (ordinal === undefined)
+                    continue;
+                const readers = uses.get(ordinal) ?? [];
+                readers.push({ block: blockId, index, operation, value: operand.value });
+                uses.set(ordinal, readers);
+            }
+        }
+    }
+    const graph = controlFlowGraphOf(body);
+    const cyclic = cyclicBlocksOf(body);
+    for (const readers of uses.values()) {
+        // A binding write may be a formal-cell alias, not a physical copy. Its
+        // subsequent binding reads are outside this direct formal-use census.
+        if (readers.some((read) => read.operation.kind === 'binding-write'))
+            continue;
+        for (const read of readers) {
+            if (cyclic.has(read.block))
+                continue;
+            const operation = read.operation;
+            if (readers.length === 1 && (operation.kind === 'call' || operation.kind === 'construct')) {
+                if (operation.arguments.some((argument) => argument.value === read.value))
+                    arguments_.add(read.value);
+            }
+            if (operation.kind !== 'convert')
+                continue;
+            const source = operation.source.representation;
+            const target = operation.result.representation;
+            if (source.kind !== 'optional' || (target.kind !== 'string' && target.kind !== 'class-ref'))
+                continue;
+            if (cppTypeOf(source.payload) !== cppTypeOf(target))
+                continue;
+            // Same-block reads may be deferred past this operation by the pure
+            // expression scheduler. A different block gives a real ordering boundary.
+            if (readers.some((other) => other !== read && other.block === read.block))
+                continue;
+            const reachable = new Set();
+            const pending = [...(graph.successors.get(read.block) ?? [])];
+            while (pending.length > 0) {
+                const next = pending.pop();
+                if (next === undefined || reachable.has(next))
+                    continue;
+                reachable.add(next);
+                pending.push(...(graph.successors.get(next) ?? []));
+            }
+            if (readers.some((other) => reachable.has(other.block)))
+                continue;
+            conversions.add(operation.result.id);
+        }
+    }
+    return { arguments: arguments_, conversions };
+};
+/**
+ * The single decision `emit-narrowing.ts`'s `movedValueText` and
+ * `emit-callable.ts`'s stable-borrow-entry check used to make twice, verbatim,
+ * against the same two whole-program facts above plus the target's own
+ * storage-ownership census (`EmitContext.ownedValues` -- carrier ownership
+ * class for a capture is a separate, still target-computed Phase 3 step per
+ * a program fact of the IR, not of this one). A dying read moves
+ * outright (`buildDyingArgumentIndex`); an SSA-dying temporary
+ * (`ownedDyingValuesOf`) moves only once storage ownership is proven, since
+ * that census alone cannot tell a physical owner from a borrowed alias.
+ */
+export const transferOf = (dyingArguments, ownedValues, ownedDyingValues, value) => (dyingArguments.has(value) || (ownedValues.has(value) && ownedDyingValues.has(value)) ? 'move' : 'retain');
+/**
+ * The formal-conversion half of the same pipeline (`ownedFormalInputsOf`'s
+ * `conversions`): a dying by-value parameter that reaches its one use through
+ * an optional-unwrap `convert` moves at the CONVERT's result, not at a read of
+ * the parameter itself -- `emit.ts`'s `emitConvert` is the one renderer that
+ * ever sees that result id, so this is keyed by result rather than by operand.
+ */
+export const transfersFormalConversion = (consumingFormalConversions, resultValue) => consumingFormalConversions.has(resultValue) ? 'move' : 'retain';

package/dist/ir/type-query-results.d.ts

@@ -0,0 +1,25 @@
+import type { DeclarationId, IrValueId } from '../identity/ids.js';
+import { type ComputeOperation, type IrBody, type IrOperand } from './model.js';
+export type TypeQueryOperand = {
+    readonly kind: 'tag';
+    readonly operand: IrOperand;
+} | {
+    readonly kind: 'literal';
+    readonly text: string;
+};
+export interface TypeQueryComparison {
+    readonly left: TypeQueryOperand;
+    readonly right: TypeQueryOperand;
+    readonly unequal: boolean;
+}
+/** A typeof result consumed only by equality tests needs its finite type tag,
+ * not a constructed string. This is a snapshot at the query's original site,
+ * never a new query at the comparison (the input may have changed meanwhile).
+ * Native storage is confined to SSA values and private, single-writer cells
+ * whose write dominates every read. Any escape invalidates the entire chain.
+ * The caller supplies the existing placement/capture proof, not a new census. */
+export declare const typeQueryResultsOf: (body: IrBody, privateCell: (declaration: DeclarationId) => boolean) => {
+    readonly values: ReadonlySet<IrValueId>;
+    readonly bindings: ReadonlySet<DeclarationId>;
+    readonly comparisons: ReadonlyMap<ComputeOperation, TypeQueryComparison>;
+};