@geastack/compiler 1.0.15

package/dist/targets/cpp/property-read-claims.d.ts

@@ -0,0 +1,62 @@
+import type { IrValueId } from '../../identity/ids.js';
+import type { GetOperation, IrOperand } from '../../ir/model.js';
+/**
+ * Claims lifted out of `emit-properties.ts`'s `emitGet` ladder: each rung
+ * below used to decide, inline, WHAT KIND of read a `get` is at the same
+ * point it composed the C++ text for it. Per the single-census architecture's
+ * architecture rule, a decision and its spelling are two different questions,
+ * and only the second may stay at the render site.
+ *
+ * Every claim here is pure in already-settled facts -- `staticKeyTexts`,
+ * `unreadValues`, and the IR's own carriers -- and mints nothing: no name, no
+ * declaration, no buffer push, and no read of anything a printer has already
+ * written (`ctx.valueNames`/`operandText`). That is what makes each one safe
+ * to ask before the first line of a body renders, not only from `emitGet`
+ * itself.
+ */
+/**
+ * The named-field half of a `record-with-index` receiver's own split layout
+ * (see `emit-properties.ts`'s `recordWithIndexFieldText`, the sole caller):
+ * whether a `get`'s key is a *constant* text that names one of the carrier's
+ * own declared `fields`, as opposed to the sidecar's open half.
+ *
+ * `ir/certify/property-access.ts`'s `recordWithIndexKeyNamesAField` asks the
+ * identical question -- `representation.kind === 'record-with-index'` and a
+ * `.fields.some/.find` against the same key text -- over the semantic
+ * operand's own key/representation rather than the IR's. The two have not
+ * been unified here: they live in different layers (`ir/certify/` certifies
+ * a semantic operation before lowering; this asks an already-lowered `get`'s
+ * settled `staticKeyTexts`) and unifying them is out of this file's scope,
+ * but a caller auditing "does anything else answer this" should start there
+ * rather than assume this is the only place that knows.
+ */
+export interface RecordWithIndexFieldClaim {
+    readonly fieldKey: string;
+}
+export declare const recordWithIndexFieldClaimOf: (staticKeyTexts: ReadonlyMap<IrValueId, string>, receiver: IrOperand, key: IrOperand) => RecordWithIndexFieldClaim | null;
+/**
+ * Whether a `get` off a native callable is a deferred read of
+ * `Function.prototype.call`/`apply`/`bind` that a call downstream already
+ * rewrote away -- `ir/lower-invocation.ts`'s `deferredFunctionCallCalleeOf`/
+ * `deferredFunctionApplyCalleeOf`/the direct `bind` lowering into
+ * `bind-callable` -- so this read itself has nothing left to spell and the
+ * result the lowering left unread is the proof of it.
+ *
+ * `isNativeCallableCarrier` is the one authority for the carrier-kind half,
+ * asked here instead of re-listing callable representation kinds a fourth
+ * time -- see `emit-properties.ts`'s own comment on the drift that cost one
+ * spelling of that list `function-value-family`.
+ *
+ * A THIRD authority answers a related but not identical question at a third
+ * pipeline stage: `ir/certify/property-access-keys.ts`'s
+ * `callableBuiltinResolutionAt`/`callableBuiltinRecipeKey` certifies, from the
+ * semantic graph and a synthetic plan, whether a `.call`/`.apply`/`.bind`
+ * property read has a renderable recipe at all; `projection/callee.ts`'s
+ * `deferredCalleeOf` decides, at lowering, whether the CALL that reads this
+ * `get`'s result rewrites to skip it. This claim answers neither of those --
+ * it only reads the LOWERED body's own settled facts to decide whether the
+ * `get` that survived lowering unread has anything left to print. Three
+ * questions, three stages; not reconciled here.
+ */
+export type CallableBuiltinReadClaim = 'call' | 'apply' | 'bind';
+export declare const deferredCallableBuiltinReadClaimOf: (staticKeyTexts: ReadonlyMap<IrValueId, string>, unreadValues: ReadonlySet<IrValueId>, operation: GetOperation) => CallableBuiltinReadClaim | null;

package/dist/targets/cpp/property-read-claims.js

