@geastack/compiler 1.0.15

package/dist/targets/cpp/host/emit-host-reflect.js

@@ -0,0 +1,180 @@
+import { nativeReflectFieldTransportOf } from '../../../ir/native-reflect-field.js';
+import { createCppEmitBlockedError, operandText } from '../emit-context.js';
+import { boxedValueText, propertyKeyText, unboxedReadText } from '../emit-dynamic-properties.js';
+import { regexpRoleOf } from '../prototype/emit-prototype-regexp.js';
+import { declaredRecordFieldOf } from '../records.js';
+import { cppTypeOf } from '../types.js';
+import { alignedValueText } from '../emit-narrowing.js';
+import { getOwnPropertyDescriptorText } from './emit-host-object.js';
+import { unaddressableNativeSymbolKeyOf } from '../native-symbol-keys.js';
+const ownKeysCallText = (ctx, operation) => {
+    const target = operation.arguments[0];
+    const site = 'Reflect.ownKeys';
+    const refuse = (reason) => {
+        throw createCppEmitBlockedError(`host-member-call:${site}`, reason);
+    };
+    if (!target || operation.argumentsAreSpread)
+        return refuse('own-key enumeration requires a known target operand');
+    const representation = target.representation;
+    const unsupportedSymbol = unaddressableNativeSymbolKeyOf(ctx, representation);
+    if (unsupportedSymbol !== null)
+        return refuse(`fixed symbol key ${unsupportedSymbol} has no retained runtime identity`);
+    const receiver = operandText(ctx, target);
+    const generated = representation.kind === 'record' ||
+        representation.kind === 'record-with-index' ||
+        representation.kind === 'class-ref' ||
+        (representation.kind === 'native-record-ref' && representation.native === null);
+    let preparation;
+    if (representation.kind === 'dynamic') {
+        preparation = `const auto& __gea_target = ${receiver}; if (!gea::isObjectValue(__gea_target)) gea::host::throwRuntimeError("TypeError", "Reflect.ownKeys target must be an object"); const auto __gea_keys = __gea_target.ownPropertyKeys(); `;
+    }
+    else if ((generated && representation.ownership === 'shared-refcount') || regexpRoleOf(representation) === 'pattern') {
+        preparation = `const auto& __gea_target = ${receiver}; if (!__gea_target) gea::host::throwRuntimeError("TypeError", "Reflect.ownKeys target must be an object"); const auto __gea_keys = gea::nativeOwnPropertyKeys(__gea_target); `;
+    }
+    else
+        return refuse('the target has no supported native own-key protocol');
+    if (!operation.result)
+        return `([&]() { ${preparation}(void)__gea_keys; })()`;
+    const result = operation.result.representation;
+    if (result.kind !== 'array-object' || result.ownership !== 'shared-refcount')
+        return refuse('the key list has no native array carrier');
+    const stringKey = alignedValueText(ctx, site, { kind: 'string' }, result.element, '__gea_key.text()');
+    const symbolKey = alignedValueText(ctx, site, { kind: 'symbol' }, result.element, 'gea::Symbol(static_cast<std::uint32_t>(__gea_key.symbolId()))');
+    if (stringKey === null || symbolKey === null)
+        return refuse('the key element cannot retain both strings and symbols');
+    return (`([&]() -> ${cppTypeOf(result)} { ${preparation}auto __gea_result = gea::makeRef<gea::ArrayObject<${cppTypeOf(result.element)}>>(); ` +
+        `for (const auto& __gea_key : __gea_keys) { if (__gea_key.isSymbol()) __gea_result->push(${symbolKey}); ` +
+        `else __gea_result->push(${stringKey}); } return __gea_result; })()`);
+};
+const methods = new Map([
+    ['gea::reflectGet', 'get'],
+    ['gea::reflectSet', 'set'],
+    ['gea::reflectHas', 'has'],
+    ['gea::reflectDelete', 'deleteProperty']
+]);
+/** Reflect over native data storage. Unsupported layouts must not enter a boxed host call implicitly. */
+export const nativeReflectCallText = (ctx, operation, spelling) => {
+    if (spelling === 'gea::reflectOwnKeys({arg0})')
+        return ownKeysCallText(ctx, operation);
+    if (spelling === 'gea::reflectOwnDescriptor') {
+        const target = operation.arguments[0];
+        if (!target || target.representation.kind === 'dynamic')
+            return null;
+        const representation = target.representation;
+        const generated = representation.kind === 'record' ||
+            representation.kind === 'record-with-index' ||
+            representation.kind === 'class-ref' ||
+            (representation.kind === 'native-record-ref' && representation.native === null);
+        if (!generated || operation.arguments.length !== 2 || operation.argumentsAreSpread) {
+            throw createCppEmitBlockedError('host-member-call:Reflect.getOwnPropertyDescriptor', 'this native target or argument list has no supported descriptor protocol; the target must not be boxed');
+        }
+        // Object and Reflect query the same own descriptor once the receiver is
+        // known to be an object. Reflect additionally rejects a null native ref.
+        const descriptor = getOwnPropertyDescriptorText(ctx, operation);
+        if (representation.ownership !== 'shared-refcount')
+            return descriptor;
+        return (`([&]() { if (!${operandText(ctx, target)}) gea::host::throwRuntimeError("TypeError", ` +
+            `"Reflect.getOwnPropertyDescriptor target must be an object"); return ${descriptor}; })()`);
+    }
+    const method = methods.get(spelling);
+    if (!method)
+        return null;
+    const target = operation.arguments[0];
+    if (!target || target.representation.kind === 'dynamic')
+        return null;
+    const refuse = (reason) => {
+        // Same shape as Atomics' own call-support rule (`atomics.ts`): whether
+        // this particular target/argument shape has a native recipe is a target
+        // RULE over the call, not a manifest-registered set, so `host-member-call`
+        // is the family even though the callee's own `host-invocation` demand
+        // (raised at certify time) already passed.
+        throw createCppEmitBlockedError(`host-member-call:Reflect.${method}`, `${reason}; native reflection cannot silently box its target`);
+    };
+    const representation = target.representation;
+    const expected = method === 'set' ? 3 : 2;
+    if (operation.arguments.length !== expected)
+        return refuse('explicit receivers or omitted arguments have no native recipe');
+    const key = operation.arguments[1];
+    if (!key)
+        return refuse('the property key is missing');
+    const receiver = operandText(ctx, target);
+    const site = `Reflect.${method} on a native target`;
+    const callable = representation.kind === 'function' ||
+        representation.kind === 'function-family' ||
+        representation.kind === 'function-value-family' ||
+        representation.kind === 'function-value-dispatch' ||
+        representation.kind === 'function-and-constructor';
+    // Reflect's target stays a Callable(Constructor)Object. The one Value at
+    // this boundary is the property payload, never a conversion of the target
+    // that would erase its call/construct ABI intersection.
+    if (callable) {
+        const property = propertyKeyText(ctx, key, site);
+        const constructorSetup = representation.kind === 'function-and-constructor'
+            ? `if (!__gea_key.isSymbol() && __gea_key.text() == "prototype") gea::installCallableConstructorPrototype(__gea_callable); `
+            : '';
+        const prepare = `const auto& __gea_callable = ${receiver}; gea::installCallableOwnFacts(__gea_callable.functionObjectIdentity(), __gea_callable.name(), __gea_callable.length()); ` +
+            `const gea::PropertyKey __gea_key = ${property}; ${constructorSetup}`;
+        if (method === 'get') {
+            if (!operation.result)
+                return `(void)gea::callableDynamicGet(${receiver}, ${property})`;
+            return unboxedReadText(operation.result.representation, `gea::callableDynamicGet(${receiver}, ${property})`, site);
+        }
+        if (method === 'has') {
+            return `([&]() -> bool { ${prepare} return __gea_callable.functionObjectIdentity()->properties->hasProperty(__gea_key) || gea::callableDynamicGet(__gea_callable, __gea_key).tag() != gea::Value::Tag::Undefined; })()`;
+        }
+        if (method === 'deleteProperty') {
+            return `([&]() -> bool { ${prepare} return __gea_callable.functionObjectIdentity()->properties->deleteOwnProperty(__gea_key); })()`;
+        }
+        return (`([&]() -> bool { ${prepare} return __gea_callable.functionObjectIdentity()->properties->set(__gea_key, ` +
+            `${boxedValueText(ctx, operation.arguments[2], site)}, gea::Value::box(gea::Value::Tag::Function, __gea_callable)); })()`);
+    }
+    // Pattern is native, not a generated record, but its `lastIndex` hook is
+    // the exact same fixed-own-property protocol. Keep the receiver native and
+    // use the runtime dispatch only at the PropertyKey/Value reflection boundary.
+    if (regexpRoleOf(target.representation) === 'pattern') {
+        const property = propertyKeyText(ctx, key, site);
+        if (method === 'get') {
+            if (!operation.result)
+                return `(void)gea::runtime::regex::dynamicGet(${receiver}, ${property})`;
+            return unboxedReadText(operation.result.representation, `gea::runtime::regex::dynamicGet(${receiver}, ${property})`, site);
+        }
+        if (method === 'has')
+            return `gea::runtime::regex::dynamicHas(${receiver}, ${property})`;
+        if (method === 'deleteProperty')
+            return `gea::nativeDynamicDelete(${receiver}, ${property})`;
+        return `gea::runtime::regex::dynamicSet(${receiver}, ${property}, ${boxedValueText(ctx, operation.arguments[2], site)})`;
+    }
+    const generated = representation.kind === 'record' ||
+        representation.kind === 'record-with-index' ||
+        representation.kind === 'class-ref' ||
+        // An Array's ordinary own properties live in the same identity-keyed
+        // expando table `emit-dynamic-properties.ts`'s `nativeSidecarReceiver`
+        // already grants `p[key] = v` on one; `Reflect.get(p, key)` reads the
+        // same table.
+        representation.kind === 'array-object' ||
+        (representation.kind === 'native-record-ref' && representation.native === null);
+    if (!generated || representation.ownership !== 'shared-refcount')
+        return refuse('the target has no generated shared record layout');
+    const property = propertyKeyText(ctx, key, site);
+    const staticKey = ctx.staticKeyTexts.get(key.value);
+    const field = staticKey === undefined ? null : declaredRecordFieldOf(ctx.deriver, representation, staticKey, ctx.classes);
+    const transport = nativeReflectFieldTransportOf(operation, field);
+    if (method === 'get') {
+        const read = `gea::nativeDynamicGet(${receiver}, ${property})`;
+        if (!operation.result)
+            return `(void)${read}`;
+        const decoded = unboxedReadText(operation.result.representation, read, site);
+        return transport === 'native-read'
+            ? `gea::nativeFieldGet<${cppTypeOf(operation.result.representation)}>(${receiver}, ${property}, [&]() { return ${decoded}; })`
+            : decoded;
+    }
+    if (method === 'has')
+        return `gea::nativeDynamicHasProperty(${receiver}, ${property})`;
+    if (method === 'deleteProperty')
+        return `gea::nativeDynamicDelete(${receiver}, ${property})`;
+    if (transport === 'native-write') {
+        const value = operation.arguments[2];
+        return `gea::nativeFieldSet(${receiver}, ${property}, static_cast<${cppTypeOf(value.representation)}>(${operandText(ctx, value)}))`;
+    }
+    return `gea::nativeDynamicSet(${receiver}, ${property}, ${boxedValueText(ctx, operation.arguments[2], site)})`;
+};

