@geastack/compiler 1.0.15

package/dist/ir/type-query-results.js

@@ -0,0 +1,96 @@
+import { stringConstantsOf } from './dead-values.js';
+import { dominatorTreeOf } from './dominance.js';
+import { allOperationsOf } from './model.js';
+import { operandsOfIrOperation } from './queries.js';
+/** A typeof result consumed only by equality tests needs its finite type tag,
+ * not a constructed string. This is a snapshot at the query's original site,
+ * never a new query at the comparison (the input may have changed meanwhile).
+ * Native storage is confined to SSA values and private, single-writer cells
+ * whose write dominates every read. Any escape invalidates the entire chain.
+ * The caller supplies the existing placement/capture proof, not a new census. */
+export const typeQueryResultsOf = (body, privateCell) => {
+    const values = new Set();
+    const bindings = new Set();
+    const comparisons = new Map();
+    const operations = [...body.blocks.values()].flatMap(allOperationsOf);
+    for (const operation of operations)
+        if (operation.kind === 'compute' && operation.form === 'typeof' && operation.result.representation.kind === 'string')
+            values.add(operation.result.id);
+    if (values.size === 0 || body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+        return { values: new Set(), bindings, comparisons };
+    const constants = stringConstantsOf(body);
+    const dominance = dominatorTreeOf(body);
+    const uses = new Map();
+    const writes = new Map();
+    const reads = new Map();
+    for (const block of body.blocks.values())
+        for (const [position, operation] of allOperationsOf(block).entries()) {
+            for (const operand of operandsOfIrOperation(operation)) {
+                const sites = uses.get(operand.value) ?? [];
+                sites.push(operation);
+                uses.set(operand.value, sites);
+            }
+            if (operation.kind === 'binding-write') {
+                const sites = writes.get(operation.declaration) ?? [];
+                sites.push({ value: operation.value.value, block: block.id, position });
+                writes.set(operation.declaration, sites);
+            }
+            if (operation.kind === 'binding-read') {
+                const sites = reads.get(operation.declaration) ?? [];
+                sites.push({ value: operation.result.id, block: block.id, position, string: operation.result.representation.kind === 'string' });
+                reads.set(operation.declaration, sites);
+            }
+        }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [declaration, sites] of writes) {
+            const seed = sites[0];
+            if (bindings.has(declaration) || sites.length !== 1 || !seed || !values.has(seed.value) || !privateCell(declaration))
+                continue;
+            const loaded = reads.get(declaration) ?? [];
+            if (!loaded.every((read) => read.string && (seed.block === read.block ? seed.position < read.position : dominance.dominates(seed.block, read.block))))
+                continue;
+            bindings.add(declaration);
+            for (const read of loaded)
+                values.add(read.value);
+            changed = true;
+        }
+    }
+    const isComparison = (operation) => operation.kind === 'compute' &&
+        (operation.form === 'equality' || operation.form === 'binary') &&
+        ['===', '!==', '==', '!='].includes(operation.operator) &&
+        operation.operands.length === 2 &&
+        operation.operands.every((operand) => values.has(operand.value) || (operand.representation.kind === 'string' && constants.has(operand.value)));
+    // Removing an escaped root also removes every dependent cell/read; removing
+    // an escaped read propagates back through its cell to the query producer.
+    changed = true;
+    while (changed) {
+        changed = false;
+        for (const value of values)
+            if (!(uses.get(value) ?? []).every((use) => isComparison(use) || (use.kind === 'binding-write' && bindings.has(use.declaration)))) {
+                values.delete(value);
+                changed = true;
+            }
+        for (const [declaration, sites] of writes) {
+            if (!bindings.has(declaration))
+                continue;
+            const loaded = reads.get(declaration) ?? [];
+            if (!sites.every((site) => values.has(site.value)) || !loaded.every((site) => values.has(site.value))) {
+                bindings.delete(declaration);
+                for (const read of loaded)
+                    values.delete(read.value);
+                changed = true;
+            }
+        }
+    }
+    const operandOf = (operand) => values.has(operand.value) ? { kind: 'tag', operand } : { kind: 'literal', text: constants.get(operand.value) };
+    for (const operation of operations)
+        if (isComparison(operation) && operation.operands.some((operand) => values.has(operand.value)))
+            comparisons.set(operation, {
+                left: operandOf(operation.operands[0]),
+                right: operandOf(operation.operands[1]),
+                unequal: operation.operator === '!==' || operation.operator === '!='
+            });
+    return { values, bindings, comparisons };
+};