@@ -0,0 +1,23 @@
+import { isNativeCallableCarrier } from './emit-dynamic-properties.js';
+export const recordWithIndexFieldClaimOf = (staticKeyTexts, receiver, key) => {
+    const representation = receiver.representation;
+    if (representation.kind !== 'record-with-index')
+        return null;
+    const staticKey = staticKeyTexts.get(key.value);
+    if (staticKey === undefined)
+        return null;
+    const field = representation.fields.find((entry) => entry.key === staticKey);
+    if (!field)
+        return null;
+    return { fieldKey: staticKey };
+};
+export const deferredCallableBuiltinReadClaimOf = (staticKeyTexts, unreadValues, operation) => {
+    if (!isNativeCallableCarrier(operation.receiver.representation.kind))
+        return null;
+    if (!unreadValues.has(operation.result.id))
+        return null;
+    const key = staticKeyTexts.get(operation.key.value);
+    if (key === 'call' || key === 'apply' || key === 'bind')
+        return key;
+    return null;
+};

package/dist/targets/cpp/property-store-claims.d.ts

@@ -0,0 +1,62 @@
+import type { IrBody } from '../../ir/model.js';
+import type { IrValueId } from '../../identity/ids.js';
+import type { EmitContext } from './emit-context.js';
+import { type NamespaceMemberStoreSpelling } from './emit-namespaces.js';
+import { type RegExpDynamicSetClaim } from './prototype/emit-prototype-regexp.js';
+/**
+ * Every store-side property claim in one body, settled before it renders a
+ * line -- the write counterpart of `prototype/prototype-method-reads.ts`'s
+ * `prototypeMethodReadsOf`. `emit-properties.ts`'s store ladder
+ * (`emitFieldStore` -> `emitFieldStoreLines`) has around a dozen rungs; this
+ * walk covers the two whose whole decision is a pure function of settled
+ * facts (invariant 5: no write during render): `namespaceMemberStore`
+ * and `emitRegExpSet`. The rest stay render-time resolvers for now, exactly
+ * as the get-side migration moved one carrier at a time.
+ *
+ * Both claims below are called TWICE by design: once here, to settle the
+ * fact before any line of the body prints, and once by the resolver that
+ * spells it. A claim being pure -- it takes only `ctx` and the operation, and
+ * reads nothing a printer has written -- is what makes calling it twice free
+ * of the two-authorities defect this refactor exists to remove: there is one
+ * decision, asked twice, not two decisions that happen to agree today. The
+ * same shape the sixteen `deferred*MethodClaim` functions already use for the
+ * get side.
+ *
+ * `regexpStoreRefusal` (`prototype/emit-prototype-regexp.ts`'s third rung) is
+ * deliberately NOT walked here, even though its own decision was extracted
+ * into a claim (`regexpStoreRefusalClaim`) the same way. Its only outcomes
+ * past "not a RegExp" are "declines silently" (lastIndex, a genuine expando)
+ * and "refuses" -- and a refusal is not a fact anything downstream reads: it
+ * has no C++ to schedule and no value id to key a census by. Recording it
+ * here would mean either throwing from this walk -- which would report
+ * whichever refusal this store-only walk reaches first, rather than whichever
+ * operation of ANY kind actually renders first in the body, a reordering the
+ * refactor's own byte-identical gate cannot see (it counts refusals per
+ * program, not which one fires when several are present) -- or keeping a map
+ * nothing consults. Both are worse than leaving it a resolver-only decision
+ * until a genuine downstream reader shows up to justify one.
+ */
+export interface PropertyStoreClaims {
+    /**
+     * Every `set`/`define-own-property` this body resolves as a write through a
+     * host namespace, keyed by the store's own result id. See
+     * `EmitContext.namespaceMemberStores` for why that id is worth recording at
+     * all: a namespace receiver publishes no value, so `namespaceMemberStore`
+     * never mints this result -- a value id appearing here is exactly a value
+     * id that will never reach `defineValue`, the same kind of fact
+     * `hostNamespaceReads`/`hostNamespaceValues` already state for a namespace
+     * READ.
+     */
+    readonly namespaceMemberStores: ReadonlyMap<IrValueId, NamespaceMemberStoreSpelling>;
+    /**
+     * Every `set` this body resolves as a dynamic write into a RegExp Pattern's
+     * identity-keyed sidecar (a computed key, or a named expando that is not
+     * one of the ten `RegExp.prototype` members), keyed by the store's own
+     * result id -- unlike the namespace map above, this result IS minted
+     * (`emitRegExpSet` threads the receiver through `defineValue` once the
+     * dynamic write renders), so this map's fact is "this store's own decision
+     * is dynamic", not "this value id will never be defined".
+     */
+    readonly regexpDynamicSets: ReadonlyMap<IrValueId, RegExpDynamicSetClaim>;
+}
+export declare const propertyStoreClaimsOf: (ctx: EmitContext, body: IrBody) => PropertyStoreClaims;