package/dist/targets/cpp/host/emit-host-value.d.ts

@@ -0,0 +1,120 @@
+import type { Representation } from '../../../representation/model.js';
+import type { RecordLayoutPolicy } from '../../../representation/policies.js';
+import type { HostCallSpelling, HostMember } from './host-members.js';
+/**
+ * A host function READ as a value: the function object the language says it is.
+ *
+ * `decodeURI` is an ordinary function object in ECMAScript (18.2.6.2 -- a
+ * built-in whose value is a callable), so `const d = decodeURI` binds a
+ * callable and nothing about it is special. What this backend has is a call
+ * SPELLING, not a symbol of the right type, and a C++ function name is not a
+ * `CallableObject`. The gap is a rendering, not a language fact.
+ *
+ * The rendering is the ABI the operand already carries, wrapped in the one
+ * shape `CallableObject` accepts: a CAPTURELESS lambda matching its `Invoke`
+ * (`Result (*)(void*, Arguments...)`), which converts to a plain function
+ * pointer. No top-level helper has to be emitted, and no environment is
+ * allocated, because there is nothing to capture -- the spelling is a fixed
+ * path known at compile time.
+ *
+ * `null` for the two cases that genuinely have nothing to wrap, and both are
+ * refused by the caller rather than approximated here:
+ *
+ *  - a spelling that is a TEMPLATE rather than a path, which is a recipe for
+ *    filling in a call's own arguments and has no meaning without them;
+ *  - a receiver-taking convention, whose thunk would have to capture the
+ *    receiver and so could not be captureless.
+ */
+export declare const hostFunctionValueText: (representation: Representation, spelling: HostCallSpelling) => string | null;
+/**
+ * A host METHOD read as a value: `console.error` in `(options?.onError ??
+ * console.error)(e)`, `Object.keys` handed to a `map`.
+ *
+ * The language has no "method that is only ever a callee": reading
+ * `console.error` produces the same function object calling it goes through,
+ * and a program is free to store it, pass it, or pick it with `??`. What this
+ * backend has instead is a call TEMPLATE keyed by protocol and member, which
+ * is a recipe for a call site's arguments and names no C++ symbol on its own.
+ *
+ * So the read renders the template against a thunk's own formals -- the same
+ * closing `hostFunctionValueText` already performs for a free host function,
+ * and deliberately the same wrapper, because a host method read as a value is
+ * not a different kind of value than a host function read as one.
+ *
+ * Three template shapes fill from bare formals and one does not:
+ *
+ *  - a fixed `{argN}` count, which fills positionally and refuses when the
+ *    slot's convention has fewer parameters than the spelling names;
+ *  - `'pass-through'`, whose single `{args}` slot takes the formals in order
+ *    and leaves the overload choice to C++, exactly as a direct call does;
+ *  - `'variadic'`, whose `{args}` slot is the ToString JOIN of the arguments
+ *    (`console.log(a, b)` prints one space-separated line), computed here from
+ *    the formals with the same abstract operation `consoleArgumentsText` runs
+ *    over a direct call's operands;
+ *  - `'call-site'`, which by definition has no template: its C++ depends on
+ *    the static types of a CALL this read does not have. That refuses, and
+ *    the refusal is honest rather than a guess at which renderer applies.
+ *
+ * A `{receiver}` cannot be filled either: the member was reached off a
+ * receiver expression whose value this read did not keep, and a thunk holding
+ * one would not be captureless. Every protocol whose members take a receiver
+ * therefore refuses here by name.
+ */
+export declare const hostMemberValueText: (representation: Representation, host: HostMember, layouts: RecordLayoutPolicy) => string | null;
+/**
+ * `JSON.parse` / `JSON.stringify` read as a VALUE -- `this.text().then(JSON.parse)`
+ * in `@hono/node-server`'s `LightRequest.json`.
+ *
+ * The two JSON members are the one pair in `host-members.ts` whose `emit` is a
+ * PLACEHOLDER rather than a template: their C++ is generated per call site
+ * from the static type the call asserts, and that table says so in full.
+ * Filling the ordinary thunk from that placeholder would splice a comment
+ * where the call belongs, so this renders the same body `jsonCallText` does,
+ * against the thunk's own formals and the slot's own carrier.
+ *
+ * Narrower than the call form on purpose, for the reason
+ * `jsonRuntimeDeclaredCarrier` states. `JSON.parse` with nothing asserting a
+ * type is the case that matters and the case that fits: its result is `any`,
+ * which is `gea::Value` -- one of the four genuinely dynamic boundaries
+ * `representation/model.ts` admits, and a carrier the runtime header reads
+ * into directly.
+ */
+export declare const hostJsonMemberValueText: (member: string, representation: Representation) => string | null;
+/**
+ * A BUILTIN function read as a value, for reflection only.
+ *
+ * `Object.getOwnPropertyDescriptor(Array.from, 'name')` never calls what it is
+ * handed, and `Array.from` has no single calling convention to hand it: its
+ * four `lib.d.ts` overloads disagree at parameter 0, so
+ * `representation/derive.ts` carries the read as `callable-identity` -- the
+ * function OBJECT without a frame. This renders that object, and the runtime
+ * gives it the `name` and `length` ECMA-262 10.2.4/10.2.9 say it has.
+ *
+ * Keyed by the builtin's spec path rather than by this site, so every spelling
+ * of `Array.from` in a program is the same function object. A call through the
+ * value is refused at emission (`call-abi:no-invoke-path:callable-identity`),
+ * which is why nothing here has to invent an invoke that would then throw.
+ */
+export declare const hostBuiltinFunctionIdentityText: (protocol: string, member: string, length: number) => string;
+export declare const hostClassValueText: (representation: Representation, className: string) => string | null;
+/**
+ * A prototype method read as a VALUE (`Date.prototype.getTime`): a callable
+ * whose facts (`name`, `length`, source text) are what reflection asks for,
+ * and whose invoke is the method itself over whatever receiver a caller
+ * hands it -- `getTime.call(0)`, `getTime.call(new Date())`. The receiver is
+ * the frame's first formal, a `gea::Value` (the prototype object's copy of
+ * each method states an `any` receiver, `structural.ts`'s
+ * `prototypeMethodBodyOf`), and 21.4.4's `thisTimeValue` is the brand check
+ * on it: a Date dispatches to `gea::runtime::Date`'s own member, exactly as
+ * `emit-prototype-date.ts` renders a direct `d.getTime()`; anything else is
+ * the TypeError the clause specifies. A member this backend has no runtime
+ * spelling for, and every non-Date prototype, keeps a throwing invoke, so a
+ * call reaching it is an honest refusal at run time rather than a wrong
+ * answer. Facts are registered against the invoke pointer so
+ * `Value::box(Tag::Function, ...)` installs the own `name`/`length` the same
+ * way it does for a program's own function. `signature` is the `R(A...)`
+ * spelling of the read's own ABI when the read is typed, `void()` when the
+ * value is only ever reflected over.
+ */
+export declare const hostPrototypeMethodValueText: (signature: string, protocol: string, member: string, arity: number) => string;
+export declare const hostPrototypeMethodSignatureText: (representation: Representation) => string | null;