@geastack/compiler 1.0.15

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

@@ -0,0 +1,53 @@
+import { representationKey } from '../representation/model.js';
+/** The sequence/generator distinction is published by representation/publish.ts.
+ * A sequence advances native storage; a generator can execute arbitrary code.
+ * This is an effect query shared by provenance and reflection, not an admission
+ * rule: lowering and certification still validate the complete cursor recipe.
+ */
+export const nativeSequenceTransportOf = (operation) => {
+    const sequence = (value) => value.kind === 'iterator' && value.source === 'sequence' && value.resume.kind === 'undefined' && value.completion.kind === 'undefined';
+    if (operation.kind === 'iterator-done')
+        return (sequence(operation.iterator.representation) &&
+            operation.result.representation.kind === 'scalar' &&
+            operation.result.representation.domain === 'boolean');
+    if (operation.kind === 'iterator-next') {
+        const cursor = operation.iterator.representation;
+        if (!sequence(cursor) || operation.value !== null)
+            return false;
+        const result = operation.result.representation;
+        return (representationKey(result) === representationKey(cursor.element) ||
+            (result.kind === 'optional' &&
+                result.absence === 'undefined' &&
+                representationKey(result.payload) === representationKey(cursor.element)));
+    }
+    if (operation.kind !== 'get-iterator' || operation.protocol !== 'iterator' || operation.method !== null)
+        return false;
+    const cursor = operation.result.representation;
+    if (!sequence(cursor))
+        return false;
+    const carried = operation.receiver.representation;
+    const source = carried.kind === 'optional' ? carried.payload : carried;
+    if (source.kind === 'iterator')
+        return sequence(source) && representationKey(source) === representationKey(cursor);
+    if (source.kind === 'string')
+        return cursor.element.kind === 'string';
+    if (source.kind === 'array-object')
+        return source.ownership === 'shared-refcount' && representationKey(source.element) === representationKey(cursor.element);
+    if (source.kind === 'keyed-collection' && source.ownership === 'shared-refcount') {
+        if (source.family === 'set')
+            return representationKey(source.key) === representationKey(cursor.element);
+        const pair = cursor.element;
+        return (source.family === 'map' &&
+            source.value !== null &&
+            pair.kind === 'record' &&
+            pair.accessors.length === 0 &&
+            pair.fields.length === 2 &&
+            pair.fields.every((field, i) => field.key === String(i) &&
+                field.required &&
+                representationKey(field.value) === representationKey(i === 0 ? source.key : source.value)));
+    }
+    return (source.kind === 'record' &&
+        source.accessors.length === 0 &&
+        source.fields.length > 0 &&
+        source.fields.every((field, i) => field.key === String(i) && field.required && representationKey(field.value) === representationKey(cursor.element)));
+};

package/dist/ir/numeric-intrinsics.d.ts

@@ -0,0 +1,13 @@
+import type { IrValueId } from '../identity/ids.js';
+import type { CallOperation, IrBody } from './model.js';
+export type NumericIntrinsic = 'imul';
+/**
+ * Language builtin calls authenticated by their native protocol, never by a
+ * source identifier spelling. A user object named Math has no such protocol.
+ * Keep first-class function reads intact; only reads consumed entirely by
+ * these direct calls may omit their callable carrier.
+ */
+export declare const numericIntrinsicsOf: (body: IrBody) => {
+    readonly calls: ReadonlyMap<CallOperation, NumericIntrinsic>;
+    readonly callOnly: ReadonlySet<IrValueId>;
+};

package/dist/ir/numeric-intrinsics.js

@@ -0,0 +1,57 @@
+import { allOperationsOf } from './model.js';
+import { operandsOfIrOperation } from './queries.js';
+/**
+ * Language builtin calls authenticated by their native protocol, never by a
+ * source identifier spelling. A user object named Math has no such protocol.
+ * Keep first-class function reads intact; only reads consumed entirely by
+ * these direct calls may omit their callable carrier.
+ */
+export const numericIntrinsicsOf = (body) => {
+    const keys = new Map();
+    const callees = new Map();
+    const calls = new Map();
+    const callOnly = new Set();
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind === 'constant' && operation.literal === 'string')
+                keys.set(operation.result.id, operation.text);
+        }
+    }
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind !== 'get')
+                continue;
+            const receiver = operation.receiver.representation;
+            if (receiver.kind === 'native-handle' &&
+                receiver.native === null &&
+                receiver.protocol === 'Math' &&
+                keys.get(operation.key.value) === 'imul') {
+                callees.set(operation.result.id, 'imul');
+            }
+        }
+    }
+    for (const block of body.blocks.values()) {
+        for (const operation of block.operations) {
+            if (operation.kind !== 'call')
+                continue;
+            const intrinsic = callees.get(operation.callee.value);
+            // Other arities and coercing ABIs retain the general callable path.
+            if (intrinsic === undefined || operation.arguments.length !== 2)
+                continue;
+            if (!operation.arguments.every((argument) => argument.representation.kind === 'scalar' && argument.representation.domain === 'number'))
+                continue;
+            calls.set(operation, intrinsic);
+            callOnly.add(operation.callee.value);
+        }
+    }
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            const operands = operation.kind === 'call' && calls.has(operation)
+                ? [...(operation.receiver ? [operation.receiver] : []), ...operation.arguments]
+                : operandsOfIrOperation(operation);
+            for (const operand of operands)
+                callOnly.delete(operand.value);
+        }
+    }
+    return { calls, callOnly };
+};

