@geastack/compiler 1.0.15

package/dist/targets/cpp/emit-native-equality.d.ts

@@ -0,0 +1,3 @@
+import type { NativeEqualityRecipe } from '../../ir/native-equality.js';
+/** The verified IR selects the comparison; the target only spells its native entry. */
+export declare const nativeEqualityText: (recipe: NativeEqualityRecipe, operands: readonly [string, string]) => string;

package/dist/targets/cpp/emit-native-equality.js

@@ -0,0 +1,14 @@
+const helpers = {
+    number: 'gea::strictEqualNumber',
+    boolean: 'gea::strictEqualBoolean',
+    string: 'gea::strictEqualString',
+    symbol: 'gea::strictEqualSymbol',
+    bigint: 'gea::strictEqualBigInt'
+};
+/** The verified IR selects the comparison; the target only spells its native entry. */
+export const nativeEqualityText = (recipe, operands) => {
+    const dynamic = operands[recipe.dynamicOperand];
+    const native = operands[recipe.dynamicOperand === 0 ? 1 : 0];
+    const comparison = `${helpers[recipe.primitive]}(${dynamic}, ${native})`;
+    return recipe.negate ? `!(${comparison})` : comparison;
+};

package/dist/targets/cpp/emit-native-selection.d.ts

@@ -0,0 +1,5 @@
+import type { NativeSelectionRecipe } from '../../conversion/native-selection.js';
+import type { Representation } from '../../representation/model.js';
+/** The census already chose every arm and transfer; this renderer only spells them. */
+export declare const nativeSelectionBody: (recipe: NativeSelectionRecipe, source: Representation, target: Representation) => string | null;
+export declare const nativeSelectionText: (recipe: NativeSelectionRecipe, source: Representation, target: Representation, text: string) => string | null;

package/dist/targets/cpp/emit-native-selection.js

@@ -0,0 +1,37 @@
+import { representationKey } from '../../representation/model.js';
+import { renderNativeSumPlan } from './emit-sum-widening.js';
+import { cppClassName, cppTypeOf, cppUndefinedValue } from './types.js';
+/** The census already chose every arm and transfer; this renderer only spells them. */
+export const nativeSelectionBody = (recipe, source, target) => {
+    if (recipe.source !== representationKey(source) || recipe.target !== representationKey(target))
+        return null;
+    const alias = 'GeaSelectionTarget';
+    const spell = (value) => (representationKey(value) === recipe.target ? alias : cppTypeOf(value));
+    const render = (step, value) => {
+        if (step === null)
+            return '';
+        switch (step.kind) {
+            case 'identity':
+                return `return ${value};`;
+            case 'null':
+                return `return ${alias}{};`;
+            case 'reference-null':
+                return `if (!(${value})) { ${render(step.absent, 'nullptr')} }`;
+            case 'transfer':
+                return `return ${renderNativeSumPlan(step.plan, value, spell, true)};`;
+            case 'class-cast':
+                return `return ${step.down ? `gea::host::downcastClassRef<${cppClassName(step.target.declaration)}>` : spell(step.target)}(${value});`;
+            case 'optional':
+                return `if ((${value}).has_value()) { ${render(step.present, `(*(${value}))`)} } else { ${render(step.absent, step.absence === 'null' ? 'nullptr' : cppUndefinedValue)} }`;
+            case 'dispatch':
+                return step.arms
+                    .map((arm, index) => arm === null ? '' : `if ((${value}).template is<${index}>()) { ${render(arm, `(${value}).template get<${index}>()`)} }`)
+                    .join(' ');
+        }
+    };
+    return `using ${alias} = ${cppTypeOf(target)}; ${render(recipe.step, 'gea_selection')} gea::detail::refusePayloadMismatch("native sum selection has no matching alternative");`;
+};
+export const nativeSelectionText = (recipe, source, target, text) => {
+    const body = nativeSelectionBody(recipe, source, target);
+    return body === null ? null : `([](const auto& gea_selection) -> ${cppTypeOf(target)} { ${body} })(${text})`;
+};

package/dist/targets/cpp/emit-object-tag.d.ts

