@geastack/compiler 1.0.15

package/dist/ir/facts.js

@@ -0,0 +1,181 @@
+import { booleanConstantsOf, deadValuesOf, unreadValuesOf } from './dead-values.js';
+import { deferrableValuesOf } from './deferral.js';
+import { loopInvariantHoistsOf, loopInvariantValuesOf } from './hoist.js';
+import { narrowableIntegersOf, remainderFormGroups } from './integers.js';
+import { localIteratorValuesOf } from './local-iterators.js';
+import { allOperationsOf } from './model.js';
+import { numericIntrinsicsOf } from './numeric-intrinsics.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+import { sharedStringLayoutsOf } from './string-layout-reuse.js';
+import { stringLengthReuseOf } from './string-length-reuse.js';
+import { typeQueryResultsOf } from './type-query-results.js';
+export const irBodyCensusOf = (body, policy) => {
+    const localIterators = localIteratorValuesOf(body);
+    const censused = deferrableValuesOf(body, policy.deferrableMemberRead, policy.forwarding);
+    const dead = deadValuesOf(body, policy.deadValues);
+    const unread = unreadValuesOf(body);
+    const booleanConstants = booleanConstantsOf(body);
+    policy.spellConstants();
+    // Mutable from here on: the three censuses below each claim values out of the
+    // deferral set, and a claimed value must not be deferred by anyone.
+    const deferrable = new Set(censused.values);
+    const typeQueries = typeQueryResultsOf(body, policy.stringQueryCell);
+    // A tag observes the value at the query/read site, even if a later call
+    // mutates the input. Do not turn a saved result into a repeated typeof.
+    for (const value of typeQueries.values)
+        deferrable.delete(value);
+    // Which `number` values may be held in a `long long`, before any rendering:
+    // storage is decided at a first write. See `ir/integers.ts`.
+    const narrowed = narrowableIntegersOf(body, policy.integerStorage);
+    const numericIntrinsics = numericIntrinsicsOf(body);
+    const remainderForms = new Map();
+    for (const [form, values] of remainderFormGroups(narrowed))
+        for (const value of values)
+            remainderForms.set(value, form);
+    // The two cell facts the forwarding census leaves to this sequence: a
+    // narrowed cell is `long long` storage and a type-query cell a saved tag,
+    // and a read spelled as the written expression would be neither.
+    const forwardedBindings = new Map();
+    for (const [declaration, forwarded] of censused.forwardedBindings) {
+        if (narrowed.bindings.has(declaration) || typeQueries.bindings.has(declaration))
+            continue;
+        forwardedBindings.set(declaration, forwarded);
+    }
+    const settled = {
+        localIterators,
+        deferrable,
+        callArgumentOnly: censused.consumedByCall,
+        forwardedBindings,
+        dead,
+        unread,
+        booleanConstants,
+        typeQueryValues: typeQueries.values,
+        typeQueryBindings: typeQueries.bindings,
+        typeQueryComparisons: typeQueries.comparisons,
+        integerValues: narrowed.values,
+        integerBindings: narrowed.bindings,
+        remainderForms,
+        numericCalls: numericIntrinsics.calls,
+        numericCallOnly: numericIntrinsics.callOnly
+    };
+    const stableFormals = policy.formalStorage(settled);
+    const loopInvariantValues = loopInvariantValuesOf(body);
+    const hoists = loopInvariantHoistsOf(body);
+    const sharedStringLayouts = sharedStringLayoutsOf(body, hoists, dead);
+    // A relocated value leaves the deferral census: a deferred value renders at
+    // its use -- the place inside the loop the move exists to get it out of.
+    const hoistedResults = new Set();
+    for (const value of hoists.relocated) {
+        deferrable.delete(value);
+        hoistedResults.add(value);
+    }
+    const reusedStringLengths = stringLengthReuseOf(body, stableFormals, new Set([...dead, ...hoists.relocated]));
+    // A reused result must be stored at its dominating definition, even if its
+    // original single consumer would otherwise defer that computation.
+    for (const prior of reusedStringLengths.values())
+        deferrable.delete(prior.value);
+    // Every census above that claimed a value out of `deferrable` may have taken
+    // a forwarding's written value or read with it; a forwarding whose halves no
+    // longer both defer would spell a value that now has storage of its own at
+    // a place that storage is not written yet.
+    for (const [declaration, forwarded] of forwardedBindings) {
+        if (!deferrable.has(forwarded.value.value) || !deferrable.has(forwarded.read))
+            forwardedBindings.delete(declaration);
+    }
+    return { ...settled, loopInvariantValues, hoists, hoistedResults, sharedStringLayouts, reusedStringLengths };
+};
+export const bodyValueOriginsOf = (body) => {
+    const computeOrigins = new Map();
+    const propertyReadOrigins = new Map();
+    const bindingReadDeclarations = new Map();
+    const conversionSources = new Map();
+    const callCallees = new Map();
+    const recordFieldSources = new Map();
+    const thunkValues = new Map();
+    const staticKeyTexts = new Map();
+    const reads = new Map();
+    const calleeReads = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            for (const operand of operandsOfIrOperation(operation)) {
+                reads.set(operand.value, (reads.get(operand.value) ?? 0) + 1);
+                if (operation.kind === 'call' && operand === operation.callee)
+                    calleeReads.set(operand.value, (calleeReads.get(operand.value) ?? 0) + 1);
+            }
+            if (operation.kind === 'compute')
+                computeOrigins.set(operation.result.id, operation);
+            else if (operation.kind === 'get')
+                propertyReadOrigins.set(operation.result.id, operation);
+            else if (operation.kind === 'binding-read')
+                bindingReadDeclarations.set(operation.result.id, operation.declaration);
+            else if (operation.kind === 'convert')
+                conversionSources.set(operation.result.id, operation.source);
+            else if (operation.kind === 'constant')
+                staticKeyTexts.set(operation.result.id, operation.text);
+            else if (operation.kind === 'call') {
+                if (operation.result)
+                    callCallees.set(operation.result.id, operation.callee.value);
+            }
+            else if (operation.kind === 'allocate-callable') {
+                const carrier = operation.result.representation;
+                const payload = carrier.kind === 'optional' ? carrier.payload : carrier;
+                if (payload.kind === 'function-value-dispatch' && payload.abi.parameters.length === 0 && payload.abi.receiver === null) {
+                    thunkValues.set(operation.result.id, operation.functionId);
+                }
+            }
+            else if (operation.kind === 'allocate-record') {
+                recordFieldSources.set(operation.result.id, new Map(operation.fields.map((field) => [field.key, field.value])));
+            }
+            else if (operation.kind === 'set' || operation.kind === 'define-own-property') {
+                const storedKey = staticKeyTexts.get(operation.key.value);
+                if (storedKey !== undefined) {
+                    const sources = new Map(recordFieldSources.get(operation.receiver.value) ?? []);
+                    sources.set(storedKey, operation.value);
+                    recordFieldSources.set(operation.receiver.value, sources);
+                    if (operation.result)
+                        recordFieldSources.set(operation.result.id, sources);
+                }
+            }
+        }
+    }
+    // The transitive closure needs its own fixed point: a value's read set is
+    // its own binding-read declaration (if any) unioned with every operand's
+    // already-settled read set, iterated until nothing grows.
+    const valueCellReads = new Map();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const block of body.blocks.values()) {
+            for (const operation of allOperationsOf(block)) {
+                const result = resultOfIrOperation(operation);
+                if (result === null)
+                    continue;
+                const current = valueCellReads.get(result.id);
+                const next = new Set(current ?? []);
+                const ownDeclaration = bindingReadDeclarations.get(result.id);
+                if (ownDeclaration !== undefined)
+                    next.add(ownDeclaration);
+                for (const operand of operandsOfIrOperation(operation)) {
+                    for (const declaration of valueCellReads.get(operand.value) ?? [])
+                        next.add(declaration);
+                }
+                if (current !== undefined && current.size === next.size)
+                    continue;
+                valueCellReads.set(result.id, next);
+                changed = true;
+            }
+        }
+    }
+    return {
+        computeOrigins,
+        propertyReadOrigins,
+        staticKeyTexts,
+        bindingReadDeclarations,
+        conversionSources,
+        callCallees,
+        calleeOnlyValues: new Set([...calleeReads].filter(([value, count]) => reads.get(value) === count).map(([value]) => value)),
+        recordFieldSources,
+        thunkValues,
+        valueCellReads
+    };
+};

