@geastack/compiler 1.0.15

package/dist/ir/model.js

@@ -0,0 +1,6 @@
+export const irBlockId = (owner, ordinal) => `irblock|${owner}|${ordinal}`;
+/** Every operation kind that may terminate a block. Used to keep the "terminator is last" invariant checkable. */
+export const terminatorKinds = ['branch', 'jump', 'return', 'throw', 'switch'];
+export const isTerminatorOperation = (operation) => terminatorKinds.includes(operation.kind);
+/** Every operation in a block, in execution order, terminator last. */
+export const allOperationsOf = (block) => [...block.operations, block.terminator];

package/dist/ir/native-absent-property.d.ts

@@ -0,0 +1,3 @@
+import type { IrOperation } from './model.js';
+/** The sealed absence proof eliminates lookup, while native references still require a null check. */
+export declare const nativeAbsentPropertyReadOf: (operation: IrOperation) => "checked-reference" | "primitive" | null;

package/dist/ir/native-absent-property.js

@@ -0,0 +1,13 @@
+/** The sealed absence proof eliminates lookup, while native references still require a null check. */
+export const nativeAbsentPropertyReadOf = (operation) => {
+    if (operation.kind !== 'get' ||
+        operation.normalResult !== 'undefined' ||
+        operation.result.representation.kind !== 'undefined' ||
+        operation.key.representation.kind !== 'scalar' ||
+        operation.key.representation.domain !== 'number')
+        return null;
+    const receiver = operation.receiver.representation;
+    if (receiver.kind === 'class-ref' && receiver.ownership === 'shared-refcount')
+        return 'checked-reference';
+    return receiver.kind === 'scalar' || receiver.kind === 'string' || receiver.kind === 'symbol' ? 'primitive' : null;
+};

package/dist/ir/native-array-transport.d.ts

@@ -0,0 +1,7 @@
+import type { IrOperation } from './model.js';
+/**
+ * Native array transport does not publish the fields of its elements. This
+ * proves absence of reflection effects, not admission of an array operation:
+ * lowering and conversion guards still own whether it can be performed.
+ */
+export declare const nativeArrayTransportOf: (operation: IrOperation, constantKey: string | null) => boolean;

package/dist/ir/native-array-transport.js

@@ -0,0 +1,46 @@
+import { canonicalIndexLiteral } from '../representation/array-index.js';
+import { representationKey } from '../representation/model.js';
+/**
+ * Native array transport does not publish the fields of its elements. This
+ * proves absence of reflection effects, not admission of an array operation:
+ * lowering and conversion guards still own whether it can be performed.
+ */
+export const nativeArrayTransportOf = (operation, constantKey) => {
+    if (operation.kind === 'allocate-array-object') {
+        const target = operation.result.representation;
+        if (target.kind !== 'array-object' || target.ownership !== 'shared-refcount')
+            return false;
+        const element = representationKey(target.element);
+        return operation.elements.every((slot) => {
+            if (slot.kind === 'hole')
+                return true;
+            if (slot.kind === 'element')
+                return representationKey(slot.value.representation) === element;
+            if (slot.kind !== 'spread' || slot.element !== undefined)
+                return false;
+            const source = slot.value.representation;
+            return source.kind === 'array-object' && representationKey(source.element) === element;
+        });
+    }
+    if (operation.kind !== 'get' && operation.kind !== 'set')
+        return false;
+    const receiver = operation.receiver.representation;
+    if (receiver.kind !== 'array-object')
+        return false;
+    const value = operation.kind === 'get' ? operation.result.representation : operation.value.representation;
+    if (constantKey === 'length')
+        return value.kind === 'scalar' && value.domain === 'number';
+    // A string-shaped runtime key can name an ordinary property or method.
+    // Only a known canonical index or an already numeric key enters this path.
+    const indexed = constantKey !== null
+        ? canonicalIndexLiteral(constantKey) !== null
+        : operation.key.representation.kind === 'scalar' && operation.key.representation.domain === 'number';
+    if (!indexed)
+        return false;
+    const element = representationKey(receiver.element);
+    if (representationKey(value) === element)
+        return true;
+    // A checked indexed read represents a hole/out-of-bounds access separately
+    // from its existing native payload. It does not adapt or expose that payload.
+    return (operation.kind === 'get' && value.kind === 'optional' && value.absence === 'undefined' && representationKey(value.payload) === element);
+};