@@ -0,0 +1,4 @@
+import { type Representation } from '../../representation/model.js';
+import type { EmitContext } from './emit-context.js';
+export declare const objectTagExpression: (rep: Representation, value: string, ctx?: EmitContext) => string | null;
+export declare const objectTagCapability: (rep: Representation) => string;

package/dist/targets/cpp/emit-object-tag.js

@@ -0,0 +1,108 @@
+import { representationKey } from '../../representation/model.js';
+import { disjointNativeRecordIndexOf } from '../../ir/native-record-index.js';
+import { cppRecordIndexSidecarNameFor, recordIndexesOfShape } from './records.js';
+import { cppStringLiteral } from './types.js';
+import { binaryToStringTagText } from './emit-buffers.js';
+import { cppDateType } from './prototype/emit-prototype-date.js';
+import { cppErrorNativeType } from './error-types.js';
+import { cppRegExpNativeTypes, cppStringObjectNativeType } from './regexp-types.js';
+/** Object.prototype.toString's builtin brand, followed by its ordinary @@toStringTag lookup. */
+const nativeTagValueText = (rep, value) => {
+    if (rep.kind === 'string')
+        return `(std::string("[object ") + ${value} + "]")`;
+    if (rep.kind === 'dynamic')
+        return `gea::objectTagWithOverride(${value}, "Object")`;
+    if (rep.kind === 'optional')
+        return `(${value}.has_value() ? ${nativeTagValueText(rep.payload, `(*${value})`)} : gea::objectTagText("Object"))`;
+    if (rep.kind === 'tagged-union')
+        return `(${rep.arms
+            .map((arm, index) => `${value}.is<${index}>() ? ${nativeTagValueText(arm.value, `${value}.get<${index}>()`)} : `)
+            .join('')}gea::objectTagText("Object"))`;
+    return 'gea::objectTagText("Object")';
+};
+export const objectTagExpression = (rep, value, ctx) => {
+    if ('ownership' in rep && rep.ownership !== 'shared-refcount')
+        return null;
+    if (rep.kind === 'function-value-dispatch' && rep.recursive)
+        return null;
+    const tag = (builtin, fallback) => `gea::objectTag(${value}, ${cppStringLiteral(builtin)}${fallback ? `, ${cppStringLiteral(fallback)}` : ''})`;
+    if (rep.kind === 'optional') {
+        const payload = objectTagExpression(rep.payload, `(*${value})`, ctx);
+        return payload === null
+            ? null
+            : `(${value}.has_value() ? ${payload} : std::string("[object ${rep.absence === 'null' ? 'Null' : 'Undefined'}]"))`;
+    }
+    if (rep.kind === 'tagged-union') {
+        const arms = rep.arms.map((arm, index) => objectTagExpression(arm.value, `${value}.get<${index}>()`, ctx));
+        if (arms.length === 0 || arms.some((arm) => arm === null))
+            return null;
+        return `(${arms
+            .slice(0, -1)
+            .map((arm, index) => `${value}.is<${index}>() ? ${arm} : `)
+            .join('')}${arms.at(-1)})`;
+    }
+    if (ctx && (rep.kind === 'record-with-index' || (rep.kind === 'native-record-ref' && rep.native === null))) {
+        const index = disjointNativeRecordIndexOf(ctx.deriver, rep, { kind: 'symbol' });
+        if (index) {
+            const indexes = rep.kind === 'record-with-index' ? rep.indexes : recordIndexesOfShape(ctx.deriver, rep.shapeId);
+            const member = cppRecordIndexSidecarNameFor(index, indexes);
+            return (`([&]() -> std::string { const auto& __gea_object = ${value}; if (!__gea_object) return gea::objectTagText("Null"); ` +
+                `const auto __gea_key = gea::wellKnownSymbol(gea::detail::WellKnownSymbol::ToStringTag); ` +
+                `if (__gea_object->${member}.has(__gea_key)) { const auto& __gea_tag = __gea_object->${member}.read(__gea_key); ` +
+                `return ${nativeTagValueText(index.value, '__gea_tag')}; } return gea::objectTag(__gea_object, "Object"); })()`);
+        }
+    }
+    if (rep.kind === 'null')
+        return 'std::string("[object Null]")';
+    if (rep.kind === 'undefined' || rep.kind === 'void')
+        return 'std::string("[object Undefined]")';
+    if (rep.kind === 'scalar')
+        return rep.domain === 'bigint' ? tag('Object', 'BigInt') : tag(rep.domain === 'boolean' ? 'Boolean' : 'Number');
+    if (rep.kind === 'string')
+        return tag('String');
+    if (rep.kind === 'symbol')
+        return tag('Object', 'Symbol');
+    if (rep.kind === 'dynamic')
+        return tag('Object');
+    if (rep.kind === 'array-object')
+        return tag('Array');
+    if (rep.kind === 'native-handle') {
+        if (rep.protocol === 'Math')
+            return 'gea::hostIntrinsicObjectTag("Math", "Object", "Math")';
+        if (rep.call || rep.construct)
+            return `gea::hostIntrinsicObjectTag(${cppStringLiteral(rep.protocol)}, "Function")`;
+        return null;
+    }
+    if (rep.kind === 'native-record-ref') {
+        if (rep.native === cppDateType)
+            return tag('Date');
+        if (rep.native === cppErrorNativeType)
+            return tag('Error');
+        if (rep.native === cppRegExpNativeTypes.pattern)
+            return tag('RegExp');
+        if (rep.native === cppStringObjectNativeType)
+            return tag('String');
+        return rep.native === null ? tag('Object') : null;
+    }
+    if (rep.kind === 'keyed-collection')
+        return tag('Object', { map: 'Map', set: 'Set', 'weak-map': 'WeakMap', 'weak-set': 'WeakSet' }[rep.family]);
+    const binaryTag = binaryToStringTagText(rep);
+    if (binaryTag !== null)
+        return `gea::objectTag(${value}, "Object", ${binaryTag})`;
+    switch (rep.kind) {
+        case 'record':
+        case 'record-with-index':
+        case 'class-ref':
+        case 'dictionary':
+            return tag('Object');
+        case 'function':
+        case 'function-family':
+        case 'function-value-family':
+        case 'function-value-dispatch':
+        case 'function-and-constructor':
+            return tag('Function');
+        default:
+            return null;
+    }
+};
+export const objectTagCapability = (rep) => `computation:object-tag:${representationKey(rep)}`;