package/dist/ir/fixed-data-definition.d.ts

@@ -0,0 +1,19 @@
+import type { ConversionNodeId } from '../conversion/algebra.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { DeclarationId } from '../identity/ids.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type RecordField, type Representation } from '../representation/model.js';
+import type { IrOperand } from './model.js';
+/** The descriptor's value and attribute reads are native fixed slots, not an unknown function invocation. */
+export interface FixedDataDefinitionRecipe {
+    readonly nativeFieldProtocol: 'unused' | 'required';
+    readonly target: string;
+    readonly descriptor: string;
+    readonly field: RecordField;
+    readonly held: Representation;
+    readonly value: RecordField;
+    readonly conversion: ConversionNodeId;
+    readonly attributes: readonly RecordField[];
+}
+export declare const fixedDataDefinitionRecipeOf: (args: readonly IrOperand[], key: string, result: Representation, deriver: RepresentationDeriver, classes: ReadonlyMap<DeclarationId, ClassLayout>, conversions: ConversionCensus, authenticated: boolean) => FixedDataDefinitionRecipe | null;

package/dist/ir/fixed-data-definition.js

@@ -0,0 +1,49 @@
+import { declaredFieldRepresentationOf, recordFieldsOfShape, nativeBaseFieldOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+export const fixedDataDefinitionRecipeOf = (args, key, result, deriver, classes, conversions, authenticated) => {
+    const target = args[0]?.representation;
+    const descriptor = args[2]?.representation;
+    if (!target || args.length !== 3 || descriptor?.kind !== 'record' || descriptor.accessors.length > 0)
+        return null;
+    if (representationKey(result) !== representationKey(target))
+        return null;
+    const fields = target.kind === 'record' || target.kind === 'record-with-index'
+        ? target.fields
+        : target.kind === 'class-ref' || (target.kind === 'native-record-ref' && target.native === null)
+            ? recordFieldsOfShape(deriver, target.shapeId)
+            : null;
+    const field = fields?.find((candidate) => candidate.key === key);
+    if (!field || nativeBaseFieldOf(deriver, target, key, classes))
+        return null;
+    const value = descriptor.fields.find((candidate) => candidate.key === 'value');
+    if (!value?.required)
+        return null;
+    const attributes = descriptor.fields.filter((candidate) => candidate.key !== 'value');
+    if (attributes.some((attribute) => !['writable', 'enumerable', 'configurable'].includes(attribute.key) ||
+        !attribute.required ||
+        attribute.value.kind !== 'scalar' ||
+        attribute.value.domain !== 'boolean'))
+        return null;
+    const held = declaredFieldRepresentationOf(deriver, target, key, classes);
+    if (!held)
+        return null;
+    const conversion = conversions.nodeFor(value.value, held);
+    // Dynamic adapters can publish the stored object's native protocol. They
+    // cannot support the closed effect claimed by this recipe.
+    if (conversion.capability.kind === 'never')
+        return null;
+    const closed = authenticated &&
+        (conversion.capability.kind === 'identity' ||
+            ((conversion.capability.kind === 'atom' || conversion.capability.kind === 'static') &&
+                conversion.capability.materializer.nativeFieldProtocol === 'unused'));
+    return {
+        nativeFieldProtocol: closed ? 'unused' : 'required',
+        target: representationKey(target),
+        descriptor: representationKey(descriptor),
+        field,
+        held,
+        value,
+        conversion: conversion.id,
+        attributes
+    };
+};

package/dist/ir/generator-split.d.ts

@@ -0,0 +1,38 @@
+import type { DeclarationId, PhysicalBodyId } from '../identity/ids.js';
+import type { BindingPlacement } from '../projection/bindings.js';
+import { type IrBody } from './model.js';
+/**
+ * Carves every generator body `ir/lower.ts` marked with a
+ * `generatorPrologueBoundary` into an ordinary OUTER function (the body's own
+ * declared signature, running `FunctionDeclarationInstantiation`'s prefix)
+ * that tail-calls a private INNER coroutine holding the rest.
+ *
+ * A C++20 coroutine cannot express the ECMA-262 split within one function
+ * (10.2.1 step 8 runs before 15.5.2's `GeneratorStart` ever suspends the
+ * body), so this stage physically splits one `IrBody` into two -- reusing
+ * the ordinary allocate-callable/call/return primitives so the split reads,
+ * to every later stage, exactly like an ordinary nested closure a body
+ * allocates and immediately invokes. Every declaration bound by the
+ * prologue that the rest of the body still needs gets its own, freshly
+ * minted, inner-owned copy -- see `bridgedDeclarationsOf` -- fed from the
+ * inner coroutine's own new ABI parameters rather than shared cell
+ * identity, which is exactly right: the two halves are different physical
+ * frames, and the value merely started out equal.
+ *
+ * Run once, after `lowerToIr` and before `shakeProgram`/`renderTranslationUnit`
+ * (`compiler.ts`), because it needs `placements` -- unavailable inside
+ * `lowerToIr` itself -- to give each bridged cell's inner copy an identity.
+ *
+ * Every step here is deliberately conservative: any shape this module is not
+ * certain it carves correctly (a try region straddling the cut, a value
+ * crossing the boundary some other way than through a bridged declaration, a
+ * hand-built body that fails IR verification) refuses the split for that one
+ * owner and leaves its original, unsplit body exactly as `lowerToIr` produced
+ * it -- a body that still miscompiles the ECMA-262 timing this module exists
+ * to fix, never one that compiles to something silently wrong.
+ */
+export interface GeneratorSplitResult {
+    readonly bodies: ReadonlyMap<PhysicalBodyId, IrBody>;
+    readonly placements: ReadonlyMap<DeclarationId, BindingPlacement>;
+}
+export declare const splitGeneratorBodies: (bodies: ReadonlyMap<PhysicalBodyId, IrBody>, placements: ReadonlyMap<DeclarationId, BindingPlacement>) => GeneratorSplitResult;

package/dist/ir/generator-split.js

@@ -0,0 +1,329 @@
+import { irValueId, physicalBodyId } from '../identity/ids.js';
+import { passingOf } from '../representation/model.js';
+import { defaultOwnershipPolicy } from '../representation/policies.js';
+import { allOperationsOf, irBlockId } from './model.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+import { verifyIrBody } from './verify.js';
+export const splitGeneratorBodies = (bodies, placements) => {
+    const nextBodies = new Map(bodies);
+    let nextPlacements = placements;
+    for (const body of bodies.values()) {
+        const boundary = body.generatorPrologueBoundary;
+        if (!boundary)
+            continue;
+        const split = splitOneGeneratorBody(body, boundary, nextPlacements);
+        if (!split)
+            continue;
+        nextBodies.set(split.outer.owner, split.outer);
+        nextBodies.set(split.inner.owner, split.inner);
+        nextPlacements = split.placements;
+    }
+    return { bodies: nextBodies, placements: nextPlacements };
+};
+/** Every `DeclarationId` a `binding-read`/`binding-write` operation names, across a set of operations. */
+const declarationsTouchedBy = (operations) => {
+    const found = new Set();
+    for (const operation of operations) {
+        if (operation.kind === 'binding-read' || operation.kind === 'binding-write')
+            found.add(operation.declaration);
+    }
+    return found;
+};
+/** A `binding-read`/`binding-write` operation with its declaration swapped for the inner coroutine's own copy; every other kind is returned unchanged (terminators never name a declaration directly). */
+const rewriteDeclaration = (operation, remap) => {
+    if (operation.kind !== 'binding-read' && operation.kind !== 'binding-write')
+        return operation;
+    const to = remap.get(operation.declaration);
+    return to === undefined ? operation : { ...operation, declaration: to };
+};
+const valuesIndexOf = (blocks) => {
+    const values = new Map();
+    for (const block of blocks) {
+        for (const operation of allOperationsOf(block)) {
+            const result = resultOfIrOperation(operation);
+            if (result)
+                values.set(result.id, result.representation);
+        }
+    }
+    return values;
+};
+/** Whether every operand any of `operations` reads is defined by one of `operations` itself -- the generic guard against a value crossing the cut some way other than through a bridged declaration (a cached `receiver`, or any other reuse this module did not anticipate). */
+const isSelfContained = (blocks, iteratorCloseRegions) => {
+    const defined = new Set();
+    for (const block of blocks)
+        for (const operation of allOperationsOf(block)) {
+            const result = resultOfIrOperation(operation);
+            if (result)
+                defined.add(result.id);
+        }
+    for (const block of blocks) {
+        for (const operation of allOperationsOf(block)) {
+            for (const operand of operandsOfIrOperation(operation))
+                if (!defined.has(operand.value))
+                    return false;
+        }
+    }
+    for (const region of iteratorCloseRegions)
+        if (!defined.has(region.iterator.value))
+            return false;
+    return true;
+};
+const splitOneGeneratorBody = (body, boundary, placements) => {
+    const abi = body.abi;
+    // Void is impossible for a real generator (it always hands back an
+    // Iterator), and `construct` never applies to one (`new` on a generator
+    // function throws) -- both are defensive refusals for a shape this body
+    // cannot actually have, not a case this module means to support.
+    if (!abi || abi.result.kind === 'void' || body.construct)
+        return null;
+    const cutBlock = body.blocks.get(boundary.block);
+    if (!cutBlock)
+        return null;
+    // A try/catch/finally cannot lexically wrap a parameter list, so every
+    // region belongs entirely to the rest of the body -- UNLESS the try
+    // statement is the very first thing after the parameters and its own
+    // entry was scheduled into the same block the last default's merge lands
+    // in, in which case this module cannot tell "outer" and "inner" apart for
+    // that one block by original id alone. Refuse rather than guess.
+    const boundaryTouchesRegion = body.tryRegions.some((region) => region.tryEntry === boundary.block ||
+        region.catchEntry === boundary.block ||
+        region.finallyEntry === boundary.block ||
+        region.finallyExit === boundary.block ||
+        region.join === boundary.block);
+    if (boundaryTouchesRegion)
+        return null;
+    // IteratorClose regions are lexical C++ scopes too. A region whose block
+    // interval touches the split block cannot be divided at an operation index
+    // without also splitting its guard lifetime, so refuse that optimization
+    // rather than silently dropping or widening cleanup. Regions wholly on one
+    // side are preserved below with their original block identities.
+    const boundaryTouchesIteratorCloseRegion = (body.iteratorCloseRegions ?? []).some((region) => region.entry === boundary.block || region.blocks.includes(boundary.block) || region.dismissTargets.includes(boundary.block));
+    if (boundaryTouchesIteratorCloseRegion)
+        return null;
+    const headOperations = cutBlock.operations.slice(0, boundary.operationIndex);
+    const tailOperations = cutBlock.operations.slice(boundary.operationIndex);
+    const restBlockIds = body.blockOrder.filter((id) => !boundary.outerBlocks.has(id));
+    const restBlockIdSet = new Set(restBlockIds);
+    const outerRegions = [];
+    const innerRegions = [];
+    for (const region of body.tryRegions) {
+        const refs = [region.tryEntry, region.catchEntry, region.finallyEntry, region.finallyExit, region.join].filter((ref) => ref !== null);
+        const allOuter = refs.every((ref) => boundary.outerBlocks.has(ref));
+        const allInner = refs.every((ref) => restBlockIdSet.has(ref));
+        if (allOuter)
+            outerRegions.push(region);
+        else if (allInner)
+            innerRegions.push(region);
+        else
+            return null;
+    }
+    const outerIteratorCloseRegions = [];
+    const innerIteratorCloseRegions = [];
+    for (const region of body.iteratorCloseRegions ?? []) {
+        const refs = [region.entry, ...region.blocks, ...region.dismissTargets];
+        const allOuter = refs.every((ref) => boundary.outerBlocks.has(ref));
+        const allInner = refs.every((ref) => restBlockIdSet.has(ref));
+        if (allOuter)
+            outerIteratorCloseRegions.push(region);
+        else if (allInner)
+            innerIteratorCloseRegions.push(region);
+        else
+            return null;
+    }
+    // Every declaration the prologue's own outer half writes, that the rest of
+    // the body still reads or writes: the cells the inner coroutine needs its
+    // own copy of. A declaration outer writes but rest never touches is purely
+    // internal to the prologue (a default's own guard test, say) and needs no
+    // bridge; one rest introduces itself (`var it = ...`) is already its own,
+    // ordinary inner-owned local and needs no bridge either.
+    const outerWritten = new Set();
+    for (const id of boundary.outerBlocks) {
+        if (id === boundary.block)
+            continue;
+        const block = body.blocks.get(id);
+        if (block)
+            for (const operation of block.operations)
+                if (operation.kind === 'binding-write')
+                    outerWritten.add(operation.declaration);
+    }
+    for (const operation of headOperations)
+        if (operation.kind === 'binding-write')
+            outerWritten.add(operation.declaration);
+    const restOperationsFlat = [...tailOperations, cutBlock.terminator];
+    for (const id of restBlockIds) {
+        const block = body.blocks.get(id);
+        if (block)
+            restOperationsFlat.push(...allOperationsOf(block));
+    }
+    const restReferenced = declarationsTouchedBy(restOperationsFlat);
+    const bridged = [...outerWritten].filter((id) => restReferenced.has(id));
+    const bridgedRepresentations = new Map();
+    for (const id of bridged) {
+        const representation = placements.get(id)?.representation;
+        if (!representation || representation.kind === 'unresolved')
+            return null;
+        bridgedRepresentations.set(id, representation);
+    }
+    const needsReceiver = restOperationsFlat.some((operation) => operation.kind === 'receiver');
+    // A `receiver` operation with no receiver of THIS body's own ABI is a
+    // relayed, captured `this` from an enclosing frame -- a real shape, but not
+    // one this module bridges (see the file comment): refuse rather than drop
+    // the read silently.
+    if (needsReceiver && abi.receiver === null)
+        return null;
+    const innerOwnerId = `${body.sourceOwner}#generator-inner`;
+    const innerPhysicalBodyId = physicalBodyId(innerOwnerId, 'default');
+    const innerDeclarationOf = new Map(bridged.map((id) => [id, `${id}@generator-inner`]));
+    // Every other ABI in this compiler picks a parameter's passing mode from the
+    // representation's OWN ownership (`representation/policies.ts`'s
+    // `defaultOwnershipPolicy.forParameter`, the one every real function's ABI
+    // is derived with, `representation/derive.ts`'s `abiOf`) -- `owned` is only
+    // the fallback for a carrier that states no ownership of its own (a scalar,
+    // a string). Hardcoding `owned` here disagreed with that for every
+    // refcounted carrier (`array-object`, `record`, `class-ref`, a keyed
+    // collection...): the OUTER half still reads the bridged cell as whatever it
+    // is actually stored as -- `gea::Ref<gea::ArrayObject<double>>` for a
+    // `shared-refcount` array -- and passes that to the call, while this
+    // declared the inner coroutine's formal as the bare, unwrapped carrier
+    // (`gea::ArrayObject<double>`), a frame mismatch clang reports as "no
+    // matching function for call". The call's argument and the declaration it
+    // targets must agree on the SAME ownership, exactly as `cppAbiParameterType`
+    // assumes everywhere else.
+    const innerAbi = {
+        parameters: bridged.map((id) => {
+            const value = bridgedRepresentations.get(id);
+            const parameterOwnership = defaultOwnershipPolicy.forParameter(value);
+            return { value, ownership: parameterOwnership, passing: passingOf(value, parameterOwnership) };
+        }),
+        result: abi.result,
+        receiver: needsReceiver ? abi.receiver : null,
+        restFrom: null
+    };
+    const lineage = headOperations[headOperations.length - 1]?.lineage ?? tailOperations[0]?.lineage ?? cutBlock.terminator.lineage;
+    if (!lineage)
+        return null;
+    // The inner coroutine's own entry: one `parameter` + `binding-write` pair
+    // per bridged cell, in the SAME order `innerAbi.parameters` declares them,
+    // followed by the rest of the body exactly as it was -- reachable rewrites
+    // and all.
+    let innerOrdinal = 0;
+    const innerEntryOperations = [];
+    bridged.forEach((id, ordinal) => {
+        const representation = bridgedRepresentations.get(id);
+        const paramResult = irValueId(innerPhysicalBodyId, innerOrdinal++);
+        innerEntryOperations.push({ kind: 'parameter', lineage, ordinal, result: { id: paramResult, representation } });
+        innerEntryOperations.push({
+            kind: 'binding-write',
+            lineage,
+            declaration: innerDeclarationOf.get(id),
+            value: { value: paramResult, representation }
+        });
+    });
+    for (const operation of tailOperations)
+        innerEntryOperations.push(rewriteDeclaration(operation, innerDeclarationOf));
+    const innerEntryTerminator = cutBlock.terminator;
+    const innerEntryBlockId = irBlockId(innerPhysicalBodyId, 0);
+    const innerEntryBlock = { id: innerEntryBlockId, operations: innerEntryOperations, terminator: innerEntryTerminator };
+    const innerRestBlocks = restBlockIds.map((id) => {
+        const block = body.blocks.get(id);
+        if (!block)
+            throw new Error(`generator split: body ${body.owner} lists block ${id} in blockOrder but has no matching block`);
+        return {
+            id,
+            operations: block.operations.map((operation) => rewriteDeclaration(operation, innerDeclarationOf)),
+            terminator: block.terminator
+        };
+    });
+    const innerBlockOrder = [innerEntryBlockId, ...restBlockIds];
+    const innerBlocks = new Map([
+        [innerEntryBlockId, innerEntryBlock],
+        ...innerRestBlocks.map((block) => [block.id, block])
+    ]);
+    const allInnerBlocks = [innerEntryBlock, ...innerRestBlocks];
+    if (!isSelfContained(allInnerBlocks, innerIteratorCloseRegions))
+        return null;
+    const inner = {
+        owner: innerPhysicalBodyId,
+        sourceOwner: innerOwnerId,
+        abi: innerAbi,
+        construct: null,
+        generator: true,
+        entry: innerEntryBlockId,
+        blocks: innerBlocks,
+        blockOrder: innerBlockOrder,
+        values: valuesIndexOf(allInnerBlocks),
+        tryRegions: innerRegions,
+        iteratorCloseRegions: innerIteratorCloseRegions
+    };
+    // The outer half: the same declared signature, ending where the boundary
+    // says to -- an allocation of the inner coroutine (rendered, like any
+    // other never-escaping closure allocation, as a direct call -- see
+    // `targets/cpp/emit.ts`'s `registerDirectCalleeOfDeadValue`), a read of
+    // every bridged cell's CURRENT value, and a call forwarding them, whose
+    // result this returns unchanged.
+    const outerBlocksList = body.blockOrder.filter((id) => boundary.outerBlocks.has(id));
+    let outerOrdinal = 0;
+    const nextOuterValue = () => irValueId(body.owner, 1_000_000 + outerOrdinal++);
+    const extraOuterOperations = [];
+    const calleeRepresentation = { kind: 'function', functionId: innerOwnerId, abi: innerAbi };
+    const calleeResult = nextOuterValue();
+    extraOuterOperations.push({
+        kind: 'allocate-callable',
+        lineage,
+        functionId: innerOwnerId,
+        captures: [],
+        result: { id: calleeResult, representation: calleeRepresentation }
+    });
+    let receiverOperand = null;
+    if (needsReceiver && abi.receiver !== null) {
+        const receiverRepresentation = abi.receiver;
+        const receiverResult = nextOuterValue();
+        extraOuterOperations.push({ kind: 'receiver', lineage, result: { id: receiverResult, representation: receiverRepresentation } });
+        receiverOperand = { value: receiverResult, representation: receiverRepresentation };
+    }
+    const argumentOperands = bridged.map((id) => {
+        const representation = bridgedRepresentations.get(id);
+        const readResult = nextOuterValue();
+        extraOuterOperations.push({ kind: 'binding-read', lineage, declaration: id, result: { id: readResult, representation } });
+        return { value: readResult, representation };
+    });
+    const callResult = nextOuterValue();
+    extraOuterOperations.push({
+        kind: 'call',
+        lineage,
+        callee: { value: calleeResult, representation: calleeRepresentation },
+        receiver: receiverOperand,
+        arguments: argumentOperands,
+        result: { id: callResult, representation: abi.result }
+    });
+    const outerCutBlock = {
+        id: boundary.block,
+        operations: [...headOperations, ...extraOuterOperations],
+        terminator: { kind: 'return', lineage: null, value: { value: callResult, representation: abi.result } }
+    };
+    const outerBlocks = new Map(outerBlocksList.map((id) => [id, id === boundary.block ? outerCutBlock : body.blocks.get(id)]));
+    const allOuterBlocks = outerBlocksList.map((id) => outerBlocks.get(id));
+    if (!isSelfContained(allOuterBlocks, outerIteratorCloseRegions))
+        return null;
+    const outer = {
+        ...body,
+        generator: false,
+        generatorPrologueBoundary: null,
+        blockOrder: outerBlocksList,
+        blocks: outerBlocks,
+        values: valuesIndexOf(allOuterBlocks),
+        tryRegions: outerRegions,
+        iteratorCloseRegions: outerIteratorCloseRegions
+    };
+    const violations = [...verifyIrBody(outer), ...verifyIrBody(inner)];
+    if (violations.length > 0)
+        return null;
+    const nextPlacements = new Map(placements);
+    for (const [originalId, newId] of innerDeclarationOf) {
+        nextPlacements.set(newId, {
+            storage: { kind: 'local', owner: innerOwnerId },
+            representation: bridgedRepresentations.get(originalId) ?? null
+        });
+    }
+    return { outer, inner, placements: nextPlacements };
+};