package/dist/ir/native-callable-bind.d.ts

@@ -0,0 +1,9 @@
+import type { IrOperation } from './model.js';
+/**
+ * A native bind captures an already-converted prefix; it neither reads object
+ * properties nor invokes the callable. An eventual dynamic publication or
+ * callable adapter is analyzed at that operation, not invented at allocation.
+ * Match the complete source frame and remaining result frame before claiming
+ * native transport. Boxed sources and mismatched frames keep boundary demand.
+ */
+export declare const nativeCallableBindTransportOf: (operation: IrOperation) => boolean;

package/dist/ir/native-callable-bind.js

@@ -0,0 +1,30 @@
+import { abiOfCallee } from '../projection/callee.js';
+import { abiKey, representationKey } from '../representation/model.js';
+/**
+ * A native bind captures an already-converted prefix; it neither reads object
+ * properties nor invokes the callable. An eventual dynamic publication or
+ * callable adapter is analyzed at that operation, not invented at allocation.
+ * Match the complete source frame and remaining result frame before claiming
+ * native transport. Boxed sources and mismatched frames keep boundary demand.
+ */
+export const nativeCallableBindTransportOf = (operation) => {
+    if (operation.kind !== 'bind-callable' || operation.source.representation.kind === 'dynamic')
+        return false;
+    const source = abiOfCallee(operation.source.representation);
+    const result = abiOfCallee(operation.result.representation);
+    if (!source || !result || abiKey(source) !== abiKey(operation.sourceAbi))
+        return false;
+    if (source.restFrom !== null || result.restFrom !== null || result.receiver !== null)
+        return false;
+    if (source.receiver === null
+        ? operation.receiver !== null
+        : operation.receiver === null || representationKey(source.receiver) !== representationKey(operation.receiver.representation))
+        return false;
+    if (operation.bound.length > source.parameters.length ||
+        operation.bound.some((value, index) => representationKey(value.representation) !== representationKey(source.parameters[index].value)))
+        return false;
+    const remaining = source.parameters.slice(operation.bound.length);
+    return (remaining.length === result.parameters.length &&
+        representationKey(source.result) === representationKey(result.result) &&
+        remaining.every((parameter, index) => representationKey(parameter.value) === representationKey(result.parameters[index].value)));
+};

package/dist/ir/native-carrier-predicate.d.ts

@@ -0,0 +1,34 @@
+import type { IrOperation } from './model.js';
+/**
+ * A call that reads its argument's CARRIER and nothing inside it.
+ *
+ * `Array.isArray(v)` -- ECMA-262 23.1.2.2 -- answers whether the value is an
+ * Array exotic object. It reads no property, runs no getter, invokes no
+ * method: nothing about the argument's contents can be observed through it.
+ * So an argument passed to one is not exposed to the dynamic protocol, and a
+ * class or record reaching one keeps its native field surface.
+ *
+ * Without this the reflection census saw an ordinary call whose ambient
+ * parameter is `any`, concluded it "may inspect or mutate every native
+ * receiver/argument", and gave every class reachable through the argument the
+ * full boxed reflection protocol -- `gea_readOwnField`, `gea_ownFieldDescriptor`
+ * and the `gea::Value::box` calls inside them. The printer had already decided
+ * otherwise: `emit-host-invoke.ts`'s `isArrayText` renders the whole call as
+ * the argument's own discriminant (`v.is<0>() ? false : true`), so the call it
+ * emits reads exactly the tag. Two authorities disagreed about one call, and
+ * the census's answer -- the pessimistic one -- shaped the emitted struct.
+ *
+ * The authentication is the semantic layer's, not this file's: the same guards
+ * that authenticate `Object.keys` (`producers/invocations.ts`'s
+ * `intrinsicPropertyCallOf` -- standard-library provenance for both the owner
+ * and the member, no global host-mutation taint) stamp
+ * `intrinsicCarrierPredicate`, and this reads that fact. That is the
+ * `intrinsicOwnKeys`/`nativeKeyQueryOf` arrangement exactly.
+ *
+ * A `proxy-object` argument is excluded. `IsArray` walks a proxy to its target
+ * rather than invoking a trap, so the exclusion is not required by the spec --
+ * it is here because `native-key-query.ts` draws the same line for the same
+ * reason, and a carrier whose behaviour is another object's is not one this
+ * claim should be the first to speak for.
+ */
+export declare const nativeCarrierPredicateOf: (operation: IrOperation) => boolean;