package/dist/ir/typed-property-access.d.ts

@@ -0,0 +1,100 @@
+import type { ConversionNodeId } from '../conversion/algebra.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { DeclarationId } from '../identity/ids.js';
+import type { ClassLayout } from '../projection/classes.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type Representation } from '../representation/model.js';
+import type { PropertyOperation } from '../semantics/model/operations.js';
+import type { SemanticGraph } from '../semantics/model/graph.js';
+/**
+ * The property family's two SEALED computed-key certificates.
+ *
+ * A computed key whose semantic type is a finite set of string literals is a
+ * closed question, but only while the semantic graph is still in hand: by
+ * emission time the key is a `std::string` and the literal union that bounded
+ * it is gone. So the fact is asked ONCE here, during lowering, and carried on
+ * the operation for the printer to spell -- the read side as
+ * `GetOperation.typedComputedRead`, the write side as
+ * `SetOperation.typedComputedWrite`. Both share `stringLiteralTextsOf`, which
+ * is the one authority for "what strings can this key be"; neither re-derives
+ * it, and the emitter has no way to ask it.
+ */
+/** One fixed field arm of a sealed computed read. */
+export interface TypedComputedReadArm {
+    readonly key: string;
+    readonly source: Representation;
+    /** The conversion census node that carries this field into the get result. */
+    readonly conversion: ConversionNodeId;
+}
+/**
+ * A fixed-field read over a closed data record. String literal keys bound
+ * the selected arms; numeric keys use all fields and an explicit absence arm.
+ * The emitter may switch on the key,
+ * but it must keep the ordinary dynamic route when this certificate is absent.
+ */
+export interface TypedComputedReadRecipe {
+    readonly kind: 'closed-record';
+    readonly receiver: string;
+    readonly result: string;
+    readonly arms: readonly TypedComputedReadArm[];
+    /**
+     * Present when the RECEIVER bounds the arms rather than the key's own value
+     * set: the key can miss every fixed field, so absence needs its own sealed
+     * conversion. `carrier` is the key carrier the arms were selected for, so a
+     * later carrier change invalidates the certificate instead of silently
+     * changing which route runs.
+     */
+    readonly receiverBounded?: {
+        readonly carrier: string;
+        readonly missing: ConversionNodeId;
+    };
+}
+/**
+ * Publishes a candidate fixed-field computed-read recipe from the
+ * semantic/representation contracts. A later whole-program reflection census
+ * is the authority for whether the receiver can escape to mutation, an
+ * accessor, or an unknown call; that finalization pass must revoke this
+ * candidate when it finds such demand. This selector deliberately excludes
+ * index-bearing, accessor-bearing, symbol-bearing and optional layouts: each
+ * can have an additional runtime answer that a direct field switch would
+ * erase even before whole-program exposure is considered.
+ */
+export declare const typedComputedReadRecipeOf: (graph: SemanticGraph, operation: PropertyOperation, receiver: Representation, result: Representation, keyRepresentation: Representation, deriver: RepresentationDeriver, classes: ReadonlyMap<DeclarationId, ClassLayout>, conversions: ConversionCensus) => TypedComputedReadRecipe | null;
+/**
+ * A computed WRITE whose semantic key is a finite set of string literals, each
+ * naming a declared field of the receiver.
+ *
+ * The read's twin, and deliberately thinner. The read recipe carries a
+ * conversion node per arm because the emitter renders the field load itself;
+ * the write recipe carries only the KEYS, because the emitter renders each arm
+ * by re-entering the ordinary CONSTANT-key store path with that key
+ * (`emit-properties.ts`). That is the whole point of the shape: a computed
+ * store into a declared field must reach the same storage, the same
+ * conversion, the same setter and the same reactive tick a source-literal
+ * store to that member reaches -- and the only way to guarantee it is to call
+ * that renderer, not to re-implement its tail.
+ *
+ * What this buys over the runtime field dispatcher (`gea_writeOwnField`, which
+ * `class-ref:set:true` already claims) is the carriers it cannot address. The
+ * dispatcher goes through `gea::Value`, so a field whose carrier has no tag --
+ * an `optional`, an iterator, a CALLABLE -- refuses at run time by name
+ * (`refuseUnaddressableField`). `this[name] = fn` where `name: 'a' | 'b'` and
+ * both fields hold a callable is a perfectly static write that the dynamic
+ * route cannot express; asked as a closed set, it is two ordinary stores.
+ */
+export interface TypedComputedWriteRecipe {
+    readonly kind: 'closed-record';
+    readonly receiver: string;
+    readonly keys: readonly string[];
+}
+/**
+ * Publishes a candidate closed computed-write recipe.
+ *
+ * The exclusions are the read's, for the read's reasons, plus one of its own:
+ * an ACCESSOR anywhere on the receiver means a key might name a setter rather
+ * than storage, and a field switch would write past it. Symbol keys cannot be
+ * named by a string literal at all. A field that is not required carries a
+ * presence bit, which the constant-key renderer does set -- so those are
+ * admitted, and it is the accessor case alone that is refused here.
+ */
+export declare const typedComputedWriteRecipeOf: (graph: SemanticGraph, operation: PropertyOperation, receiver: Representation, deriver: RepresentationDeriver, classes: ReadonlyMap<DeclarationId, ClassLayout>) => TypedComputedWriteRecipe | null;

