@geastack/compiler 1.0.15

package/dist/ir/lower-operands.js

@@ -0,0 +1,461 @@
+import { detachedMethodAbiOf, isClosedContiguousTupleRecord } from '../projection/callee.js';
+import { classMemberOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+import { operandOf, resultOf } from '../semantics/model/operands.js';
+import { anchorResultOf, IrLoweringBlockedError, requireRepresentation } from './lower-graph.js';
+/**
+ * Whether a property read's receiver+key names a field an installed plugin
+ * declared a reactive cell.
+ *
+ * Answered once, here, at the point a `get` is about to be built
+ * (`lower-property.ts`, `lower-destructuring.ts`'s object-pattern step) --
+ * see `GetOperation.reactive` for why this belongs on the operation instead
+ * of being re-asked from a table the target does not publish until struct
+ * rendering. `classMemberOf` finds the field's DECLARING class along the
+ * inheritance chain, which is the class `reactiveFields` is keyed by (own
+ * fields only -- `component-classes.ts`'s `GeaReactiveFields`); a receiver
+ * that is not a class at all (a record, a dictionary, ...) answers `false`
+ * without a lookup, since the plugin's table only ever names class fields.
+ */
+export const reactiveFieldReadOf = (classes, receiver, key, reactiveFields) => {
+    if (receiver.kind !== 'class-ref')
+        return false;
+    const site = classMemberOf(classes, receiver.declaration, key);
+    return site !== null && site.kind === 'field' && reactiveFields.get(site.owner)?.has(key) === true;
+};
+export const describeOperand = (operand) => `operand "${operand.role}"#${operand.ordinal}`;
+/** The ABI projection's stated reason, ready to append to a refusal, or nothing when it stated none. */
+const abiRefusalOf = (ctx) => ctx.abiRefusal === null ? '' : `; the ABI projection refused this convention because ${ctx.abiRefusal}`;
+/** A published result's carrier plus the SSA id already minted for it -- the only legal source for an operand that names a prior result. */
+export const resolveResultValue = (ctx, result, describe) => {
+    const value = ctx.values.get(result);
+    if (!value) {
+        throw new IrLoweringBlockedError(`${describe} references result ${result}, which was not lowered in this owner ` +
+            '(a value produced by a different owner needs capture lowering, which is not supported yet)');
+    }
+    return { value, representation: requireRepresentation(ctx.plan, result, describe) };
+};
+export const resolveRequiredOperand = (ctx, block, lineage, operand) => {
+    const source = operand.source;
+    if (source.kind === 'absent')
+        throw new IrLoweringBlockedError(`${describeOperand(operand)} is absent where a value is required`);
+    // A result whose carrier is `void` minted no SSA name (`namesVoidResult`),
+    // and an operand that reads one -- `let u: number | void = f()`, `return
+    // f()` in a valued function, `g(f())` -- is a STORED position, where the
+    // language's value for "nothing" is `undefined`
+    // (`representation/primitives.ts`'s `storedCarrier`, the same rule the
+    // representations apply to every nested `void`). A consumer that can
+    // genuinely take nothing (`return f()` in a `void` function, an expression
+    // statement) asks `namesVoidResult` itself before resolving. A `never`-typed
+    // result shares the void carrier and is the opposite fact -- the point past
+    // `return Debug.fail(...)` is unreachable, not undefined -- so it keeps
+    // refusing here; its consumers (`emit-return.ts`) render the point as
+    // `gea::host::unreachableValue<T>()` from the absence of a value.
+    if (source.kind === 'result' && namesVoidResult(ctx, operand) && !ctx.constantDeriver.isNeverType(operand.type)) {
+        const absent = { kind: 'undefined' };
+        return { value: ctx.builder.constant(block, lineage, 'undefined', 'undefined', absent), representation: absent };
+    }
+    if (source.kind === 'result')
+        return resolveResultValue(ctx, source.result, describeOperand(operand));
+    if (source.kind === 'parameter') {
+        // The carrier comes from the ABI slot, not from the operand's own type: the
+        // ABI is what the caller pushed, and a body that read the slot as anything
+        // else would be reading a frame nobody wrote.
+        const declared = ctx.abi?.parameters[source.ordinal];
+        if (!declared) {
+            throw new IrLoweringBlockedError(`${describeOperand(operand)} reads ABI position ${source.ordinal}, which this body's calling convention does not declare` +
+                abiRefusalOf(ctx));
+        }
+        return {
+            value: ctx.builder.parameter(block, lineage, source.ordinal, declared.value),
+            representation: declared.value
+        };
+    }
+    if (source.kind === 'receiver') {
+        // Same rule as a parameter: the carrier is normally the one the
+        // convention declares, because that is what the caller pushed. A body
+        // with no convention has no receiver at all, and reading one would
+        // ordinarily invent a frame slot -- except for the one role
+        // `semantics/normalize/producers/references.ts`'s `buildThisReference`
+        // mints when it has already proven the read resolves to an *enclosing*
+        // class's own instance: `this` inside an arrow, captured across the
+        // function-object boundary that arrow's allocation crosses. That proof
+        // lives in the operand's own role, not re-derived here: an ordinary,
+        // undeclared `receiver` role still refuses exactly as it always has, and
+        // only the producer-verified `captured-receiver` role derives a carrier
+        // from the operand's own type -- the same field the enclosing class's own
+        // receiver representation is itself derived from
+        // (`representation/derive.ts`'s `signature.thisParameter`), so the two
+        // agree by construction rather than by coincidence.
+        const declared = ctx.abi?.receiver;
+        if (declared)
+            return { value: ctx.builder.receiver(block, lineage, declared), representation: declared };
+        if (operand.role === 'static-class-receiver') {
+            const representation = ctx.constantDeriver.derive(operand.type);
+            const declaration = representation.kind === 'constructor-family' && representation.members.length === 1 ? representation.members[0] : null;
+            if (!declaration) {
+                throw new IrLoweringBlockedError(`${describeOperand(operand)} denotes a static block's class value, but its carrier is ` +
+                    `"${representationKey(representation)}" rather than one exact constructor-family`);
+            }
+            return {
+                value: ctx.builder.allocateConstructor(block, lineage, declaration, [], representation),
+                representation
+            };
+        }
+        if (operand.role !== 'captured-receiver') {
+            throw new IrLoweringBlockedError(`${describeOperand(operand)} reads the frame's receiver, which this body's calling convention does not declare` + abiRefusalOf(ctx));
+        }
+        const representation = ctx.constantDeriver.derive(operand.type);
+        if (representation.kind === 'unresolved') {
+            throw new IrLoweringBlockedError(`${describeOperand(operand)} captures the enclosing receiver, and no carrier is derivable for it: ${representation.reason}`);
+        }
+        return { value: ctx.builder.receiver(block, lineage, representation), representation };
+    }
+    const representation = ctx.constantDeriver.derive(operand.type);
+    if (representation.kind === 'unresolved') {
+        throw new IrLoweringBlockedError(`${describeOperand(operand)} has no derivable carrier: ${representation.reason}`);
+    }
+    return { value: ctx.builder.constant(block, lineage, source.text, source.literal, representation), representation };
+};
+export const resolveOptionalOperand = (ctx, block, lineage, operand) => {
+    if (!operand || operand.source.kind === 'absent')
+        return null;
+    return resolveRequiredOperand(ctx, block, lineage, operand);
+};
+/**
+ * Whether an operand names a result whose carrier is `void`.
+ *
+ * `void` is the carrier for "there is no value": a call that returns it mints
+ * no SSA id at all (`build.ts`'s `mintOptionalResult`). So an operand naming
+ * one cannot be resolved, and a consumer that can legitimately have nothing --
+ * `return f()` in a `void` function, which C++ spells the same way -- has to
+ * ask before resolving rather than be refused for a value that was correctly
+ * never minted.
+ */
+export const namesVoidResult = (ctx, operand) => operand?.source.kind === 'result' && ctx.plan.selected.get(operand.source.result)?.kind === 'void';
+export const namedOperand = (operation, role, ordinal = 0) => {
+    const found = operandOf(operation, role, ordinal);
+    if (!found)
+        throw new IrLoweringBlockedError(`a ${operation.family} operation has no "${role}" operand to lower`);
+    return found;
+};
+export const orderedOperandsOf = (operation, role) => operation.operands.filter((operand) => operand.role === role).sort((left, right) => left.ordinal - right.ordinal);
+/** The one non-provenance operand of an operation that has exactly one, when no operand is explicitly named `value`. */
+export const singleValueOperand = (operation) => {
+    const named = operandOf(operation, 'value', 0);
+    if (named)
+        return named;
+    const runtime = operation.operands.filter((operand) => operand.evaluation.kind !== 'provenance');
+    const only = runtime.length === 1 ? runtime[0] : undefined;
+    if (only)
+        return only;
+    throw new IrLoweringBlockedError(`a ${operation.family} operation has no unambiguous value operand to lower`);
+};
+export const requireLineage = (operation) => {
+    const anchor = anchorResultOf(operation);
+    if (!anchor)
+        throw new IrLoweringBlockedError(`a ${operation.family} operation published no semantic result for the IR to cite as lineage`);
+    return anchor;
+};
+export const optionalResultRepresentation = (ctx, operation, role) => {
+    const result = resultOf(operation, role);
+    return result ? requireRepresentation(ctx.plan, result.id, `result ${result.id}`) : null;
+};
+export const requireResultRepresentation = (ctx, operation, role, describe) => {
+    const result = resultOf(operation, role);
+    if (!result)
+        throw new IrLoweringBlockedError(`${describe} published no "${role}" result`);
+    return requireRepresentation(ctx.plan, result.id, describe);
+};
+/** Registers the SSA id an operation's own IR lowering just produced under the same anchor `requireLineage` would cite for it. */
+/**
+ * A value in exactly the carrier a slot declares.
+ *
+ * The one place lowering converts. A consumer that needs an operand in its
+ * slot's carrier asks here rather than converting on its own, so every
+ * `convert` in the IR names a node of the conversion census -- the same node
+ * the certificate checks and the printer renders -- and no consumer decides a
+ * pair for itself. Identity is no conversion at all: the operand is handed
+ * back untouched, so a slot that already agrees costs nothing in the IR.
+ */
+export const convertTo = (ctx, block, lineage, operand, slot, via = 'slot') => {
+    if (representationKey(operand.representation) === representationKey(slot))
+        return operand;
+    const node = ctx.program.conversions.nodeFor(operand.representation, slot);
+    if (node.capability.kind === 'never')
+        return null;
+    const value = ctx.builder.convert(block, lineage, node.id, operand, slot);
+    traceSpeculativeLoad(lineage, via, node, value);
+    return { value, representation: slot };
+};
+/**
+ * Diagnostic only, under `GEA_SPECULATIVE_LOADS`: every classifier-gated load
+ * lowering minted, with the site that asked for it, so the loads no presence
+ * or membership proof stands behind can be counted by site.
+ */
+export const speculativeLoads = [];
+const tracingSpeculativeLoads = process.env.GEA_SPECULATIVE_LOADS !== undefined;
+const traceSpeculativeLoad = (lineage, via, node, value) => {
+    if (tracingSpeculativeLoads && node.capability.kind === 'atom')
+        speculativeLoads.push({ lineage, via, node, value });
+};
+/**
+ * An operand as its consumer's slot wants it: resolved, then converted into
+ * the slot's carrier when the census names one. A raw operand -- a key, a
+ * callee, a condition, an argument to a host member the printer spells from
+ * its own carrier -- is handed back as it arrived; so is an operand whose
+ * pair the census cannot convert, which is recorded in `program.drift` and
+ * left to the printer's own path (see `LoweringProgram.drift`).
+ */
+export const enter = (ctx, block, lineage, operation, operand, resolved) => {
+    const answer = ctx.program.slots.slotOf(operation, operand);
+    if (answer.kind === 'coerce') {
+        // The census named an abstract operation, not a store: the node comes from
+        // the coercion table, and a `never` there is drift the printer refuses by
+        // name at the operator (no mixed-carrier spelling exists any more).
+        const node = ctx.program.conversions.coercionFor(resolved.representation, answer.operation);
+        if (node.capability.kind === 'identity')
+            return resolved;
+        if (node.capability.kind === 'never') {
+            recordDrift(ctx, block, operation.id, operand.role, operand.ordinal, resolved.representation, node.target, node);
+            return resolved;
+        }
+        return { value: ctx.builder.convert(block, lineage, node.id, resolved, node.target), representation: node.target };
+    }
+    if (answer.kind !== 'slot')
+        return resolved;
+    const bound = bindDetachedMethod(ctx, block, lineage, resolved, answer.representation);
+    if (bound !== null)
+        return bound;
+    // An `alias` slot is a VIEW the consuming lowering builds itself -- an
+    // object-source step's frozen view, an array pattern's cursor -- not a value
+    // converted on the way in; converting here would hand the view builder a
+    // value it then re-viewed.
+    if (answer.source === 'alias')
+        return resolved;
+    const entered = convertTo(ctx, block, lineage, resolved, answer.representation);
+    if (entered !== null)
+        return entered;
+    recordDrift(ctx, block, operation.id, operand.role, operand.ordinal, resolved.representation, answer.representation);
+    return resolved;
+};
+/** The row `LoweringProgram.drift` keeps for a pair the census has no recipe for. */
+const recordDrift = (ctx, block, operation, role, ordinal, source, slot, node = ctx.program.conversions.nodeFor(source, slot)) => {
+    ctx.program.drift.push({
+        block,
+        operation,
+        role,
+        ordinal,
+        source: representationKey(source),
+        slot: representationKey(slot),
+        reason: node.capability.kind === 'never' ? node.capability.reason : node.capability.kind,
+        sourceRepresentation: source,
+        slotRepresentation: slot
+    });
+};
+/**
+ * A conversion the lowering itself decides on rather than one a slot asks
+ * for -- a receiver's narrowed view, a dead merge arm's absence, the thrown
+ * carrier, an omitted formal's `undefined`: the census node for the pair,
+ * named on the `convert` instruction like every slot-driven conversion. A
+ * pair the census cannot convert is recorded as drift under the given role
+ * and STILL minted, because the consumer needs the value in `target` (a phi
+ * arm, a `throw`) and the printer's own chain is what answers such a pair
+ * until the census does. Every `convert` a lowering mints goes through here
+ * or `convertTo`: a hand-built use id named a conversion no census had
+ * counted, which is how a pair certified under one authority and refused
+ * under another.
+ */
+export const convertOrDrift = (ctx, block, lineage, operation, role, ordinal, operand, target, via = 'lowering') => {
+    const converted = convertTo(ctx, block, lineage, operand, target, via);
+    if (converted !== null)
+        return converted;
+    recordDrift(ctx, block, operation, role, ordinal, operand.representation, target);
+    const node = ctx.program.conversions.nodeFor(operand.representation, target);
+    return { value: ctx.builder.convert(block, lineage, node.id, operand, target), representation: target };
+};
+/**
+ * A method value entering a receiver-less slot, bound to the object it was
+ * read from -- the receiver converted into the convention's own receiver
+ * carrier first, the way any receiver enters a frame. `null` when the pair is
+ * not that, or when the value's origin is not a method read this body saw.
+ */
+const bindDetachedMethod = (ctx, block, lineage, resolved, slot) => {
+    const abi = detachedMethodAbiOf(resolved.representation, slot);
+    if (abi === null || abi.receiver === null)
+        return null;
+    const origin = ctx.program.methodValueReceivers.get(resolved.value);
+    if (origin === undefined)
+        return null;
+    const receiver = convertTo(ctx, block, lineage, origin.receiver, abi.receiver) ?? origin.receiver;
+    return {
+        value: ctx.builder.bindCallable(block, lineage, resolved, origin.method, abi, null, receiver, [], slot, true),
+        representation: slot
+    };
+};
+/**
+ * A binding read in the carrier the plan selected for it, which is the cell's
+ * own carrier or a narrowing of it: `x` read as `string` out of a cell placed
+ * `optional(string)` behind the guard that proved it present. The read itself
+ * yields the cell's carrier and the narrowing is a `convert` the conversion
+ * census names, exactly as a store into the cell converts the other way. A
+ * pair the census cannot convert is recorded as drift and the read is minted
+ * in the selected carrier for the printer's own path to narrow.
+ */
+export const narrowedBindingRead = (ctx, block, lineage, operation, declaration, representation) => {
+    const placement = ctx.program.slots.input.placements.get(declaration);
+    const storage = placement?.storage.kind;
+    const held = placement && (storage === 'local' || storage === 'region' || storage === 'external') ? placement.representation : null;
+    // `resolvedBinding` is the ONLY route a field's own declaration reaches a
+    // binding read (`lower-property.ts`); an ordinary lexical variable's
+    // declaration is never a key of `reactiveFieldDeclarations`, so this is a
+    // no-op lookup for every other caller of this function.
+    const reactive = ctx.program.reactiveFieldDeclarations.has(declaration);
+    if (held === null || representationKey(held) === representationKey(representation)) {
+        return ctx.builder.bindingRead(block, lineage, declaration, representation, reactive);
+    }
+    const node = ctx.program.conversions.nodeFor(held, representation);
+    if (node.capability.kind === 'never') {
+        recordDrift(ctx, block, operation.id, 'read', 0, held, representation);
+        return ctx.builder.bindingRead(block, lineage, declaration, representation, reactive);
+    }
+    const raw = ctx.builder.bindingRead(block, lineage, declaration, held, reactive);
+    const value = ctx.builder.convert(block, lineage, node.id, { value: raw, representation: held }, representation);
+    traceSpeculativeLoad(lineage, 'read', node, value);
+    return value;
+};
+/** `resolveRequiredOperand` followed by `enter`, for the consumers whose operand is a value in a slot. */
+export const enterRequiredOperand = (ctx, block, lineage, operation, operand) => enter(ctx, block, lineage, operation, operand, resolveRequiredOperand(ctx, block, lineage, operand));
+export const registerResult = (ctx, operation, value) => {
+    if (value === null)
+        return;
+    const anchor = anchorResultOf(operation);
+    if (anchor)
+        ctx.values.set(anchor, value);
+};
+export { abiOfCallee, constructAbiOfCallee } from '../projection/callee.js';
+/**
+ * The named fields a record carrier lays out.
+ *
+ * A record type written inline (`function Row(props: {label: string})`) carries
+ * its fields directly; one written as a named interface is carried *by name*,
+ * because that is what makes a self-referential type finite -- so its layout
+ * lives in the sealed structural table and is read back by deriving the shape
+ * the reference names. Both are the same physical object; only the carrier
+ * differs, and a lowering that handled just the first would refuse an ordinary
+ * `interface RowProps` for no reason the program could act on.
+ */
+export const recordLayoutOf = (ctx, props) => {
+    if (props.kind === 'record')
+        return props.fields;
+    if (props.kind !== 'native-record-ref')
+        return null;
+    const resolved = ctx.constantDeriver.layoutOf(props.shapeId);
+    return resolved.kind === 'record' ? resolved.fields : null;
+};
+export const packRestArguments = (ctx, block, lineage, operation, abi, passed) => {
+    let args = passed;
+    const firstSpread = args.findIndex((slot) => slot.kind === 'spread');
+    if (!abi || abi.restFrom === null) {
+        if (firstSpread >= 0) {
+            throw new IrLoweringBlockedError('a call range-copies a spread argument into a convention that declares no rest slot; a spread contributes a runtime number of ' +
+                'values and there is no fixed formal for them to land in');
+        }
+        return args.map((slot) => slot.value);
+    }
+    const slot = abi.parameters[abi.restFrom];
+    if (!slot) {
+        throw new IrLoweringBlockedError('a variadic convention declares no parameter at its own rest position and cannot be packed');
+    }
+    if (firstSpread >= 0 && firstSpread < abi.restFrom) {
+        throw new IrLoweringBlockedError(`a call range-copies a spread argument at position ${firstSpread}, before this convention's rest slot at ${abi.restFrom}; ` +
+            'only the rest tail can absorb a runtime number of values');
+    }
+    // A call may pass fewer arguments than the convention names before its rest
+    // slot -- `verifyProperty(obj, name, desc)` against `(obj, name, desc,
+    // options, ...args)`, where the phantom tail exists only because the body
+    // reads `arguments` -- and ECMA-262 10.2.1 binds each omitted formal to
+    // `undefined`. The emitter pads an omitted formal for a convention with NO
+    // rest slot (`paddedArguments`, emit-context.ts), but it identifies the rest
+    // array positionally as the last argument, so the padding for a rest
+    // convention has to happen here, before the tail is packed: each omitted
+    // named slot is the language's literal `undefined`, converted into the
+    // slot's own carrier by the same two steps `lower-short-circuit.ts` uses
+    // for `??`'s absent arm, and a carrier that cannot hold the absence refuses
+    // in that conversion rather than being default-constructed.
+    const omitted = [];
+    for (let position = args.length; position < abi.restFrom; position += 1) {
+        const named = abi.parameters[position];
+        if (!named)
+            throw new IrLoweringBlockedError(`a variadic convention declares no parameter at named position ${position}`);
+        const absent = ctx.builder.constant(block, lineage, 'undefined', 'undefined', { kind: 'undefined' });
+        const converted = convertOrDrift(ctx, block, lineage, operation, 'omitted', position, { value: absent, representation: { kind: 'undefined' } }, named.value);
+        omitted.push({ kind: 'value', value: converted });
+    }
+    if (omitted.length > 0)
+        args = [...args, ...omitted];
+    // A tuple carried as a positional record has a bounded field set.
+    // Optional trailing positions may be omitted: leave those fields absent,
+    // preserving the difference from a present argument whose value is undefined.
+    if (isClosedContiguousTupleRecord(slot.value)) {
+        const tail = args.slice(abi.restFrom);
+        if (firstSpread >= 0) {
+            throw new IrLoweringBlockedError('a call range-copies a spread argument into a rest slot whose convention is a fixed-arity tuple, not a runtime-sized array; ' +
+                'a spread contributes a runtime number of values and a tuple has no primitive to absorb one');
+        }
+        if (tail.length > slot.value.fields.length) {
+            throw new IrLoweringBlockedError(`a call passes ${tail.length} trailing argument(s) into a rest slot whose tuple convention declares ${slot.value.fields.length}; ` +
+                'a fixed-arity rest slot and its call site have to agree on arity');
+        }
+        const fields = slot.value.fields.flatMap((field, index) => {
+            const entry = tail[index];
+            if (!entry) {
+                if (field.required)
+                    throw new IrLoweringBlockedError(`a tuple-shaped rest slot's required field ${index} has no matching trailing argument`);
+                return [];
+            }
+            return [{ key: field.key, value: entry.value }];
+        });
+        const packed = ctx.builder.allocateRecord(block, lineage, fields, slot.value);
+        return [...args.slice(0, abi.restFrom).map((entry) => entry.value), { value: packed, representation: slot.value }];
+    }
+    if (slot.value.kind !== 'array-object') {
+        throw new IrLoweringBlockedError('a variadic convention declares a rest slot that is not an array-object and cannot be packed');
+    }
+    // `slot` is captured by the element callback below; keep the narrowing in a
+    // stable local rather than asking TypeScript to retain it through closure
+    // control flow.  This is the same ABI-proved rest carrier, not a cast.
+    const restArray = slot.value;
+    // The rest array is FRESH per call -- the language binds `...rest` to a new
+    // Array, never to the caller's -- so a spread contributes a range copy into
+    // it rather than aliasing it. That is also why a mixed `f(a, ...xs, b)`
+    // needs no special case: the copy and the push are both just elements of the
+    // array being built, in written order.
+    const elements = args.slice(abi.restFrom).map((entry) => {
+        // A positional element enters the pack's element slot the way a literal's
+        // element enters an array literal's: converted here, so the printer's
+        // folded push (`emit-arrays.ts`) and the packed array agree on the carrier.
+        if (entry.kind !== 'spread')
+            return { kind: 'element', value: convertTo(ctx, block, lineage, entry.value, restArray.element) ?? entry.value };
+        if (entry.value.representation.kind === 'dynamic') {
+            if (restArray.element.kind !== 'dynamic') {
+                throw new IrLoweringBlockedError(`a call gathers a dynamic iterator into a "${representationKey(restArray.element)}" rest element carrier; ` +
+                    'per-element dynamic conversion is not installed');
+            }
+            return { kind: 'gather', iterator: entry.value };
+        }
+        // Set/string/cursor range sources retain their existing emitter checks.
+        // Only a dynamic iterator needs this dedicated materialization path.
+        // A source carried wider than the rest element -- an open-ended tuple's
+        // tail, whose array carries the union of every position -- converts per
+        // element on the way in; the emitter installs the conversion from the
+        // ordinary recipes and refuses by name where none exists.
+        const converts = entry.value.representation.kind === 'array-object' &&
+            representationKey(entry.value.representation.element) !== representationKey(restArray.element);
+        return converts
+            ? { kind: 'spread', value: entry.value, from: entry.from ?? 0, element: restArray.element }
+            : { kind: 'spread', value: entry.value, from: entry.from ?? 0 };
+    });
+    const packed = ctx.builder.allocateArrayObject(block, lineage, elements, restArray);
+    return [...args.slice(0, abi.restFrom).map((entry) => entry.value), { value: packed, representation: restArray }];
+};

package/dist/ir/lower-property.d.ts

@@ -0,0 +1,21 @@
+import type { IrBlockId } from './model.js';
+import type { PropertyOperation } from '../semantics/model/operations.js';
+import { type LoweringContext } from './lower-operands.js';
+/**
+ * Lowering the property family: the six object internal methods, and nothing
+ * else.
+ *
+ * Property syntax has exactly one route to the runtime -- `[[Get]]`, `[[Set]]`,
+ * `[[Delete]]`, `[[HasProperty]]`, `[[OwnPropertyKeys]]`,
+ * `[[DefineOwnProperty]]` (`ir/model.ts`) -- so this file is a dispatch over
+ * `internalMethod` with no second, source-shaped path for a property
+ * expression to take. It lives apart from `lower.ts` for the same reason
+ * `lower-element.ts` and `lower-destructuring.ts` do: one family, one file.
+ */
+/**
+ * The class method body a property read names when it reads a method as a
+ * VALUE: a callable carrier stating a receiver, read by a constant key off a
+ * class instance (or a class constructor, for a static). What `enter` binds
+ * the receiver to when the value reaches a receiver-less slot.
+ */
+export declare const lowerProperty: (ctx: LoweringContext, block: IrBlockId, operation: PropertyOperation) => void;

package/dist/ir/lower-property.js

@@ -0,0 +1,132 @@
+import { narrowedOperandView } from '../conversion/operand-view.js';
+import { callableOwnPrototypeAt } from '../semantics/callable-origins.js';
+import { resultOf } from '../semantics/model/operands.js';
+import { IrLoweringBlockedError } from './lower-graph.js';
+import { pendingShortCircuitOf } from './lower-short-circuit.js';
+import { methodValueOriginOf } from '../projection/callee.js';
+import { propertyReadResultRepresentationOf } from '../projection/fields.js';
+import { typedComputedReadRecipeOf, typedComputedWriteRecipeOf } from './typed-property-access.js';
+import { namedOperand, optionalResultRepresentation, registerResult, requireLineage, requireResultRepresentation, resolveRequiredOperand, convertOrDrift, enterRequiredOperand, narrowedBindingRead, reactiveFieldReadOf } from './lower-operands.js';
+/**
+ * Lowering the property family: the six object internal methods, and nothing
+ * else.
+ *
+ * Property syntax has exactly one route to the runtime -- `[[Get]]`, `[[Set]]`,
+ * `[[Delete]]`, `[[HasProperty]]`, `[[OwnPropertyKeys]]`,
+ * `[[DefineOwnProperty]]` (`ir/model.ts`) -- so this file is a dispatch over
+ * `internalMethod` with no second, source-shaped path for a property
+ * expression to take. It lives apart from `lower.ts` for the same reason
+ * `lower-element.ts` and `lower-destructuring.ts` do: one family, one file.
+ */
+/**
+ * The class method body a property read names when it reads a method as a
+ * VALUE: a callable carrier stating a receiver, read by a constant key off a
+ * class instance (or a class constructor, for a static). What `enter` binds
+ * the receiver to when the value reaches a receiver-less slot.
+ */
+export const lowerProperty = (ctx, block, operation) => {
+    const lineage = requireLineage(operation);
+    if (operation.internalMethod === 'get' && operation.resolvedBinding !== undefined) {
+        const representation = requireResultRepresentation(ctx, operation, 'value', 'a resolved binding property read');
+        const value = narrowedBindingRead(ctx, block, lineage, operation, operation.resolvedBinding, representation);
+        registerResult(ctx, operation, value);
+        if (operation.shortCircuitAlwaysPresent) {
+            const expression = resultOf(operation, 'short-circuit');
+            if (expression)
+                ctx.values.set(expression.id, value);
+            return;
+        }
+        const pending = pendingShortCircuitOf(ctx, operation, { value, representation });
+        if (pending)
+            ctx.shortCircuits.set(pending.result, pending);
+        return;
+    }
+    const receiverOperand = namedOperand(operation, 'receiver');
+    const incoming = resolveRequiredOperand(ctx, block, lineage, receiverOperand);
+    const view = narrowedOperandView(incoming.representation, receiverOperand, ctx.constantDeriver);
+    const receiver = convertOrDrift(ctx, block, lineage, operation.id, 'receiver', receiverOperand.ordinal, incoming, view, 'receiver-view');
+    switch (operation.internalMethod) {
+        case 'own-property-keys': {
+            const representation = requireResultRepresentation(ctx, operation, 'value', 'an own-property-keys operation');
+            registerResult(ctx, operation, ctx.builder.ownPropertyKeys(block, lineage, receiver, representation));
+            return;
+        }
+        case 'get': {
+            const keyOperand = namedOperand(operation, 'key');
+            const key = resolveRequiredOperand(ctx, block, lineage, keyOperand);
+            const representation = requireResultRepresentation(ctx, operation, 'value', 'a property get operation');
+            const reactive = keyOperand.source.kind === 'constant'
+                ? reactiveFieldReadOf(ctx.program.classes, receiver.representation, keyOperand.source.text, ctx.program.reactiveFields)
+                : false;
+            const held = keyOperand.source.kind === 'constant'
+                ? propertyReadResultRepresentationOf(ctx.constantDeriver, ctx.program.classes, ctx.program.abis, receiver.representation, keyOperand.source.text)
+                : null;
+            // The declaration's own `prototype` fact, asked once and carried on the
+            // read (`GetOperation.callableOwnPrototype`). The printer cannot ask:
+            // the census lives on the semantic graph, and by emission time only the
+            // carrier is left -- which is precisely the authority that used to
+            // answer this question by accident.
+            const callableOwnPrototype = keyOperand.source.kind === 'constant' &&
+                keyOperand.source.text === 'prototype' &&
+                receiver.representation.kind === 'function-value-dispatch'
+                ? (callableOwnPrototypeAt(ctx.graph, operation) ?? undefined)
+                : undefined;
+            const typedComputedRead = typedComputedReadRecipeOf(ctx.graph, operation, receiver.representation, held ?? representation, key.representation, ctx.constantDeriver, ctx.program.classes, ctx.program.conversions);
+            const raw = ctx.builder.get(block, lineage, receiver, key, held ?? representation, operation.hostMethod, reactive, callableOwnPrototype, operation.normalResult, typedComputedRead ?? undefined, operation.provenKeyTexts);
+            const value = held === null
+                ? raw
+                : convertOrDrift(ctx, block, lineage, operation.id, 'read', 0, { value: raw, representation: held }, representation, 'field-read')
+                    .value;
+            registerResult(ctx, operation, value);
+            const method = keyOperand.source.kind === 'constant'
+                ? methodValueOriginOf(ctx.program.classes, receiver.representation, keyOperand.source.text, representation)
+                : null;
+            if (method !== null)
+                ctx.program.methodValueReceivers.set(value, { receiver, method });
+            if (operation.shortCircuitAlwaysPresent) {
+                const expression = resultOf(operation, 'short-circuit');
+                if (expression)
+                    ctx.values.set(expression.id, value);
+                return;
+            }
+            // `a?.b` publishes a second value -- what the *expression* evaluates to --
+            // which is a merge this arm cannot close. It is recorded and settled once
+            // an operation outside the guard runs (`lower-short-circuit.ts`).
+            const pending = pendingShortCircuitOf(ctx, operation, { value, representation });
+            if (pending)
+                ctx.shortCircuits.set(pending.result, pending);
+            return;
+        }
+        case 'has-property': {
+            const key = resolveRequiredOperand(ctx, block, lineage, namedOperand(operation, 'key'));
+            const representation = requireResultRepresentation(ctx, operation, 'value', 'a has-property operation');
+            registerResult(ctx, operation, ctx.builder.hasProperty(block, lineage, receiver, key, representation));
+            return;
+        }
+        case 'delete': {
+            const key = resolveRequiredOperand(ctx, block, lineage, namedOperand(operation, 'key'));
+            registerResult(ctx, operation, ctx.builder.delete(block, lineage, receiver, key, operation.strict, optionalResultRepresentation(ctx, operation, 'value')));
+            return;
+        }
+        case 'set': {
+            const key = resolveRequiredOperand(ctx, block, lineage, namedOperand(operation, 'key'));
+            const value = enterRequiredOperand(ctx, block, lineage, operation, namedOperand(operation, 'value'));
+            registerResult(ctx, operation, ctx.builder.set(block, lineage, receiver, key, value, operation.strict, optionalResultRepresentation(ctx, operation, 'value'), typedComputedWriteRecipeOf(ctx.graph, operation, receiver.representation, ctx.constantDeriver, ctx.program.classes) ?? undefined, operation.provenKeyTexts));
+            return;
+        }
+        case 'define-own-property': {
+            const key = resolveRequiredOperand(ctx, block, lineage, namedOperand(operation, 'key'));
+            const value = enterRequiredOperand(ctx, block, lineage, operation, namedOperand(operation, 'value'));
+            // The attributes are the operation's own, never defaults chosen here: a
+            // definition with no stated descriptor is an unanswerable question, not
+            // a permissive one, and guessing would install a property the source
+            // never described.
+            const descriptor = operation.descriptor;
+            if (!descriptor) {
+                throw new IrLoweringBlockedError('a define-own-property operation states no descriptor for the IR to install');
+            }
+            registerResult(ctx, operation, ctx.builder.defineOwnProperty(block, lineage, receiver, key, value, { writable: descriptor.writable, enumerable: descriptor.enumerable, configurable: descriptor.configurable }, optionalResultRepresentation(ctx, operation, 'value')));
+            return;
+        }
+    }
+};

package/dist/ir/lower-protocol.d.ts

@@ -0,0 +1,11 @@
+import type { IrBlockId } from './model.js';
+import type { ProtocolOperation } from '../semantics/model/operations.js';
+import { type LoweringContext } from './lower-operands.js';
+/**
+ * The iteration protocol's steps.
+ *
+ * Split out of `lower.ts` on the same family boundary `lower-allocation.ts`
+ * and `lower-destructuring.ts` already draw, so the file that dispatches every
+ * family does not also carry one family's whole implementation.
+ */
+export declare const lowerProtocol: (ctx: LoweringContext, block: IrBlockId, operation: ProtocolOperation) => void;