package/dist/ir/native-carrier-predicate.js

@@ -0,0 +1,49 @@
+/**
+ * A call that reads its argument's CARRIER and nothing inside it.
+ *
+ * `Array.isArray(v)` -- ECMA-262 23.1.2.2 -- answers whether the value is an
+ * Array exotic object. It reads no property, runs no getter, invokes no
+ * method: nothing about the argument's contents can be observed through it.
+ * So an argument passed to one is not exposed to the dynamic protocol, and a
+ * class or record reaching one keeps its native field surface.
+ *
+ * Without this the reflection census saw an ordinary call whose ambient
+ * parameter is `any`, concluded it "may inspect or mutate every native
+ * receiver/argument", and gave every class reachable through the argument the
+ * full boxed reflection protocol -- `gea_readOwnField`, `gea_ownFieldDescriptor`
+ * and the `gea::Value::box` calls inside them. The printer had already decided
+ * otherwise: `emit-host-invoke.ts`'s `isArrayText` renders the whole call as
+ * the argument's own discriminant (`v.is<0>() ? false : true`), so the call it
+ * emits reads exactly the tag. Two authorities disagreed about one call, and
+ * the census's answer -- the pessimistic one -- shaped the emitted struct.
+ *
+ * The authentication is the semantic layer's, not this file's: the same guards
+ * that authenticate `Object.keys` (`producers/invocations.ts`'s
+ * `intrinsicPropertyCallOf` -- standard-library provenance for both the owner
+ * and the member, no global host-mutation taint) stamp
+ * `intrinsicCarrierPredicate`, and this reads that fact. That is the
+ * `intrinsicOwnKeys`/`nativeKeyQueryOf` arrangement exactly.
+ *
+ * A `proxy-object` argument is excluded. `IsArray` walks a proxy to its target
+ * rather than invoking a trap, so the exclusion is not required by the spec --
+ * it is here because `native-key-query.ts` draws the same line for the same
+ * reason, and a carrier whose behaviour is another object's is not one this
+ * claim should be the first to speak for.
+ */
+export const nativeCarrierPredicateOf = (operation) => {
+    if (operation.kind !== 'call' || !operation.intrinsicCarrierPredicate || operation.argumentsAreSpread)
+        return false;
+    const queried = operation.arguments[0]?.representation;
+    if (queried === undefined || operation.arguments.length !== 1)
+        return false;
+    const carrierOnly = (value) => {
+        if (value.kind === 'optional')
+            return carrierOnly(value.payload);
+        if (value.kind === 'borrowed-ref')
+            return carrierOnly(value.referent);
+        if (value.kind === 'tagged-union')
+            return value.arms.length > 0 && value.arms.every((arm) => carrierOnly(arm.value));
+        return value.kind !== 'proxy-object';
+    };
+    return carrierOnly(queried);
+};

package/dist/ir/native-class-accessor.d.ts

@@ -0,0 +1,18 @@
+import type { DeclarationId, FunctionId } from '../identity/ids.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { IrBody, IrOperation, IrOperand } from './model.js';
+/** A direct native accessor is an ordinary body entry on the same receiver.
+ * Overridden families and adapting frames remain with the dispatch census;
+ * matching one implementation never authenticates the others.
+ *
+ * A setter argument may also reach its formal through the conversion the
+ * emitter applies there (`emit-properties.ts` aligns the value to the
+ * setter's parameter through the census node): only a node that is itself
+ * certified as a payload-preserving, field-protocol-free native transfer
+ * (`nativePayloadTransportMatches`) qualifies, so the formal holds the very
+ * payload the store wrote. Without the census no conversion is admitted. */
+export declare const nativeClassAccessorEntryOf: (operation: IrOperation, key: string | null, classes: ReadonlyMap<DeclarationId, ClassLayout>, bodyOf: (id: FunctionId) => IrBody | null | undefined, conversions?: Pick<ConversionCensus, "nodeById">) => {
+    readonly functionId: FunctionId;
+    readonly arguments: readonly IrOperand[];
+} | null;