package/dist/targets/cpp/emit-owned-record.d.ts

@@ -0,0 +1,2 @@
+import type { OwnedRecordPlan } from '../../conversion/record-view.js';
+export declare const ownedRecordMaterializationText: (plan: OwnedRecordPlan, text: string, depth?: number) => string;

package/dist/targets/cpp/emit-owned-record.js

@@ -0,0 +1,15 @@
+import { cppRecordFieldName, cppRecordStructName, cppTypeOf } from './types.js';
+export const ownedRecordMaterializationText = (plan, text, depth = 0) => {
+    if (plan.kind === 'identity') {
+        return plan.target.kind === 'scalar' && plan.target.domain !== 'bigint' ? `static_cast<${cppTypeOf(plan.target)}>(${text})` : text;
+    }
+    if (plan.kind === 'arm') {
+        return `${cppTypeOf(plan.target)}::ofArm<${plan.index}>(${ownedRecordMaterializationText(plan.payload, text, depth)})`;
+    }
+    const holder = `gea_owned_record_${depth}`;
+    const reads = plan.fields.map((field) => ownedRecordMaterializationText(field.value, `${holder}.${cppRecordFieldName(field.key)}`, depth + 1));
+    const structure = cppRecordStructName(plan.target.shapeId);
+    const aggregate = `${structure}{${reads.join(', ')}}`;
+    const result = plan.target.ownership === 'shared-refcount' ? `gea::makeRef<${structure}>(${aggregate})` : aggregate;
+    return `[](const ${cppTypeOf(plan.source)}& ${holder}) { return ${result}; }(${text})`;
+};

package/dist/targets/cpp/emit-presence.d.ts