package/dist/targets/cpp/property-store-claims.js

@@ -0,0 +1,26 @@
+import { allOperationsOf } from '../../ir/model.js';
+import { namespaceMemberStoreClaim } from './emit-namespaces.js';
+import { regexpDynamicSetClaim } from './prototype/emit-prototype-regexp.js';
+export const propertyStoreClaimsOf = (ctx, body) => {
+    const namespaceMemberStores = new Map();
+    const regexpDynamicSets = new Map();
+    for (const block of body.blocks.values()) {
+        for (const operation of allOperationsOf(block)) {
+            if (operation.kind !== 'set' && operation.kind !== 'define-own-property')
+                continue;
+            // Neither claim below has anything to key a census entry by when this
+            // particular store publishes no result -- and nothing outside this
+            // walk could look one up by a value id that was never minted either.
+            if (operation.result === null)
+                continue;
+            const namespaceClaim = namespaceMemberStoreClaim(ctx, operation);
+            if (namespaceClaim !== null && namespaceClaim.kind === 'resolved') {
+                namespaceMemberStores.set(operation.result.id, { key: namespaceClaim.key, setter: namespaceClaim.setter });
+            }
+            const regexpClaim = regexpDynamicSetClaim(ctx, operation);
+            if (regexpClaim !== null)
+                regexpDynamicSets.set(operation.result.id, regexpClaim);
+        }
+    }
+    return { namespaceMemberStores, regexpDynamicSets };
+};

package/dist/targets/cpp/prototype/emit-prototype-array.d.ts