package/dist/ir/native-class-accessor.js

@@ -0,0 +1,52 @@
+import { conversionNodeIdOf } from '../conversion/nodes.js';
+import { nativePayloadTransportMatches } from '../conversion/native-payload-transport.js';
+import { classMemberOf } from '../projection/fields.js';
+import { classFamilyOverridesOf } from '../projection/dispatch.js';
+import { representationKey } from '../representation/model.js';
+/** A direct native accessor is an ordinary body entry on the same receiver.
+ * Overridden families and adapting frames remain with the dispatch census;
+ * matching one implementation never authenticates the others.
+ *
+ * A setter argument may also reach its formal through the conversion the
+ * emitter applies there (`emit-properties.ts` aligns the value to the
+ * setter's parameter through the census node): only a node that is itself
+ * certified as a payload-preserving, field-protocol-free native transfer
+ * (`nativePayloadTransportMatches`) qualifies, so the formal holds the very
+ * payload the store wrote. Without the census no conversion is admitted. */
+export const nativeClassAccessorEntryOf = (operation, key, classes, bodyOf, conversions) => {
+    if ((operation.kind !== 'get' && operation.kind !== 'set') || key === null)
+        return null;
+    const receiver = operation.receiver.representation;
+    if (receiver.kind !== 'class-ref' || receiver.ownership !== 'shared-refcount')
+        return null;
+    const layout = classes.get(receiver.declaration);
+    if (!layout || layout.nativeBase !== null || classFamilyOverridesOf(classes, receiver.declaration, key).length > 0)
+        return null;
+    const member = classMemberOf(classes, receiver.declaration, key);
+    if (member?.kind !== 'accessor')
+        return null;
+    const functionId = operation.kind === 'get' ? member.accessor.getter : member.accessor.setter;
+    const frame = functionId === null ? null : bodyOf(functionId)?.abi;
+    const owner = classes.get(member.owner);
+    if (!functionId ||
+        !frame ||
+        !owner?.instance ||
+        owner.nativeBase !== null ||
+        frame.receiver === null ||
+        representationKey(frame.receiver) !== representationKey(owner.instance) ||
+        frame.restFrom !== null)
+        return null;
+    if (operation.kind === 'get') {
+        if (frame.parameters.length !== 0 || representationKey(frame.result) !== representationKey(operation.result.representation))
+            return null;
+        return { functionId, arguments: [] };
+    }
+    if (frame.result.kind !== 'void' || frame.parameters.length !== 1)
+        return null;
+    const formal = frame.parameters[0].value;
+    const written = operation.value.representation;
+    if (representationKey(formal) !== representationKey(written) &&
+        !nativePayloadTransportMatches(written, formal, conversions?.nodeById(conversionNodeIdOf(written, formal))))
+        return null;
+    return { functionId, arguments: [operation.value] };
+};

package/dist/ir/native-class-construction.d.ts

@@ -0,0 +1,16 @@
+import type { DeclarationId, FunctionId } from '../identity/ids.js';
+import type { ClassLayout } from '../projection/classes.js';
+import { type Representation } from '../representation/model.js';
+import { type ConversionCensus } from '../conversion/nodes.js';
+import type { ConstructOperation, IrBody } from './model.js';
+import { type NativeInitializationEntry } from './native-class-initialization.js';
+export interface NativeClassConstructionBranch {
+    readonly declaration: DeclarationId;
+    readonly instance: Representation;
+    readonly entries: readonly NativeInitializationEntry[];
+}
+/** A constructor-family names implementations, unlike a constructor-value-
+ * dispatch carrier, which states only a signature. Each native sum arm keeps
+ * its own frame. Consume those identities and the conversion census rather
+ * than treating a non-direct semantic target as an unknown implementation. */
+export declare const nativeClassConstructionOf: (operation: ConstructOperation, classes: ReadonlyMap<DeclarationId, ClassLayout>, bodyOf: (id: FunctionId) => IrBody | null | undefined, conversions?: Pick<ConversionCensus, "nodeById">) => readonly NativeClassConstructionBranch[] | null;

package/dist/ir/native-class-construction.js