@@ -0,0 +1,78 @@
+import { type Representation } from '../../representation/model.js';
+/**
+ * Definedness: whether a value is `undefined`. The narrow half of presence.
+ *
+ * One construct asks it: a defaulted parameter. The language substitutes an
+ * initializer for a MISSING argument and for nothing else -- ECMA-262 8.6.3
+ * tests `undefined`, so `f(x = 0)` called `f(null)` binds `null`. Asking the
+ * presence question there re-runs the default on a `null` the caller chose,
+ * which is a silently wrong answer rather than a refusal.
+ *
+ * It made no observable difference while a defaulted parameter's slot could
+ * only be `T | undefined`: with no `null` state in the carrier, both tests read
+ * the same flag. It does now that `T | null | undefined` has a carrier
+ * (`normalize/parameter-slot.ts`), and it always did for a box, whose tag has
+ * both states.
+ *
+ * `null` is DEFINED, and that is the one place the two tests disagree in
+ * writing: presence over the `null` carrier is `false`, definedness is `true`.
+ */
+export declare const definedTestText: (text: string, representation: Representation) => string;
+export declare const presenceTestText: (text: string, representation: Representation) => string;
+/** Whether this backend can answer a presence test for a carrier, asked of the one authority rather than re-listed. */
+export declare const presenceIsAnswerable: (representation: Representation) => boolean;
+/**
+ * `x === null`, `x !== undefined`, `x == null` -- equality against an absent
+ * literal.
+ *
+ * Not a general comparison and never a conversion: the language settles most
+ * of it from the two carriers alone. `null === undefined` is false. An
+ * `Optional<T>` whose tag stands for `null` answers `x === undefined` false
+ * whatever it holds, and a carrier that cannot be absent at all answers both
+ * false without reading the value. Only when the tag and the literal agree is
+ * there a runtime question, and that question is the presence flag.
+ *
+ * The loose operators are a different rule and get it: `x == null` is true for
+ * *either* absent value, which is the presence test, so a union with both
+ * absent arms answers it correctly where `===` has to name one arm.
+ *
+ * Returns `null` when neither side is an absent literal, leaving ordinary
+ * equality to its own path, and when a side is carried dynamically -- a runtime
+ * tag this backend does not read.
+ */
+export declare const absenceComparisonText: (operator: string, left: {
+    readonly text: string;
+    readonly representation: Representation;
+}, right: {
+    readonly text: string;
+    readonly representation: Representation;
+}) => string | null;
+/**
+ * `ToBoolean` of one value, per carrier.
+ *
+ * The table is the language's, not a convenience: `0` and `NaN` are false and
+ * every other number true, an empty string is false and a one-space string
+ * true, `null` and `undefined` are false, an absent optional is false, and
+ * *every* object is true no matter what it holds. Writing any of these as a
+ * C++ implicit conversion would get several of them wrong -- `NaN` converts to
+ * `true`, and a `std::string` does not convert at all -- so each carrier gets
+ * the expression that is exactly its rule, and a carrier with no stated rule
+ * is refused rather than left to whatever `if (x)` happens to mean in C++.
+ *
+ * Truthiness and presence live in one file because they are the two questions
+ * a program asks of a value it has not looked at, they disagree on exactly the
+ * values that matter (`0`, `''`, `NaN` are present and falsy), and keeping them
+ * apart is how a backend ends up answering one with the other's rule.
+ */
+/**
+ * `integral` says the value is HELD in a `long long` -- the integer storage
+ * census narrowed the cell, the field or the formal it came out of.
+ *
+ * It changes one answer and it has to: a `long long` has no NaN, so `v == v`
+ * is not a NaN test there but a tautology, and gcc rejects it outright under
+ * `-Werror=tautological-compare`. `examples/apps/weather` is where that
+ * surfaced -- five `if (store.searchResultVisible)` sites the moment those
+ * flags became `Signal<long long>` -- and it is a compile error rather than a
+ * wrong answer only because the board builds with `-Werror`.
+ */
+export declare const booleanTestText: (text: string, representation: Representation, integral?: boolean) => string;