package/dist/ir/object-value-conversions.d.ts

@@ -0,0 +1,20 @@
+import type { ConversionNodeId } from '../conversion/algebra.js';
+import type { ConversionCensus } from '../conversion/nodes.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type Representation } from '../representation/model.js';
+import type { IrOperand } from './model.js';
+export interface ObjectValueConversionInput {
+    readonly role: 'descriptor-value' | 'callable-property';
+    readonly argument: number;
+    readonly field: string;
+    readonly source: Representation;
+    readonly target: Representation;
+}
+/** Values produced inside an authenticated Object intrinsic's field walk
+ * still require a conversion citation before certification and printing. */
+export interface ObjectValueConversion extends ObjectValueConversionInput {
+    readonly conversion: ConversionNodeId;
+}
+export declare const objectValueConversionInputsOf: (intrinsic: string | undefined, args: readonly IrOperand[], deriver: RepresentationDeriver) => readonly ObjectValueConversionInput[];
+export declare const objectValueConversionsOf: (intrinsic: string | undefined, args: readonly IrOperand[], deriver: RepresentationDeriver, conversions: ConversionCensus) => readonly ObjectValueConversion[];
+export declare const objectValueConversionsMatch: (expected: readonly ObjectValueConversionInput[], actual: readonly ObjectValueConversion[], conversions: Pick<ConversionCensus, "nodeById">) => boolean;

package/dist/ir/object-value-conversions.js

@@ -0,0 +1,50 @@
+import { isNativeCallableCarrier } from '../representation/callable-object.js';
+import { recordFieldsOfShape } from '../projection/fields.js';
+import { representationKey } from '../representation/model.js';
+export const objectValueConversionInputsOf = (intrinsic, args, deriver) => {
+    const dynamic = { kind: 'dynamic', reason: 'declared-any-never-narrowed' };
+    const fieldsOf = (value) => {
+        if (value.kind === 'optional')
+            return fieldsOf(value.payload);
+        if (value.kind === 'record' || value.kind === 'record-with-index')
+            return value.fields;
+        if (value.kind === 'class-ref' || (value.kind === 'native-record-ref' && value.native === null))
+            return recordFieldsOfShape(deriver, value.shapeId) ?? [];
+        return [];
+    };
+    if (intrinsic === 'object-define-property') {
+        const descriptor = args[2]?.representation;
+        const value = descriptor && fieldsOf(descriptor).find((field) => field.key === 'value');
+        if (!value)
+            return [];
+        const source = value.value.kind === 'optional' && value.value.absence === 'undefined' ? value.value.payload : value.value;
+        return source.kind === 'dynamic' ? [] : [{ role: 'descriptor-value', argument: 2, field: 'value', source, target: dynamic }];
+    }
+    const target = args[0]?.representation;
+    if (intrinsic !== 'object-assign' || !target || !isNativeCallableCarrier(target.kind))
+        return [];
+    return args.slice(1).flatMap((argument, index) => fieldsOf(argument.representation).map((field) => ({
+        role: 'callable-property',
+        argument: index + 1,
+        field: field.key,
+        source: field.value,
+        target: dynamic
+    })));
+};
+export const objectValueConversionsOf = (intrinsic, args, deriver, conversions) => objectValueConversionInputsOf(intrinsic, args, deriver).map((input) => ({
+    ...input,
+    conversion: conversions.nodeFor(input.source, input.target).id
+}));
+export const objectValueConversionsMatch = (expected, actual, conversions) => expected.length === actual.length &&
+    expected.every((input, index) => {
+        const value = actual[index];
+        const node = conversions.nodeById(value.conversion);
+        return (input.role === value.role &&
+            input.argument === value.argument &&
+            input.field === value.field &&
+            representationKey(input.source) === representationKey(value.source) &&
+            representationKey(input.target) === representationKey(value.target) &&
+            node !== null &&
+            representationKey(node.source) === representationKey(input.source) &&
+            representationKey(node.target) === representationKey(input.target));
+    });

package/dist/ir/physical-class-reflection.d.ts

@@ -0,0 +1,9 @@
+import type { DeclarationId } from '../identity/ids.js';
+import type { PhysicalClassLayout } from '../projection/classes.js';
+import type { ReflectionExposure } from './reflection-demand.js';
+/** A derived field protocol calls and overrides the protocol of its physical
+ * base. Type-only layouts participate in that contract even when no class
+ * lifecycle survives. Retain ancestor hooks without inventing a publication
+ * of their fields' payloads or exposing sibling classes.
+ */
+export declare const closePhysicalClassReflection: (exposure: ReflectionExposure, layouts: ReadonlyMap<DeclarationId, PhysicalClassLayout>) => ReflectionExposure;