package/dist/ir/typed-property-access.js

@@ -0,0 +1,161 @@
+import { declaredRecordFieldOf } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+import { operandOf } from '../semantics/model/operands.js';
+/**
+ * A key whose value set cannot be enumerated, so the record's own fields bound
+ * the read instead. Numeric and nullish keys were always here; a plain `string`
+ * key belongs for the same reason, and it is the common case -- `for (const key
+ * in values) target[key]`, a shader-chunk table read by name -- that otherwise
+ * costs the whole receiver its sealed field protocol.
+ *
+ * The comment this replaces excluded strings because a string key CAN name
+ * `Object.prototype.toString` while a numeric one cannot. That is a true fact
+ * about JavaScript and the wrong test for this recipe: the route this
+ * certificate replaces is `gea_readOwnField`, an OWN-property read over a
+ * record with no prototype object in the model at all, so absence already
+ * answers `undefined` on both routes. The switch changes which instructions
+ * run, never which value comes back.
+ *
+ * Symbol keys stay out. A symbol is not addressable by a string field switch
+ * and cannot be rendered into one, which is also why symbol-keyed fields
+ * disqualify the receiver above.
+ */
+const receiverBoundedPropertyKeyOf = (key) => {
+    if (key.kind === 'null' || key.kind === 'undefined' || key.kind === 'string')
+        return true;
+    if (key.kind === 'optional')
+        return receiverBoundedPropertyKeyOf(key.payload);
+    if (key.kind === 'tagged-union')
+        return key.arms.length > 0 && key.arms.every((arm) => receiverBoundedPropertyKeyOf(arm.value));
+    return key.kind === 'scalar' && (key.domain === 'number' || key.domain === 'int32' || key.domain === 'uint32' || key.domain === 'float64');
+};
+const stringLiteralTextsOf = (graph, type, visited = new Set()) => {
+    if (visited.has(type))
+        return null;
+    visited.add(type);
+    const entry = graph.structuralTypes.get(type);
+    if (!entry)
+        return null;
+    const shape = entry.shape;
+    if (shape.kind === 'literal')
+        return shape.primitive === 'string' ? [shape.text] : null;
+    if (shape.kind === 'declared' && shape.body !== null)
+        return stringLiteralTextsOf(graph, shape.body, visited);
+    if (shape.kind !== 'union' || shape.members.length === 0)
+        return null;
+    const texts = [];
+    for (const member of shape.members) {
+        const nested = stringLiteralTextsOf(graph, member, new Set(visited));
+        if (nested === null)
+            return null;
+        texts.push(...nested);
+    }
+    return [...new Set(texts)].sort();
+};
+/**
+ * Publishes a candidate fixed-field computed-read recipe from the
+ * semantic/representation contracts. A later whole-program reflection census
+ * is the authority for whether the receiver can escape to mutation, an
+ * accessor, or an unknown call; that finalization pass must revoke this
+ * candidate when it finds such demand. This selector deliberately excludes
+ * index-bearing, accessor-bearing, symbol-bearing and optional layouts: each
+ * can have an additional runtime answer that a direct field switch would
+ * erase even before whole-program exposure is considered.
+ */
+export const typedComputedReadRecipeOf = (graph, operation, receiver, result, keyRepresentation, deriver, classes, conversions) => {
+    if (operation.internalMethod !== 'get' || !operation.keyIsComputed)
+        return null;
+    if (receiver.kind !== 'record' || receiver.accessors.length !== 0)
+        return null;
+    if (receiver.fields.some((field) => !field.required || field.key.startsWith('sym(')))
+        return null;
+    if (!operandOf(operation, 'receiver'))
+        return null;
+    const keyOperand = operandOf(operation, 'key');
+    if (!keyOperand)
+        return null;
+    let keys = stringLiteralTextsOf(graph, keyOperand.type);
+    let receiverBounded;
+    if (keys === null && receiverBoundedPropertyKeyOf(keyRepresentation)) {
+        const missing = conversions.nodeFor({ kind: 'undefined' }, result);
+        if (missing.capability.kind === 'never')
+            return null;
+        // The receiver, rather than the key's value set, bounds these arms.
+        // Exposure finalization still revokes this recipe for unknown mutation.
+        keys = receiver.fields.map((field) => field.key);
+        receiverBounded = { carrier: representationKey(keyRepresentation), missing: missing.id };
+    }
+    if (keys === null || keys.length === 0)
+        return null;
+    const arms = [];
+    for (const key of keys) {
+        const field = declaredRecordFieldOf(deriver, receiver, key, classes);
+        if (field === null)
+            return null;
+        const conversion = conversions.nodeFor(field.value, result);
+        if (conversion.capability.kind === 'never')
+            return null;
+        arms.push({ key, source: field.value, conversion: conversion.id });
+    }
+    if (arms.length === 0 || arms.some((arm) => representationKey(arm.source) === 'unresolved'))
+        return null;
+    return {
+        kind: 'closed-record',
+        receiver: representationKey(receiver),
+        result: representationKey(result),
+        arms,
+        ...(receiverBounded === undefined ? {} : { receiverBounded })
+    };
+};
+/**
+ * Publishes a candidate closed computed-write recipe.
+ *
+ * The exclusions are the read's, for the read's reasons, plus one of its own:
+ * an ACCESSOR anywhere on the receiver means a key might name a setter rather
+ * than storage, and a field switch would write past it. Symbol keys cannot be
+ * named by a string literal at all. A field that is not required carries a
+ * presence bit, which the constant-key renderer does set -- so those are
+ * admitted, and it is the accessor case alone that is refused here.
+ */
+export const typedComputedWriteRecipeOf = (graph, operation, receiver, deriver, classes) => {
+    if (operation.internalMethod !== 'set' || !operation.keyIsComputed)
+        return null;
+    if (receiver.kind === 'record' && receiver.accessors.length !== 0)
+        return null;
+    if (receiver.kind !== 'record' && receiver.kind !== 'class-ref')
+        return null;
+    if (receiver.kind === 'class-ref' && classAccessorKeysOf(classes, receiver.declaration).size !== 0)
+        return null;
+    if (!operandOf(operation, 'receiver'))
+        return null;
+    const keyOperand = operandOf(operation, 'key');
+    if (!keyOperand)
+        return null;
+    const keys = stringLiteralTextsOf(graph, keyOperand.type);
+    if (keys === null || keys.length === 0)
+        return null;
+    if (keys.some((key) => key.startsWith('sym(')))
+        return null;
+    for (const key of keys) {
+        const field = declaredRecordFieldOf(deriver, receiver, key, classes);
+        if (field === null || representationKey(field.value) === 'unresolved')
+            return null;
+    }
+    return { kind: 'closed-record', receiver: representationKey(receiver), keys };
+};
+/** Every accessor key on a class and its bases -- the exclusion above, asked once. */
+const classAccessorKeysOf = (classes, declaration) => {
+    const keys = new Set();
+    const seen = new Set();
+    let current = declaration;
+    while (current !== null && !seen.has(current)) {
+        seen.add(current);
+        const layout = classes.get(current);
+        if (!layout)
+            break;
+        for (const accessor of layout.accessors)
+            keys.add(accessor.key);
+        current = layout.base;
+    }
+    return keys;
+};

package/dist/ir/verify.d.ts

@@ -0,0 +1,19 @@
+import type { IrValueId } from '../identity/ids.js';
+import { type IrBlockId, type IrBody } from './model.js';
+/**
+ * Fail-closed guards over one IR body.
+ *
+ * Every guard here describes a state that would otherwise compile into a
+ * silently wrong or undefined program: a dangling reference, a phi that
+ * disagrees with its own predecessors, a carrier that never got selected. A
+ * guard firing is always correct; the defect is in whatever produced the
+ * body, never in the guard (mirrors `representation/verify.ts`).
+ */
+export interface IrViolation {
+    readonly guard: string;
+    readonly value: IrValueId | null;
+    readonly block: IrBlockId | null;
+    readonly message: string;
+}
+/** Run every guard and return the complete violation set, never just the first. */
+export declare const verifyIrBody: (body: IrBody) => readonly IrViolation[];