@geastack/compiler 1.0.15 → 1.0.17

package/dist/semantics/normalize/producers/invocations.js

@@ -8,6 +8,7 @@ import { implementationSignatureOf } from '../structural-declarations.js';
 import { physicalGeneratorOverloadResultAt } from '../physical-overload-result.js';
 import { regionId, semanticResultId } from '../../../identity/ids.js';
 import { bindingKindOf } from './binding-kind.js';
+import { declaresExactArms } from './exact-arms.js';
 import { blocked, mintOperationId, mintResult, operand } from './mint.js';
 import { calleeAwareTypeAt, objectDescriptorReturnTypeAt, resolvedCalleeSignatureType, sourceForValue, unwrapErased, valueEdgesInto } from './shared.js';
 import { isShortCircuitingCall, optionalChainGuardOf, optionalCallGuardOf, presentReturnTypeOf } from './optional-chain.js';
@@ -152,6 +153,34 @@ const argumentConversionRolesOf = (selected, operands) => {
     }
     return roles;
 };
+/**
+ * The `exact-arm` roles of a call into an `@gea-exact-arms` implementation
+ * (`ConversionRoleTarget.owner`): each argument's type under the overload the
+ * checker resolved. Published beside the implementation's own
+ * `parameter-slot` roles rather than instead of them, because the slot is
+ * still the implementation's union -- this only says which arm of it the
+ * argument enters. Nothing for a call that resolved straight to the body
+ * (no overload was chosen, so there is no arm to name) or to a generic
+ * overload (the instantiated parameter types are not public, exactly as
+ * `argumentConversionRolesOf` refuses them).
+ */
+const exactArmArgumentRolesOf = (context, node, resolved, implementation, operands) => {
+    if (!resolved || !implementation?.declaration || !declaresExactArms(implementation.declaration))
+        return [];
+    const selected = buildSelectedSignature(context, node, resolved);
+    if (!selected || selected.typeArguments.kind !== 'none')
+        return [];
+    const roles = [];
+    for (const argument of operands) {
+        if (argument.role !== 'argument')
+            continue;
+        const parameter = selected.parameters[argument.ordinal];
+        if (!parameter || parameter.rest)
+            continue;
+        roles.push({ role: 'argument', ordinal: argument.ordinal, owner: 'exact-arm', type: parameter.slot });
+    }
+    return roles;
+};
 const buildSelectedSignature = (context, node, signature) => {
     const declaration = signature.declaration;
     // No declaration node (the implicit constructor of a class with no written
@@ -1740,7 +1769,10 @@ export const createInvocationProducer = (context) => ({
                 ? { intrinsicReflection: intrinsicPropertyCall }
                 : {}),
             operands,
-            conversionRoles: argumentConversionRolesOf(selectedSignature, operands),
+            conversionRoles: [
+                ...argumentConversionRolesOf(selectedSignature, operands),
+                ...exactArmArgumentRolesOf(context, node, resolvedSignature, implementationSignature, operands)
+            ],
             // Two results, and they are different values. `value` is what the call
             // returned, which exists only on the branch where the guard was present;
             // `short-circuit` is what the *expression* evaluates to, which is that

package/dist/semantics/normalize/reachability.d.ts

@@ -37,17 +37,16 @@ import ts from 'typescript';
  * - A **function declaration**. Its evaluation is `InstantiateFunctionObject`:
  *   a closure is created and bound. Nothing observable happens, and the body
  *   does not run.
- * - A **class declaration** with no decorators, no `extends` clause, no static
+ * - A **class declaration** with no decorators, no static
  *   block, no static field initializer and no computed member name.
  *   `ClassDefinitionEvaluation` for such a class evaluates nothing at all, and
  *   this compiler lowers class evaluation to *no runtime step at all*
  *   (`ir/lower.ts`, `case 'class-lifecycle'`): the struct and the construct
  *   function it emits already are the layout the definition events record. A
  *   static block or a static initializer is the opposite -- each is a real
- *   region with a body -- so a class carrying one is kept; so is a class with
- *   a heritage clause, whose one definition-time step (the heritage read) is
- *   the event the projection takes the struct's base from (see
- *   `classDefinitionIsInert`).
+ *   region with a body -- so a class carrying one is kept. An `extends`
+ *   clause is tolerated only in the two spellings `heritageIsInert` proves
+ *   evaluate nothing; any other base keeps the class.
  * - A **variable statement** whose every declarator binds a plain name and has
  *   either no initializer or an initializer drawn from `initializerIsInert`'s
  *   whitelist: literals, function/arrow/class expressions, and object/array
@@ -185,5 +184,21 @@ export interface ReachabilityInput {
      */
     readonly hostReachedMemberKeys?: ReadonlySet<string>;
 }
+/**
+ * Whether the statements this program REACHES in `file` evaluate anything.
+ *
+ * `evaluatesNothing` above is the syntactic answer for a whole file;
+ * this is the same question after pruning, and it is the one the entry needs:
+ * a module body is called because something in it runs. A class retained for
+ * its LAYOUT alone is the case that separates them. It is a live statement --
+ * it publishes a class-lifecycle operation, so the census gives its file a
+ * module-body region -- and by `layoutClasses`' own definition it runs no
+ * constructor, no initializer and no module effect, so lowering gives that
+ * region no body. A rooted script whose every class is pruned except one some
+ * annotation names (node-compat's `whatwg-streams.ts`, in a program that
+ * touches no stream) was scheduled on the strength of the region and refused
+ * by the printer for want of the body.
+ */
+export declare const fileEvaluates: (reachable: ProgramReachability, file: ts.SourceFile) => boolean;
 export declare const moduleEvaluationOrder: (input: ReachabilityInput) => readonly ts.SourceFile[];
 export declare const censusReachability: (input: ReachabilityInput) => ProgramReachability;

package/dist/semantics/normalize/reachability.js

@@ -92,21 +92,63 @@ const computedKeyIsInert = (checker, name) => {
     const declarations = checker.getSymbolAtLocation(root)?.declarations ?? [];
     return declarations.length > 0 && declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile);
 };