package/dist/ir/physical-class-reflection.js

@@ -0,0 +1,57 @@
+import { representationKey } from '../representation/model.js';
+/** A derived field protocol calls and overrides the protocol of its physical
+ * base. Type-only layouts participate in that contract even when no class
+ * lifecycle survives. Retain ancestor hooks without inventing a publication
+ * of their fields' payloads or exposing sibling classes.
+ */
+export const closePhysicalClassReflection = (exposure, layouts) => {
+    if (!exposure.complete)
+        return exposure;
+    const classes = new Map(exposure.classes);
+    const byRepresentation = new Map(exposure.byRepresentation);
+    const joinSupport = (existing, demand) => {
+        const fieldOperations = new Map();
+        const restricted = existing?.fieldOperations !== undefined && demand.fieldOperations !== undefined;
+        if (restricted)
+            for (const source of [existing.fieldOperations, demand.fieldOperations])
+                for (const [key, uses] of source) {
+                    const merged = fieldOperations.get(key) ?? new Set();
+                    for (const use of uses)
+                        merged.add(use);
+                    fieldOperations.set(key, merged);
+                }
+        return {
+            level: 'full',
+            ...(restricted ? { fieldOperations } : {}),
+            reasons: new Set([...(existing?.reasons ?? []), ...demand.reasons, 'inherited-physical-protocol']),
+            representations: new Set([...(existing?.representations ?? []), ...demand.representations])
+        };
+    };
+    for (const layout of layouts.values()) {
+        // Missing demand already means full protocol to every consumer. Publish
+        // that fail-closed default explicitly so its ancestors cannot prune it.
+        const demand = exposure.classes.get(layout.declaration) ?? {
+            level: 'full',
+            reasons: new Set(['uncensused-physical-layout']),
+            representations: new Set([representationKey(layout.instance)])
+        };
+        if (demand.level !== 'full')
+            continue;
+        classes.set(layout.declaration, joinSupport(classes.get(layout.declaration), demand));
+        const seen = new Set([layout.declaration]);
+        for (let base = layout.base; base !== null && !seen.has(base);) {
+            seen.add(base);
+            const ancestor = layouts.get(base);
+            if (!ancestor)
+                break; // Missing physical ancestry is refused by its publication.
+            classes.set(base, joinSupport(classes.get(base), demand));
+            base = ancestor.base;
+        }
+    }
+    for (const [declaration, demand] of classes) {
+        const layout = layouts.get(declaration);
+        if (layout)
+            byRepresentation.set(representationKey(layout.instance), demand);
+    }
+    return { ...exposure, classes, byRepresentation };
+};

package/dist/ir/presence-proof.d.ts

@@ -0,0 +1,42 @@
+import type { IrValueId } from '../identity/ids.js';
+import { type IrBody, type IrOperation } from './model.js';
+/**
+ * Which loads out of an `optional` carrier the program itself proves present.
+ *
+ * A `convert` from `optional(T, absence)` to `T` is a load: `has_value`
+ * classifies and `operator*` reads the payload without testing it. The
+ * checker's type at the consumer is what asked for `T`, and the checker's type
+ * is not evidence -- `@type {number}` on a field three.js also writes
+ * `undefined` into says nothing about what the cell holds. Presence is a fact
+ * about the program's own control flow, and this module reads it off the
+ * lowered IR, where the test and the load are both instructions:
+ *
+ * - `guard`: a branch on a presence test of the loaded value itself --
+ *   `test` (`to-boolean`/`is-present`/`is-defined`), `!`, or a comparison
+ *   with the `undefined`/`null` constant -- whose proving edge dominates the
+ *   load. An SSA value never changes, so nothing between the test and the
+ *   load can undo it. `a || b`, `a ?? b` and a default's present arm all
+ *   reach their loads this way.
+ * - `cell`: the loaded value is a `binding-read` of a cell a forward
+ *   must-analysis proves present at that read -- every path to it passes a
+ *   write of a present value, or a presence test of an earlier read of the
+ *   same cell with nothing able to write the cell in between. A cell some
+ *   other body writes (a closure's capture, a global) loses its facts at
+ *   every operation that can run code.
+ *
+ * Nothing else proves presence. A load neither rule reaches is unproven,
+ * however confident the checker was.
+ */
+/** @semanticCategory generic-primitive */
+export type PresenceProof = 'guard' | 'cell';
+/** The proof, if any, behind every present-optional load in `bodies`, keyed by the load's result. */
+export declare const presenceProofsOf: (bodies: Iterable<IrBody>) => ReadonlyMap<IrValueId, PresenceProof>;
+/**
+ * `bodies` with every unchecked load no proof reaches marked
+ * `presence: 'checked'`. Which conversions read a payload without testing its
+ * flag is the target's fact, not this module's -- `readsUnchecked` asks the
+ * conversion census that installed them.
+ */
+export declare const withPresenceChecks: <K>(bodies: ReadonlyMap<K, IrBody>, readsUnchecked: (operation: Extract<IrOperation, {
+    kind: "convert";
+}>) => boolean) => ReadonlyMap<K, IrBody>;