@@ -0,0 +1,71 @@
+import { abiKey, representationKey } from '../representation/model.js';
+import { conversionNodeIdOf } from '../conversion/nodes.js';
+import { nativePayloadTransportMatches } from '../conversion/native-payload-transport.js';
+import { receivableArguments } from './call-entry.js';
+import { nativeClassInitializationOf } from './native-class-initialization.js';
+/** A constructor-family names implementations, unlike a constructor-value-
+ * dispatch carrier, which states only a signature. Each native sum arm keeps
+ * its own frame. Consume those identities and the conversion census rather
+ * than treating a non-direct semantic target as an unknown implementation. */
+export const nativeClassConstructionOf = (operation, classes, bodyOf, conversions) => {
+    if (operation.callee.value !== operation.newTarget.value)
+        return null;
+    const callee = operation.callee.representation;
+    const alternatives = callee.kind === 'tagged-union' ? callee.arms.map((arm) => arm.value) : [callee];
+    if (alternatives.length === 0)
+        return null;
+    const branches = [];
+    for (const alternative of alternatives) {
+        if (alternative.kind !== 'constructor-family' || alternative.members.length === 0)
+            return null;
+        const abi = alternative.abi;
+        if (abi.receiver !== null || abi.restFrom !== null)
+            return null;
+        const received = receivableArguments(abi, operation.arguments);
+        // These are frame views after the cited, payload-preserving conversions,
+        // not new SSA values or permission to reinterpret an emitted operand.
+        const frame = [];
+        for (let index = 0; index < received.length; index++) {
+            const source = received[index];
+            const target = abi.parameters[index]?.value;
+            if (!target)
+                return null;
+            const node = conversions?.nodeById(conversionNodeIdOf(source.representation, target));
+            if (representationKey(source.representation) !== representationKey(target) &&
+                !nativePayloadTransportMatches(source.representation, target, node))
+                return null;
+            frame.push({ value: source.value, representation: target });
+        }
+        const result = operation.result.representation;
+        if (representationKey(abi.result) !== representationKey(result) &&
+            !nativePayloadTransportMatches(abi.result, result, conversions?.nodeById(conversionNodeIdOf(abi.result, result))))
+            return null;
+        for (const declaration of alternative.members) {
+            const layout = classes.get(declaration);
+            if (!layout?.construct || !layout.instance || abiKey(layout.construct) !== abiKey(abi))
+                return null;
+            const entries = nativeClassInitializationOf(layout, frame, classes, bodyOf, conversions);
+            if (entries === null)
+                return null;
+            branches.push({ declaration, instance: layout.instance, entries });
+        }
+    }
+    const targets = operation.target.kind === 'exact'
+        ? [operation.target.target]
+        : operation.target.kind === 'closed-family'
+            ? operation.target.targets
+            : null;
+    const matches = (branch, target) => {
+        const layout = classes.get(branch.declaration);
+        return target.kind === 'function'
+            ? target.constructable && target.functionId === layout.constructor
+            : layout.constructor === null && target.classDeclaration === branch.declaration;
+    };
+    // A later family proof may refine an open target, but cannot overrule a
+    // contradictory implementation identity already published by semantics.
+    if (targets &&
+        (!branches.every((branch) => targets.some((target) => matches(branch, target))) ||
+            !targets.every((target) => branches.some((branch) => matches(branch, target)))))
+        return null;
+    return branches;
+};

package/dist/ir/native-class-initialization.d.ts

@@ -0,0 +1,15 @@
+import type { DeclarationId, FunctionId } from '../identity/ids.js';
+import { type ClassLayout } from '../projection/classes.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { IrBody, IrOperand, SuperInitializeOperation } from './model.js';
+export interface NativeInitializationEntry {
+    readonly functionId: FunctionId;
+    readonly arguments: readonly IrOperand[];
+}
+/** Existing-receiver initialization follows the projected class lifecycle.
+ * An implicit derived constructor forwards its received frame to its base;
+ * a written constructor enters its body, whose super operation owns that edge.
+ * No instance is published merely by traversing this native call chain. */
+export declare const nativeClassInitializationOf: (layout: ClassLayout, args: readonly IrOperand[], classes: ReadonlyMap<DeclarationId, ClassLayout>, bodyOf: (id: FunctionId) => IrBody | null | undefined, conversions?: Pick<ConversionCensus, "nodeById">, visiting?: Set<DeclarationId>) => readonly NativeInitializationEntry[] | null;
+/** The owning constructor authenticates the implicit this passed by super(). */
+export declare const nativeSuperInitializationOf: (operation: SuperInitializeOperation, owner: IrBody | null | undefined, classes: ReadonlyMap<DeclarationId, ClassLayout>, bodyOf: (id: FunctionId) => IrBody | null | undefined, conversions?: Pick<ConversionCensus, "nodeById">) => readonly NativeInitializationEntry[] | null;