+/**
+ * Whether evaluating a class's `extends` clause is provably not an action.
+ *
+ * `ClassDefinitionEvaluation` (15.7.14) evaluates the heritage expression and
+ * requires a constructor. Two spellings cannot do anything else. A bare
+ * identifier naming a class DECLARED EARLIER at the top level of the same file
+ * is a read of an initialized binding -- past its temporal dead zone, never a
+ * getter, always a constructor. And a bare identifier whose every declaration
+ * is ambient names the language's own intrinsic (`Error`), for the reason
+ * `computedKeyIsInert` gives. Everything else is kept: a call (`mixin(Base)`),
+ * a property read (`ns.Base`, which can be a getter), a base declared later
+ * (a TDZ throw), and an imported base, whose module a cycle may not have
+ * evaluated yet.
+ *
+ * This used to answer `false` for every `extends`, for a reason that was never
+ * about evaluation: `projection/classes.ts` takes a struct's base from the
+ * heritage event a LIVE class publishes, so pruning a subclass some type still
+ * named left `struct One final {}` with no base under an upcast. That is a
+ * question about who names the class, and `markTypeNamedClasses` now answers
+ * it where it belongs -- a class any live annotation, alias or interface names
+ * is opened for its layout and publishes that event. What is pruned here is a
+ * subclass NOTHING names, whose struct nothing emits.
+ *
+ * The blanket rule's cost was every unused hierarchy in a rooted script:
+ * node-compat's `whatwg-streams.ts` and `abort-events.ts` are roots of every
+ * program, so every program carried `ReadableByteStreamController`,
+ * `TextEncoderStream`, `DOMException` and, through them, the whole stream
+ * implementation -- ~2.4k emitted lines in a program that prints one number.
+ */
+const heritageIsInert = (checker, node) => {
+    for (const clause of node.heritageClauses ?? []) {
+        if (clause.token !== ts.SyntaxKind.ExtendsKeyword)
+            continue;
+        for (const type of clause.types) {
+            if (!ts.isIdentifier(type.expression))
+                return false;
+            const declarations = checker.getSymbolAtLocation(type.expression)?.declarations ?? [];
+            if (declarations.length === 0)
+                return false;
+            if (declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile))
+                continue;
+            const file = node.getSourceFile();
+            const settled = declarations.every((declaration) => ts.isClassDeclaration(declaration) &&
+                declaration.getSourceFile() === file &&
+                declaration.parent === file &&
+                declaration.end <= node.pos);
+            if (!settled)
+                return false;
+        }
+    }
+    return true;
+};
 /** Whether a class's *definition* evaluates anything beyond binding its own name. */
 const classDefinitionIsInert = (checker, node) => {
     if (ts.canHaveDecorators(node) && (ts.getDecorators(node)?.length ?? 0) > 0)
         return false;
-    // The one step `ClassDefinitionEvaluation` performs for a decorator-free
-    // class is its heritage read, and that step is not inert in THIS compiler
-    // even though it calls nothing: `projection/classes.ts` reads a class's
-    // `base` link off the class-lifecycle heritage event the census publishes
-    // for the definition, and `records.ts` spells `struct D : B` from that
-    // link alone -- while the struct itself is emitted whenever the class's
-    // shape is reachable, which a type position keeps it. Pruning an
-    // un-instantiated `class One extends Base` whose type still names a union
-    // arm emitted `struct One final {}` with no base, and the upcast
-    // `Ref<Base>(Ref<One>)` the union's recast renders stopped compiling.
-    if (node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword))
+    if (!heritageIsInert(checker, node))
         return false;
     return node.members.every((member) => {
         if (ts.canHaveDecorators(member) && (ts.getDecorators(member)?.length ?? 0) > 0)
@@ -238,6 +280,31 @@ const objectMemberIsInert = (checker, member) => {
  * module (TS2448, which this compiler refuses the program for), it does not
  * across an import cycle.
  */
+/**
+ * `Symbol()` / `Symbol('description')` on the language's own `Symbol`.
+ *
+ * ECMA-262 20.4.1.1 does one thing a program could observe: `ToString` of the
+ * description, and `ToString` of a string literal (or of nothing) runs no
+ * code. What is left is minting a symbol, and a symbol bound to a name nothing
+ * reads is not observable -- which is the only case this is ever asked about,
+ * because a binding something names is opened regardless. The callee must be
+ * the ambient intrinsic for the reason `computedKeyIsInert` gives: a user
+ * `Symbol` is an ordinary call.
+ *
+ * A module-private brand token is what reaches it: node-compat's
+ * `abort-events.ts` is a root of every program and declares
+ * `const abortSignalConstructionToken = Symbol('AbortSignal construction')`,
+ * so every program kept a module body whose whole content was that call.
+ */
+const intrinsicSymbolCallIsInert = (checker, node) => {
+    if (!ts.isIdentifier(node.expression) || node.expression.text !== 'Symbol' || node.arguments.length > 1)
+        return false;
+    const description = node.arguments[0];
+    if (description !== undefined && !ts.isStringLiteral(description) && !ts.isNoSubstitutionTemplateLiteral(description))
+        return false;
+    const declarations = checker.getSymbolAtLocation(node.expression)?.declarations ?? [];
+    return declarations.length > 0 && declarations.every((declaration) => declaration.getSourceFile().isDeclarationFile);
+};
 const initializerIsInert = (checker, node) => {
     if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node))
         return initializerIsInert(checker, node.expression);
@@ -286,7 +353,7 @@ const initializerIsInert = (checker, node) => {
             declarations.every((declaration) => ts.isClassDeclaration(declaration) && declaration.getSourceFile() === node.getSourceFile()));
     }
     if (ts.isCallExpression(node))
-        return closureFactoryCallIsInert(checker, node);
+        return intrinsicSymbolCallIsInert(checker, node) || closureFactoryCallIsInert(checker, node);
     // `-1` and `+1` are how a negative numeric constant is spelled; nothing else
     // unary is admitted, because every other operand form can reach user code.
     if (ts.isPrefixUnaryExpression(node)) {
@@ -547,9 +614,33 @@ const evaluatesNothing = (file) => file.statements.every((statement) => {
             return true;
         if (statement.moduleSpecifier !== undefined)
             return false;
-        return statement.exportClause !== undefined && ts.isNamedExports(statement.exportClause) && statement.exportClause.elements.length === 0;
+        return (statement.exportClause !== undefined && ts.isNamedExports(statement.exportClause) && statement.exportClause.elements.length === 0);
     }
-    return ts.canHaveModifiers(statement) && (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword);
+    return (ts.canHaveModifiers(statement) &&
+        (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword));
+});
+/**
+ * Whether the statements this program REACHES in `file` evaluate anything.
+ *
+ * `evaluatesNothing` above is the syntactic answer for a whole file;
+ * this is the same question after pruning, and it is the one the entry needs:
+ * a module body is called because something in it runs. A class retained for
+ * its LAYOUT alone is the case that separates them. It is a live statement --
+ * it publishes a class-lifecycle operation, so the census gives its file a
+ * module-body region -- and by `layoutClasses`' own definition it runs no
+ * constructor, no initializer and no module effect, so lowering gives that
+ * region no body. A rooted script whose every class is pruned except one some
+ * annotation names (node-compat's `whatwg-streams.ts`, in a program that
+ * touches no stream) was scheduled on the strength of the region and refused
+ * by the printer for want of the body.
+ */
+export const fileEvaluates = (reachable, file) => reachable.statementsOf(file).some((statement) => {
+    if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement))
+        return false;
+    if (ts.isClassDeclaration(statement) && reachable.classIsLayoutOnly(statement))
+        return false;
+    return !(ts.canHaveModifiers(statement) &&
+        (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword));
 });
 export const moduleEvaluationOrder = (input) => {
     const compiled = new Set(input.files);
@@ -787,11 +878,25 @@ export const censusReachability = (input) => {
      * header already gives, and layout-only is the smallest promotion there is:
      * no module evaluation, no constructor, no member body.
      */
+    // A type alias or interface is a NAME for the types inside it, so a class it
+    // names is named by whatever names the alias: `type Arm = One | Two` then
+    // `let v: Arm` types a live cell as `One`. The walk never enters a type
+    // declaration on its own (`markReferences` returns on both), so it is entered
+    // here, once, from the reference that makes it matter. This is what lets
+    // `heritageIsInert` prune an unnamed subclass without losing a named one.
+    const followedTypeDeclarations = new Set();
     const markTypeNamedClasses = (node) => {
         const named = ts.isTypeReferenceNode(node) ? node.typeName : ts.isExpressionWithTypeArguments(node) ? node.expression : null;
         if (named !== null) {
             const symbol = input.checker.getSymbolAtLocation(named);
             for (const declaration of symbol ? declarationsOf(input.checker, symbol) : []) {
+                if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) {
+                    if (followedTypeDeclarations.has(declaration))
+                        continue;
+                    followedTypeDeclarations.add(declaration);
+                    ts.forEachChild(declaration, markTypeNamedClasses);
+                    continue;
+                }
                 if (!ts.isClassDeclaration(declaration))
                     continue;
                 const file = declaration.getSourceFile();

package/dist/semantics/normalize/specialization.js

@@ -1781,10 +1781,7 @@ export const censusSpecializations = (checker, sourceFiles, reachable, namespace
                 // refusal it replaces. Those copies are two layouts and split.
                 const stored = parametersInInstanceStorage(checker, declaration);
                 const foldable = (candidate) => ![...layoutRelevant].some((index) => stored.has(index) &&
-                    fillings.some((other, at) => minted[at] === true &&
-                        other[index] !== candidate[index] &&
-                        !openFilling(other[index]) &&
-                        !openFilling(candidate[index])));
+                    fillings.some((other, at) => minted[at] === true && other[index] !== candidate[index] && !openFilling(other[index]) && !openFilling(candidate[index])));
                 // The chosen layout must be one the program actually builds.
                 return (fillings.find((candidate, at) => minted[at] === true && differs(candidate) && foldable(candidate) && fillings.every((other) => absorbs(candidate, other))) ?? null);
             })();

package/dist/targets/cpp/class-layout.d.ts

@@ -6,6 +6,7 @@ import { classFamilyOverridesOf } from '../../projection/dispatch.js';
 export { classFamilyOverridesOf };
 import { classMemberOf, classStaticMemberOf, type ClassMemberSite } from '../../projection/fields.js';
 export { classMemberOf, classStaticMemberOf, type ClassMemberSite };
+import type { ConstantLiteral } from '../../semantics/model/operands.js';
 import { type RecordField, type Representation } from '../../representation/model.js';
 import { type ConversionSite } from './emit-narrowing.js';
 /**
@@ -167,6 +168,45 @@ export declare const lazyArrowFieldGetPlanOf: (ctx: Pick<EmitContext, "classes"
  * the snapshot in hand.
  */
 export declare const lazyCalleeReadsOf: (ctx: EmitContext, body: IrBody) => ReadonlySet<IrValueId>;
+/**
+ * A class field initializer that is one constant and nothing else.
+ *
+ * Carried as the constant's own `text`/`literal` rather than as a decided
+ * boolean because the question "is this redundant" cannot be answered here:
+ * it depends on the PHYSICAL storage the field was given, which
+ * `cppFieldInitializerStatements` learns from its `storedFieldOf` and this
+ * census never sees. This says what the initializer is; that site says what
+ * the storage is; the two together decide.
+ */
+export interface ConstantFieldInitializer {
+    readonly text: string;
+    readonly literal: ConstantLiteral;
+}
+/** Publishes one compile's constant-field-initializer census. Called once, before any body renders -- mirrors `publishLazyArrowFieldPlans`. */
+export declare const publishConstantFieldInitializers: (classes: ReadonlyMap<DeclarationId, ClassLayout>, constants: ReadonlyMap<DeclarationId, ReadonlyMap<string, ConstantFieldInitializer>>) => void;
+/** The single constant one class field's initializer evaluates to, or `null` when it is anything else (including in a compile that published no census). */
+export declare const constantFieldInitializerOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, declaration: DeclarationId, key: string) => ConstantFieldInitializer | null;
+/**
+ * Every class field whose initializer is a single constant.
+ *
+ * The shape admitted is the narrowest one that proves "evaluating this thunk
+ * does nothing but produce this value": one block, one operation in it, that
+ * operation a `constant`, and the block returning that constant's own result.
+ * A thunk with two operations may have computed something; one that returns a
+ * different value than it built is not what it looks like. Neither gets in.
+ *
+ * A REACTIVE field is refused. Its storage is `Cell<T>`, not `T`
+ * (`records.ts`'s `fieldStorageType`), so the assignment runs the cell's own
+ * `operator=` and what a value-initialized cell holds is the cell's business,
+ * not this function's. The refusal reads the plugin's own per-class statement
+ * (`ReactiveCellPlan.fields`) rather than `cell`: gea names a cell spelling in
+ * every compile, reactive or not, so testing `cell !== null` would switch the
+ * census off for every program. It also cannot wait for the settled
+ * `celledFields`, which `cppRecordDeclarations` produces only after this
+ * census has to be published -- but that set is derived from these same
+ * `fields`, so refusing all of them refuses a superset.
+ */
+export declare const censusConstantFieldInitializers: (bodies: readonly IrBody[], classes: ReadonlyMap<DeclarationId, ClassLayout>, reactiveFields: ReadonlyMap<DeclarationId, ReadonlySet<string>>) => ReadonlyMap<DeclarationId, ReadonlyMap<string, ConstantFieldInitializer>>;
 /**
  * Which class fields qualify for lazy materialization, computed once for the
  * whole translation unit.

package/dist/targets/cpp/class-layout.js

@@ -62,6 +62,31 @@ classDeclaration, fields, receiver, storedFieldOf) => {
             return `field "${field.key}" initializer has no complete physical storage contract`;
         }
         const stored = storage.value;
+        // A field whose initializer writes the value its storage ALREADY holds.
+        //
+        // `makeRef<T>()` value-initializes -- these structs have no user-provided
+        // constructor, so `T()` zero-initializes and then default-constructs every
+        // member: a `std::string` field is `""` and a `bool` field is `false`
+        // before any statement here runs. `statusMessage = ''` then calls the
+        // field's initializer thunk and assigns its result, and for a
+        // `std::string` that assignment is an out-of-line libstdc++ `_M_replace`
+        // -- per field, per construction. `node:http`'s `ServerResponse` alone
+        // declares five, and it is built once per request.
+        //
+        // Only the store is dropped, and only where dropping it is invisible:
+        // the initializer must BE one constant (`censusConstantFieldInitializers`
+        // proved the thunk is a single `constant` and a `return` of it, so it has
+        // no side effect to lose), its representation must already be the
+        // storage's (no conversion to skip), the field must be required (an
+        // optional's presence bit is `false` by declaration and would still need
+        // setting), and the constant must be the carrier's own value-initialized
+        // value.
+        const constant = constantFieldInitializerOf(site.classes, classDeclaration, field.key);
+        if (constant !== null &&
+            storage.required &&
+            representationKey(field.representation) === representationKey(stored) &&
+            storesTheValueInitializedDefault(stored, constant))
+            continue;
         const markPresent = !storage.required ? ` ${receiver}->${cppRecordFieldPresenceName(field.key)} = true;` : '';
         // A widening may inspect a tagged union's live arm and therefore name its
         // input more than once. A field initializer runs exactly once, so bind its
@@ -236,6 +261,93 @@ export const lazyCalleeReadsOf = (ctx, body) => {
     }
     return result;
 };
+const constantFieldInitializerSidecar = new WeakMap();
+/** Publishes one compile's constant-field-initializer census. Called once, before any body renders -- mirrors `publishLazyArrowFieldPlans`. */
+export const publishConstantFieldInitializers = (classes, constants) => {
+    constantFieldInitializerSidecar.set(classes, constants);
+};
+/** The single constant one class field's initializer evaluates to, or `null` when it is anything else (including in a compile that published no census). */
+export const constantFieldInitializerOf = (classes, declaration, key) => constantFieldInitializerSidecar.get(classes)?.get(declaration)?.get(key) ?? null;
+/**
+ * Whether `storage` value-initializes to exactly what `constant` spells.
+ *
+ * Deliberately only the two carriers whose C++ value-initialized state is a
+ * single known value: `std::string()` is empty and a scalar is zero. Anything
+ * else -- an optional, a union, a `Ref`, a record -- either has a presence or
+ * tag byte the caller must still write or a default this cannot state, and
+ * gets no answer rather than a guessed one.
+ *
+ * `-0` is refused although `Number('-0') === 0`: a value-initialized `double`
+ * is `+0.0`, and the two differ under `Object.is` and `1 / x`. Any negative
+ * spelling that reaches here is one of that family, so the sign test is the
+ * whole check.
+ */
+const storesTheValueInitializedDefault = (storage, constant) => {
+    if (storage.kind === 'string')
+        return constant.literal === 'string' && constant.text === '';
+    if (storage.kind !== 'scalar')
+        return false;
+    if (storage.domain === 'boolean')
+        return constant.literal === 'boolean' && constant.text === 'false';
+    if (storage.domain === 'bigint')
+        return false;
+    return constant.literal === 'number' && !constant.text.startsWith('-') && Number(constant.text) === 0;
+};
+/**
+ * Every class field whose initializer is a single constant.
+ *
+ * The shape admitted is the narrowest one that proves "evaluating this thunk
+ * does nothing but produce this value": one block, one operation in it, that
+ * operation a `constant`, and the block returning that constant's own result.
+ * A thunk with two operations may have computed something; one that returns a
+ * different value than it built is not what it looks like. Neither gets in.
+ *
+ * A REACTIVE field is refused. Its storage is `Cell<T>`, not `T`
+ * (`records.ts`'s `fieldStorageType`), so the assignment runs the cell's own
+ * `operator=` and what a value-initialized cell holds is the cell's business,
+ * not this function's. The refusal reads the plugin's own per-class statement
+ * (`ReactiveCellPlan.fields`) rather than `cell`: gea names a cell spelling in
+ * every compile, reactive or not, so testing `cell !== null` would switch the
+ * census off for every program. It also cannot wait for the settled
+ * `celledFields`, which `cppRecordDeclarations` produces only after this
+ * census has to be published -- but that set is derived from these same
+ * `fields`, so refusing all of them refuses a superset.
+ */
+export const censusConstantFieldInitializers = (bodies, classes, reactiveFields) => {
+    const result = new Map();
+    const bodyBySourceOwner = new Map();
+    for (const body of bodies)
+        bodyBySourceOwner.set(body.sourceOwner, body);
+    for (const [declaration, layout] of classes) {
+        for (const field of layout.fields) {
+            if (field.initializer === null)
+                continue;
+            if (reactiveFields.get(declaration)?.has(field.key))
+                continue;
+            const thunkBody = bodyBySourceOwner.get(field.initializer);
+            if (!thunkBody || thunkBody.blocks.size !== 1)
+                continue;
+            const block = [...thunkBody.blocks.values()][0];
+            if (!block || block.operations.length !== 1)
+                continue;
+            const only = block.operations[0];
+            if (!only || only.kind !== 'constant')
+                continue;
+            const terminator = block.terminator;
+            if (terminator.kind !== 'return' || terminator.value === null)
+                continue;
+            if (terminator.value.value !== only.result.id)
+                continue;
+            let byKey = result.get(declaration);
+            if (!byKey) {
+                byKey = new Map();
+                result.set(declaration, byKey);
+            }
+            byKey.set(field.key, { text: only.text, literal: only.literal });
+        }
+    }
+    return result;
+};
 /**
  * Which class fields qualify for lazy materialization, computed once for the
  * whole translation unit.

package/dist/targets/cpp/class-properties/emit-class-properties.js

@@ -3,7 +3,7 @@ import { abiKey, representationKey } from '../../../representation/model.js';
 import { abiOfCallee } from '../../../projection/callee.js';
 import { runtimeClassLayoutsOf } from '../../../projection/classes.js';
 import { classMethodOverrideOf, classPrototypeMethodMutableOf } from '../../../projection/fields.js';
-import { bindingReference, captureFieldText, cppEnvironmentStructName, cppThunkName, createCppEmitBlockedError, operandText } from '../emit-context.js';
+import { bindingReference, captureFieldText, cppEnvironmentStructName, cppThunkEntryText, createCppEmitBlockedError, operandText } from '../emit-context.js';
 import { classFamilyOverridesOf, classMemberOf, dispatchesStatically, reachableClassMethodsOf, classStaticFieldStorageOf, classStaticMemberOf } from '../class-layout.js';
 import { cppVirtualMemberName, virtualDispatchKey } from '../virtual-methods.js';
 import { cppAbiParameterType, cppBodyName, cppCallableDeclarationTagName, cppClassName, cppConstructName, cppRecordFieldName, cppRecordFieldPresenceName, cppResultTypeOf, cppStringLiteral, cppTypeOf, cppUndefinedIn } from '../types.js';
@@ -160,7 +160,7 @@ valueRepresentation = boundMethodValueRepresentation(operation), receiverText =
     const owner = [...ctx.classes.values()].find((layout) => layout.methods.some((entry) => entry.callable === method.callable && entry.key === key));
     if (owner === undefined)
         throw createCppEmitBlockedError('call-abi:class-method-owner', `method "${key}" has no declaring prototype`);
-    const payload = `${cppTypeOf(bodyRepresentation)}{&${cppThunkName(method.callable)}, ${environment}}`;
+    const payload = `${cppTypeOf(bodyRepresentation)}{${cppThunkEntryText(ctx, method.callable)}, ${environment}}`;
     const override = receiverRepresentation.kind === 'class-ref' && !dispatchesStatically(ctx, operation.receiver)
         ? classMethodOverrideOf(ctx.classes, receiverRepresentation.declaration, key)
         : null;
@@ -813,7 +813,7 @@ receiverText) => {
                 throw createCppEmitBlockedError('property-access:class-prototype:method-abi', 'prototype method has no native convention');
             const representation = { kind: 'function-value-dispatch', abi };
             const environment = methodEnvironmentText(ctx, method.callable, `prototype method ${method.key}`);
-            const payload = `${cppTypeOf(representation)}{&${cppThunkName(method.callable)}, ${environment}}`;
+            const payload = `${cppTypeOf(representation)}{${cppThunkEntryText(ctx, method.callable)}, ${environment}}`;
             return {
                 representation,
                 text: `gea::nativeClassMethodValue<${cppClassName(owner.declaration)}, &${cppCallableDeclarationTagName(method.callable)}>(${state}, ${payload})`
@@ -869,7 +869,7 @@ receiverText) => {
         // `gea::Value{&thunk, env}` for a computed read, which is not a boxed
         // callable at all.
         const methodAbi = ctx.abiOfCallable(site.method.callable);
-        const object = `{&${cppThunkName(site.method.callable)}, ${methodEnvironmentText(ctx, site.method.callable, `a "get" of static "${key}"`)}}`;
+        const object = `{${cppThunkEntryText(ctx, site.method.callable)}, ${methodEnvironmentText(ctx, site.method.callable, `a "get" of static "${key}"`)}}`;
         if (methodAbi === null)
             return `${cppTypeOf(result)}${object}`;
         const methodRepresentation = { kind: 'function-value-dispatch', abi: methodAbi };

package/dist/targets/cpp/conversions.js

@@ -11,7 +11,7 @@ import { cppTypeOf } from './types.js';
 import { nativeSumWidenable } from '../../conversion/native-sum.js';
 import { nativeSelectionRecipeOf, nativeTotalSelectionRecipeOf } from '../../conversion/native-selection.js';
 import { nativeClassReferenceIdentityOf } from '../../conversion/native-class-reference.js';
-import { ownedRecordMaterializationPlan, recordViewUsesOnlyDirectFields } from '../../conversion/record-view.js';
+import { isRecordViewTarget, ownedRecordMaterializationPlan, recordViewDispatchesArms, recordViewUsesOnlyDirectFields } from '../../conversion/record-view.js';
 import { cppStringObjectNativeType } from './regexp-types.js';
 import { viewPlanFor } from './emit-record-view.js';
 /** Called only after the native converting-constructor predicate has selected this pair. */
@@ -446,6 +446,37 @@ const dynamicCallablePair = (target) => {
         materializer: { id: 'gea::detail::DynamicCarrier::in', domain, allocates: true }
     };
 };