@@ -0,0 +1,111 @@
+import type { IrOperand, IrResult } from '../../../ir/model.js';
+import type { Representation } from '../../../representation/model.js';
+import { type EmitContext } from '../emit-context.js';
+/**
+ * `Array.prototype`, as this backend renders it.
+ *
+ * Clause numbers throughout are ECMA-262 2023 (14th edition), where
+ * `Array.prototype`'s members are numbered alphabetically -- stated because the
+ * numbering shifts every edition that adds a member, so a clause is only
+ * unambiguous once its edition is named. The member NAME is the identity; the
+ * clause is the pointer.
+ *
+ * The mechanism is `emit-prototype-invoke.ts`'s -- a deferred `[[Get]]` fused
+ * with the call that follows -- and its header states why. What lives here is
+ * the table: which members are claimed, at which arities, over which argument
+ * carriers, and which are refused BY NAME with what missing.
+ *
+ * The runtime behind it is `gea::runtime::array` over this backend's own
+ * `ArrayObject<E>`. That namespace's header states why these are written
+ * rather than ported: v1's typed (`std::vector<T>`) array surface stops at
+ * length, indexed get/set and iteration, and every method past that takes a
+ * BOXED `gea_cpp_value` receiver -- which a statically typed array may not be
+ * lowered into. v1's generic implementation is the spec reference the step
+ * order follows; the carrier stays typed.
+ *
+ * Two rules recur below and are stated once here:
+ *
+ *  - An argument that must BE an element (`indexOf`'s needle, `fill`'s value)
+ *    is checked against the receiver's own element carrier by
+ *    `representationKey`. The checker's `T` binds identically for both, so a
+ *    disagreement should never happen -- but if it did it would alias two
+ *    differently laid-out `ArrayObject<T>` instantiations, a real miscompile
+ *    C++ would not catch, so it is refused rather than assumed (`push`'s own
+ *    long-standing check, generalized).
+ *  - A CALLBACK argument is converted, not checked: `gea::runtime::array`'s
+ *    templates invoke whatever they are handed with the element type, at the
+ *    arity the callable actually takes, and where the callback's first
+ *    parameter is declared WIDER than the element the element is injected into
+ *    it at the boundary (`elementAdaptedCallbackText`), by the same conversion
+ *    authority every direct call site uses. Anything past that is left to C++,
+ *    which rejects a callable that cannot take what it is handed at the same
+ *    call this renders.
+ */
+/** The one signature every member's renderer has. `element` is the receiver's own element carrier; `result` is read by the members whose ECMA-262 result can be `undefined`. */
+export type ArrayCallRenderer = (ctx: EmitContext, receiverText: string, element: Representation, args: readonly IrOperand[], result: IrResult | null) => string;
+/**
+ * The mutating bulk pair, ECMA-262 23.1.3.23 `push` and 23.1.3.37 `unshift`.
+ *
+ * Both take a rest parameter, so `ir/lower.ts`'s `packRestArguments` has
+ * already packed every call argument into one `array-object` before this runs
+ * -- a three-argument `a.push(x, y, z)` arrives here as `args.length === 1`.
+ * That is what makes the rendering a two-step bulk write rather than a
+ * comma-chain of one call per argument: `appendRange`/`prependRange`
+ * (gea_runtime.h) already are "insert every slot of one `ArrayObject` into
+ * another, in order, holes and all", which for a rest pack is exactly the
+ * spec's own loop. The observable end state is identical for a plain array
+ * with no exotic `length`/index setters, which is the only receiver an
+ * `array-object` carrier ever is. The final `Set(O, "length", len)` and
+ * `Return len` are the same `->length()` read `.length` already uses.
+ *
+ * A comma expression: C++ sequences the bulk write fully before `length()`
+ * reads it, so this is one expression whose value is the new length -- exactly
+ * the shape `emitCall` renders either as a bare statement or as an assignment.
+ */
+/**
+ * The one `arrayMethods` entry `emit-arrays.ts`'s counted-loop census also has
+ * to recognize, by name, before this table has run at all -- see that file's
+ * `pushLookups`. Named here rather than left a bare `'push'` literal in both
+ * files so the two cannot silently name two different methods: this is a
+ * bulk APPEND specifically (ECMA-262 23.1.3.23), not `unshift`'s bulk prepend,
+ * because the loop rewrite it feeds only ever turns a counted push into a
+ * range append -- a counted `unshift` would have to run its bound in reverse,
+ * which nothing here builds.
+ */
+export declare const arrayBulkAppendMethodName = "push";
+/** `emit-carrier-members.ts`'s `arrayAccessText` defers exactly these keys off an `array-object` receiver -- one authority for "is this method implemented". */
+export declare const arrayMethods: ReadonlyMap<string, ArrayCallRenderer>;
+export declare const arrayPrototypeMethods: ReadonlySet<string>;
+/**
+ * Members this backend states a REASON for not implementing, rather than
+ * letting them fall into the generic "here is the list of what is implemented"
+ * refusal. "Not built yet" and "cannot be built without X" are different
+ * answers, and only the second tells you what to build.
+ */
+/**
+ * Names an Array INHERITS -- from `Array.prototype` or, past it,
+ * `Object.prototype` -- that this backend renders nothing for.
+ *
+ * Kept apart from `arrayMemberRefusals` above, which is about members
+ * `Array.prototype` itself declares and this backend has simply not built.
+ * These are the reason `arrayAccessText` may not treat "not an index, not
+ * `length`, not an extension field, not a method" as "an ordinary own
+ * property, ask the expando sidecar": the sidecar answers OWN properties, and
+ * for every name here the language answers from the PROTOTYPE CHAIN instead.
+ * Handing one to the sidecar would find nothing and publish `undefined` --
+ * turning a compile-time refusal into a silently wrong answer, which is the
+ * one trade this backend never makes.
+ */
+export declare const arrayInheritedMemberRefusals: ReadonlySet<string>;
+export declare const arrayMemberRefusals: ReadonlyMap<string, string>;
+/**
+ * The Array.prototype members that MUTATE their receiver (ECMA-262 23.1.3).
+ *
+ * Read by `emitCall` to tick a reactive array's revision cell after a call that
+ * changed its contents. It is a property of the language, not of this
+ * backend's rendering of it -- `slice` and `concat` build a new array and
+ * change nothing, `splice` and `sort` change the receiver in place -- so it is
+ * stated once here beside the renderings rather than re-derived from what each
+ * one happens to emit.
+ */
+export declare const mutatingArrayMembers: ReadonlySet<string>;