package/dist/ir/native-class-initialization.js

@@ -0,0 +1,56 @@
+import { constructedBaseOf } from '../projection/classes.js';
+import { representationKey } from '../representation/model.js';
+import { nativeArgumentsMatch, receivableArguments } from './call-entry.js';
+import { classConstructorBodyMatches } from './construct-entry.js';
+/** Existing-receiver initialization follows the projected class lifecycle.
+ * An implicit derived constructor forwards its received frame to its base;
+ * a written constructor enters its body, whose super operation owns that edge.
+ * No instance is published merely by traversing this native call chain. */
+export const nativeClassInitializationOf = (layout, args, classes, bodyOf, conversions, visiting = new Set()) => {
+    if (visiting.has(layout.declaration) ||
+        layout.nativeBase !== null ||
+        layout.instance === null ||
+        layout.construct === null ||
+        !nativeArgumentsMatch(layout.construct, args, conversions))
+        return null;
+    visiting.add(layout.declaration);
+    const entries = [];
+    const received = receivableArguments(layout.construct, args);
+    if (layout.constructor !== null) {
+        const body = bodyOf(layout.constructor);
+        if (!body || !classConstructorBodyMatches(layout, body))
+            return null;
+        entries.push({ functionId: layout.constructor, arguments: received });
+    }
+    else if (constructedBaseOf(layout) !== null) {
+        const base = classes.get(constructedBaseOf(layout));
+        const inherited = base ? nativeClassInitializationOf(base, received, classes, bodyOf, conversions, visiting) : null;
+        if (inherited === null)
+            return null;
+        entries.push(...inherited);
+    }
+    for (const field of layout.fields) {
+        if (field.initializer === null)
+            continue;
+        const frame = bodyOf(field.initializer)?.abi;
+        if (!frame ||
+            frame.receiver === null ||
+            representationKey(frame.receiver) !== representationKey(layout.instance) ||
+            frame.parameters.length !== 0 ||
+            frame.restFrom !== null)
+            return null;
+        entries.push({ functionId: field.initializer, arguments: [] });
+    }
+    return entries;
+};
+/** The owning constructor authenticates the implicit this passed by super(). */
+export const nativeSuperInitializationOf = (operation, owner, classes, bodyOf, conversions) => {
+    if (!owner)
+        return null;
+    const owners = [...classes.values()].filter((layout) => layout.constructor === owner.sourceOwner);
+    const layout = owners.length === 1 ? owners[0] : undefined;
+    if (!layout || layout.nativeBase !== null || layout.base === null || !classConstructorBodyMatches(layout, owner))
+        return null;
+    const base = classes.get(layout.base);
+    return base ? nativeClassInitializationOf(base, operation.arguments, classes, bodyOf, conversions) : null;
+};

package/dist/ir/native-class-origins.d.ts

@@ -0,0 +1,13 @@
+import type { DeclarationId, FunctionId, IrValueId } from '../identity/ids.js';
+import type { BindingPlacement } from '../projection/bindings.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { IrBody, IrOperand, IrOperation } from './model.js';
+/** Allocation provenance is distinct from reflection demand: native callback
+ * inputs can have closed layouts without originating in this program. */
+export declare const nativeClassOriginsOf: (bodies: readonly IrBody[], operations: readonly IrOperation[], producers: ReadonlyMap<IrValueId, IrOperation>, placements: ReadonlyMap<DeclarationId, BindingPlacement>, classes: ReadonlyMap<DeclarationId, ClassLayout>, fieldSources: (operation: Extract<IrOperation, {
+    kind: "get";
+}>) => readonly IrOperand[] | null, conversions?: Pick<ConversionCensus, "nodeById">) => {
+    readonly owned: (id: IrValueId) => boolean;
+    readonly closedInitializer: (id: FunctionId) => boolean;
+};