+/**
+ * A shared class handle among a sum's arms, at a record-shaped target it
+ * reaches by neither the chain nor the structural view.
+ *
+ * Nothing in the program proves that arm dead: an interface-typed slot holds
+ * whatever object the program put there (`semantics/interface-implementors.ts`),
+ * and a class this cannot view as the record is still a value the slot can be
+ * handed -- skytail's `const ctx: AudioContextLike | null = Ctor ? new Ctor()
+ * : createNativeAudioContext()`, whose `NativeAudioContext` carries class-typed
+ * fields and a promise the view cannot rebuild. Selecting the record arm
+ * there read the class instance's bytes as the record and crashed at launch,
+ * certified. A record arm beside the exact one is the opposite case: a record
+ * the view cannot rebuild as the target is not assignable to it either, so the
+ * checker's own narrowing is what put the pair here, and the selection stands.
+ *
+ * Asked by every table that could answer the pair -- `narrowing` and
+ * `staticRecipe` -- so the census refuses it outright rather than one table
+ * declining and the next selecting.
+ */
+const classArmWithoutHome = (layouts, source, target) => {
+    const union = source.kind === 'optional' ? source.payload : source;
+    const selected = target.kind === 'optional' ? target.payload : target;
+    if (union.kind !== 'tagged-union' || !isRecordViewTarget(selected))
+        return false;
+    const key = representationKey(selected);
+    return union.arms.some(({ value }) => value.kind === 'class-ref' &&
+        value.ownership === 'shared-refcount' &&
+        representationKey(value) !== key &&
+        conversionRecipeOf(value, selected)?.renders !== true &&
+        viewPlanFor(layouts, value, selected) === null);
+};
 export const createCppConversionRegistry = (layouts = defaultRecordLayoutPolicy) => {
     // A sum narrowing's contract is composed from the contracts this same
     // registry states for its leaf pairs (`native-narrowing-transport.ts`), so
@@ -791,6 +822,8 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
         // can see, and whose lifetime the program never stated.
         if ('ownership' in target && target.ownership === 'borrowed')
             return null;
+        if (classArmWithoutHome(layouts, source, target))
+            return null;
         const setPair = genericFunctionSetPair(source, target);
         if (setPair)
             return setPair;
@@ -949,6 +982,18 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
         const selected = source.kind === 'optional' && target.kind === 'optional' ? target.payload : target;
         if (union.kind !== 'tagged-union')
             return null;
+        // A record-shaped target some OTHER arm reaches only through the
+        // structural view is not a selection: that arm is live at a store, and a
+        // selection would read it as the exact arm. The view's `dispatch` plan
+        // (`conversion/record-view.ts`) is the conversion, installed by
+        // `staticRecipe` below once this table declines -- the same plan
+        // `emit-narrowing.ts`'s `narrowedLoadText` defers to, asked here so the
+        // admission and the render agree.
+        if (isRecordViewTarget(selected)) {
+            const view = viewPlanFor(layouts, source, target);
+            if (view !== null && recordViewDispatchesArms(view))
+                return null;
+        }
         const targetKey = representationKey(selected);
         // A SUB-union target: `selected` is still a tagged union, just missing one
         // or more of `union`'s arms -- `h instanceof Headers`'s `else` branch
@@ -1972,6 +2017,22 @@ const cppConversionTables = (layouts, nativeNarrowing, nativeWrappedPayload) =>
     staticRecipe: (source, target) => {
         if (!isSpellable(source) || !isSpellable(target))
             return null;
+        if (classArmWithoutHome(layouts, source, target))
+            return null;
+        // A sum some arm of which reaches the record-shaped target only through
+        // the structural view is that view's `dispatch` plan, asked BEFORE the
+        // chain: the chain answers the pair too, by selecting the exact arm, and
+        // that selection is the narrowing this table's `narrowing` entry has
+        // already declined for the pair (`recordViewDispatchesArms`). The
+        // printer renders in the same order (`emit-narrowing.ts`'s `recipeText`).
+        const dispatching = viewPlanFor(layouts, source, target);
+        if (dispatching !== null && recordViewDispatchesArms(dispatching))
+            return {
+                id: 'view:structural-record',
+                domain: 'static:structural-record-view',
+                allocates: true,
+                ...(recordViewUsesOnlyDirectFields(dispatching) ? { nativeFieldProtocol: 'unused' } : {})
+            };
         const recipe = conversionRecipeOf(source, target);
         if (recipe !== null && recipe.renders) {
             // `unreachable-value` spells either `unreachableValue<T>()` (a throw that
@@ -2022,6 +2083,7 @@ const allocatingRecipes = new Set([
     'record-recast',
     'optional-record-recast',
     'record-to-dictionary',
+    'dictionary-to-record',
     'record-to-array',
     'promise-payload'
 ]);