@geastack/compiler 1.0.15

package/dist/projection/bindings.js

@@ -0,0 +1,340 @@
+import { resultOf } from '../semantics/model/operands.js';
+/**
+ * The storage a host claims for a name, or `null` when no host claims it.
+ *
+ * Asked at BOTH sites that can produce a host-owned cell, and that is the
+ * point of it being a function. A program reaches an ambient name in one of
+ * two ways -- by writing the declaration itself (`declare const deviceInfo:
+ * {...}` in its own source, which introduces a cell) or by merely reading one
+ * the environment declares -- and which of the two it used says nothing about
+ * whose name it is. When the two sites answered separately, a program that
+ * declared its own view of the host got `extern std::shared_ptr<...>
+ * deviceInfo;` while `requestAnimationFrame`, reached the other way three
+ * lines later, resolved to the host's function.
+ *
+ * The order is constant, then function, then namespace, then singleton. A
+ * constant and a function each name something the program can hold or call; a
+ * namespace and a singleton name neither, so they are asked last.
+ * `__gea_audioContext` is what makes the order matter rather than merely be
+ * tidy: the host states it as a constant AND states members under its name,
+ * because the members really are members of that one object, and it is the
+ * constant that must win.
+ *
+ * Each of the four is asked twice: once of the table keyed by the declaration
+ * FILE this program's binding resolved to, and once of the flat table keyed
+ * by name alone. The file-keyed answer always wins, on the same reasoning
+ * `hostFunctionsByDeclaration` states for functions -- two of a host's own
+ * files can declare one name and mean a different constant, namespace root or
+ * singleton by it, and only the declaration this program actually resolved to
+ * says which was meant. A host with no such collision states an empty
+ * file-keyed table for that question and every name is answered by the flat
+ * one exactly as before.
+ */
+const hostStorageOf = (input, declaration, linkageName, representation) => {
+    // The declaration first, the name second -- for all four of a host's own
+    // tables, not only its functions. Two of a host's own files can declare the
+    // same name and mean a different constant, namespace root or singleton by
+    // it, exactly as they can a different function, and only the declaration
+    // this program actually resolved to says which was meant. Computed once and
+    // reused below, since it is the same file for every one of these questions
+    // about the same declaration.
+    const file = input.externalFiles?.get(declaration);
+    const declaredConstant = file === undefined ? undefined : input.hostConstantsByDeclaration?.get(file)?.get(linkageName);
+    if (declaredConstant !== undefined)
+        return { kind: 'host-constant', linkageName, emit: declaredConstant };
+    const constant = input.hostConstants?.get(linkageName);
+    if (constant !== undefined)
+        return { kind: 'host-constant', linkageName, emit: constant };
+    // The name-keyed table below is the answer for every host that has no such
+    // pair, which is nearly all of them.
+    const declared = file === undefined ? undefined : input.hostFunctionsByDeclaration?.get(file)?.get(linkageName);
+    if (declared !== undefined)
+        return { kind: 'host-function', linkageName, emit: declared };
+    const hostFunction = input.hostFunctions?.get(linkageName);
+    if (hostFunction !== undefined)
+        return { kind: 'host-function', linkageName, emit: hostFunction };
+    // A language builtin, last of the three function routes and gated on the
+    // declaration being the standard library's own: an installed host that
+    // claims one of these names has already won above, which is the right
+    // precedence -- a target that implements `btoa` itself is describing its own
+    // platform, and this table is the answer for every target that does not.
+    if (input.standardLibraryExternals?.has(declaration)) {
+        const core = input.coreGlobalFunctions?.get(linkageName);
+        if (core !== undefined)
+            return { kind: 'host-function', linkageName, emit: core };
+    }
+    // The language's own class objects, on the same gate: a constructor with no
+    // cell, whose `new` the emitter spells whole. Checked after the function
+    // table because the two never share a name and the order costs nothing, and
+    // before the namespace/singleton routes because neither of those describes a
+    // constructor.
+    if (input.standardLibraryExternals?.has(declaration) && input.coreGlobalClasses?.has(linkageName)) {
+        return { kind: 'host-class', linkageName };
+    }
+    if (input.hostNamespaceBindings?.has(declaration))
+        return { kind: 'host-namespace', linkageName };
+    if (input.exactHostNamespaceNames?.has(linkageName))
+        return null;
+    if (file !== undefined && input.hostNamespaceRootsByDeclaration?.get(file)?.has(linkageName)) {
+        return { kind: 'host-namespace', linkageName };
+    }
+    if (input.hostNamespaces?.roots.has(linkageName))
+        return { kind: 'host-namespace', linkageName };
+    if (input.hostSingletonBindings?.has(declaration))
+        return { kind: 'host-singleton', linkageName };
+    if (file !== undefined && input.hostSingletonsByDeclaration?.get(file)?.has(linkageName)) {
+        return { kind: 'host-singleton', linkageName };
+    }
+    if (input.hostSingletons?.has(linkageName))
+        return { kind: 'host-singleton', linkageName };
+    // A host handle that declares a construct convention is the host's class
+    // object rather than a cell the host defines -- see `host-class` above.
+    if (representation?.kind === 'native-handle' && representation.construct !== null)
+        return { kind: 'host-class', linkageName };
+    return null;
+};
+/**
+ * The namespace a value stands for, or `null` when it is an ordinary value.
+ *
+ * Two shapes, and only two.
+ *
+ * A READ of a cell already placed as a namespace is that namespace: the
+ * framework re-exports the host's globals under second names
+ * (`export const geolocation = Geolocation`), and an alias of a path is a
+ * path.
+ *
+ * A CONDITIONAL whose arms are that namespace and nothing else is also that
+ * namespace. This is the framework's own guard --
+ * `typeof __gea_Accelerometer !== 'undefined' ? __gea_Accelerometer :
+ * (undefined as unknown as typeof __gea_Accelerometer)` -- written because a
+ * web build only injects the global when an app uses it. On a target whose
+ * host TABLE claims the name, the question the guard asks is already answered:
+ * the host defines it, so the absent arm is unreachable and the value is the
+ * namespace. Every other arm must be an absent constant for that to hold, and
+ * an arm that is anything else makes this `null` rather than a guess.
+ */
+const namespacePathOfValue = (valueId, producers, placements, seen) => {
+    if (seen.has(valueId))
+        return null;
+    seen.add(valueId);
+    const producer = producers.get(valueId);
+    if (!producer)
+        return null;
+    if (producer.family === 'binding' && producer.action === 'read' && producer.declaration) {
+        const placed = placements.get(producer.declaration);
+        return placed?.storage.kind === 'host-namespace' ? placed.storage.linkageName : null;
+    }
+    if (producer.family !== 'computation' || producer.form !== 'conditional')
+        return null;
+    let path = null;
+    for (const operand of producer.operands) {
+        if (operand.role === 'condition')
+            continue;
+        if (operand.source.kind === 'constant') {
+            // The arm the host rules out. Only an absence qualifies: an arm holding
+            // any other value would mean the program really can observe something
+            // other than the namespace here.
+            if (operand.source.literal === 'undefined' || operand.source.literal === 'null')
+                continue;
+            return null;
+        }
+        if (operand.source.kind !== 'result')
+            return null;
+        const armPath = namespacePathOfValue(operand.source.result, producers, placements, seen);
+        if (armPath === null)
+            return null;
+        if (path !== null && path !== armPath)
+            return null;
+        path = armPath;
+    }
+    return path;
+};
+/**
+ * Cells whose value is a host namespace, placed as that namespace.
+ *
+ * Run to a fixpoint after every direct claim, because an alias can alias an
+ * alias: the framework exports `Geolocation`, then `geolocation`, and a single
+ * pass would place whichever it reached first and leave the other an `extern`
+ * nothing defines.
+ */
+const placeNamespaceAliases = (input, placements) => {
+    if (!input.hostNamespaces || input.hostNamespaces.roots.size === 0)
+        return;
+    const producers = new Map();
+    for (const operation of input.graph.operations.values()) {
+        for (const result of operation.results)
+            producers.set(result.id, operation);
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const operation of input.graph.operations.values()) {
+            if (operation.family !== 'binding' || operation.action !== 'initialize' || !operation.declaration)
+                continue;
+            const existing = placements.get(operation.declaration);
+            if (existing?.storage.kind === 'host-namespace')
+                continue;
+            const initializer = operation.operands.find((operand) => operand.role === 'initializer');
+            if (initializer?.source.kind !== 'result')
+                continue;
+            const path = namespacePathOfValue(initializer.source.result, producers, placements, new Set());
+            if (path === null)
+                continue;
+            placements.set(operation.declaration, {
+                storage: { kind: 'host-namespace', linkageName: path },
+                representation: existing?.representation ?? null
+            });
+            changed = true;
+        }
+    }
+};
+/**
+ * Every cell a program introduces, keyed by declaration.
+ *
+ * `initialize`, `declare`, and the `module-link`/`initialize` events of the
+ * declaration-lifecycle family are all introductions, and they are collected
+ * together on purpose: a consumer asking "where does this cell live" must get
+ * one answer regardless of which family happened to introduce it.
+ */
+export const projectBindingPlacements = (input) => {
+    const placements = new Map();
+    // Every graph operation that names one watched declaration, family and
+    // action included. The refusal a missing placement raises
+    // (`native-boundary:external-binding`) can only say that nothing introduced
+    // the cell; which producer was supposed to and what it emitted instead is
+    // exactly this list, and there is no other way to see it on the module-graph
+    // path. An instrument like `GEA_SHAKE_DEBUG`, not a result.
+    const watched = process.env['GEA_PLACEMENT_WATCH'];
+    if (watched) {
+        for (const operation of input.graph.operations.values()) {
+            if (!('declaration' in operation) || String(operation.declaration) !== watched)
+                continue;
+            const action = 'action' in operation ? String(operation.action) : '';
+            const event = 'event' in operation ? String(operation.event) : '';
+            console.log(`[PLACEMENT] ${watched} <- ${operation.family}${action ? `/${action}` : ''}${event ? `/${event}` : ''} ${operation.id}`);
+        }
+    }
+    const record = (declaration, storage, representation) => {
+        const existing = placements.get(declaration);
+        // A cell introduced twice keeps its first placement rather than acquiring a
+        // second: `var` re-declaration and a hoisted function name both do this, and
+        // they introduce one cell, not two.
+        if (existing)
+            return;
+        placements.set(declaration, { storage, representation });
+    };
+    for (const operation of input.graph.operations.values()) {
+        const introduces = (operation.family === 'binding' && (operation.action === 'initialize' || operation.action === 'declare')) ||
+            (operation.family === 'declaration-lifecycle' && (operation.event === 'module-link' || operation.event === 'initialize'));
+        if (!introduces)
+            continue;
+        const published = resultOf(operation, 'value');
+        const representation = published ? (input.plan.selected.get(published.id) ?? null) : null;
+        // `external` is checked ahead of `caller.kind`: an ambient declaration's
+        // caller is still an ordinary region (the module body it sits in), and
+        // that fact is irrelevant here -- the host, not that region, owns the
+        // cell, so the caller must not be consulted for one once this is set.
+        const storage = operation.family === 'binding' && operation.external
+            ? (hostStorageOf(input, operation.declaration, operation.external.linkageName, representation) ?? {
+                kind: 'external',
+                linkageName: operation.external.linkageName
+            })
+            : operation.caller.kind === 'function'
+                ? { kind: 'local', owner: operation.caller.functionId }
+                : { kind: 'region', owner: operation.caller.regionId };
+        record(operation.declaration, storage, representation);
+    }
+    // Second, and only where the graph introduced nothing: a cell the program
+    // reads but never creates. The order is what makes this safe -- a declaration
+    // this program really does introduce keeps its own placement, so a local
+    // shadowing an ambient name is never turned into an `extern`.
+    //
+    // The carrier comes from a *read* of the cell rather than from an
+    // introduction, because there is no introduction: the reads are the only
+    // published results that name this declaration's type, and every one of them
+    // carries the same type, so any one of them answers. A cell with no read
+    // reaches nothing and needs no `extern`.
+    const reads = readsByDeclaration(input.graph);
+    for (const [declaration, linkageName] of input.externals ?? []) {
+        if (placements.has(declaration))
+            continue;
+        const representation = readCarrierOf(input, reads, declaration);
+        if (!representation)
+            continue;
+        // A host that DENIED the name is answered before any host that might claim
+        // it, because a denial is the one claim that cannot be outvoted by the
+        // generic external fallback below: falling through would emit an `extern`
+        // for a symbol this compiler has just concluded is not there.
+        const storage = input.absentBindings?.has(declaration)
+            ? { kind: 'absent', linkageName }
+            : (hostStorageOf(input, declaration, linkageName, representation) ?? { kind: 'external', linkageName });
+        placements.set(declaration, { storage, representation });
+    }
+    // A program cell that is written but whose introduction nothing reached:
+    // every read folded to what the initializer named (a script-global
+    // `var Request = RequestImpl` read only as the class), so the tree shake
+    // dropped the initialize while a later write (`global.Request = ...`) still
+    // stores into it. The cell is file-scope storage like any module cell; its
+    // owner region is never consulted for one.
+    let anyRegion;
+    for (const operation of input.graph.operations.values()) {
+        if (operation.caller.kind !== 'function') {
+            anyRegion = operation.caller.regionId;
+            break;
+        }
+    }
+    for (const operation of input.graph.operations.values()) {
+        if (operation.family !== 'binding' || operation.action !== 'write' || !operation.declaration)
+            continue;
+        if (placements.has(operation.declaration) || input.externals?.has(operation.declaration))
+            continue;
+        const written = resultOf(operation, 'value');
+        const representation = readCarrierOf(input, reads, operation.declaration) ?? (written ? (input.plan.selected.get(written.id) ?? null) : null);
+        const owner = operation.caller.kind === 'function' ? anyRegion : operation.caller.regionId;
+        if (representation === null || owner === undefined)
+            continue;
+        placements.set(operation.declaration, { storage: { kind: 'region', owner }, representation });
+    }
+    // Last, so every directly-claimed cell is already placed: an alias is
+    // recognized by what it reads, and what it reads has to be known first.
+    placeNamespaceAliases(input, placements);
+    return placements;
+};
+/**
+ * Every read of a cell, by the declaration it reads, in `graph.operations` order.
+ *
+ * `readCarrierOf` below answers "what carrier does a read of this cell publish",
+ * once per ambient declaration this program never introduces, and answering it
+ * by walking the whole operation table made placement cost externals x
+ * operations. Bucketing on the field the scan already tested answers all of them
+ * in one pass, and dealing the buckets in table order keeps the same read
+ * first -- which is the one the original scan returned.
+ */
+const readsByDeclaration = (graph) => {
+    const reads = new Map();
+    for (const operation of graph.operations.values()) {
+        const declaration = operation.family === 'binding' && operation.action === 'read'
+            ? operation.declaration
+            : operation.family === 'property'
+                ? operation.resolvedBinding
+                : undefined;
+        if (declaration === undefined)
+            continue;
+        const bucket = reads.get(declaration);
+        if (bucket)
+            bucket.push(operation);
+        else
+            reads.set(declaration, [operation]);
+    }
+    return reads;
+};
+/** The carrier the plan selected for a value read out of one cell, or `null` when nothing reads it. */
+const readCarrierOf = (input, reads, declaration) => {
+    for (const operation of reads.get(declaration) ?? []) {
+        const published = resultOf(operation, 'value');
+        const representation = published ? input.plan.selected.get(published.id) : undefined;
+        if (representation && representation.kind !== 'unresolved')
+            return representation;
+    }
+    return null;
+};

package/dist/projection/callee.d.ts

@@ -0,0 +1,196 @@
+import type { DeclarationId, FunctionId, SemanticResultId } from '../identity/ids.js';
+import type { RepresentationDeriver } from '../representation/derive.js';
+import { type CallableAbi, type Representation } from '../representation/model.js';
+import type { SealedRepresentationPlan } from '../representation/plan.js';
+import { type HostMemberTable } from '../targets/cpp/host/host-members.js';
+import type { BindingPlacement } from './bindings.js';
+import type { ClassLayout } from './classes.js';
+import type { SemanticGraph } from '../semantics/model/graph.js';
+import { type SemanticOperand } from '../semantics/model/operands.js';
+import type { InvocationOperation } from '../semantics/model/operations.js';
+/**
+ * What a callee carrier says about the frame a call fills.
+ *
+ * These queries are asked twice in the pipeline -- once when a call lowers
+ * (`ir/lower-invocation.ts`) and once when the slot census states which
+ * carrier each argument must arrive in (`projection/slots.ts`). They live
+ * here, below both, so the two cannot drift: a lowering that packed
+ * arguments against one reading of a callee and a census that checked them
+ * against another would be two authorities over one convention.
+ */
+/** The convention a callable carrier states, or `null` for a carrier that states none. */
+export declare const abiOfCallee: (representation: Representation) => CallableAbi | null;
+/**
+ * The `[[Construct]]` convention a callee carries, which is the frame
+ * `super(...)` and `new` fill.
+ *
+ * Distinct from `abiOfCallee` for exactly one carrier: a value that is both
+ * callable and constructible states two conventions, and a construction fills
+ * the constructing one. Reusing `abiOfCallee` there would pack the arguments
+ * against a `[[Call]]` signature the base's initialization never reads.
+ */
+export declare const constructAbiOfCallee: (representation: Representation) => CallableAbi | null;
+/**
+ * The convention a method VALUE carries when a receiver-less slot takes it:
+ * the source states a receiver and the slot states the identical convention
+ * without one. Such a value is bound to the object it was read from before it
+ * enters the slot (`ir/lower-operands.ts`'s `enter`, minting a detached
+ * `bind-callable`); `null` for any other pair.
+ */
+export declare const detachedMethodAbiOf: (source: Representation, target: Representation) => CallableAbi | null;
+/**
+ * Whether a rest slot's carrier is a fixed-arity tuple: a record whose keys
+ * are exactly `0..n-1` in order. Such a rest slot is filled field by field,
+ * never by a runtime-sized array.
+ */
+export declare const isClosedContiguousTupleRecord: (representation: Representation) => representation is Extract<Representation, {
+    kind: "record";
+}>;
+/**
+ * The value a body's `return` hands back, given the convention's own result:
+ * the payload of an async function's promise, the completion of a generator's
+ * cursor, and otherwise the result itself.
+ */
+export declare const returnPayloadOf: (result: Representation) => Representation;
+/**
+ * A call through `Function.prototype.call`/`apply`/`bind` whose real callee
+ * is the receiver of the member read, when the builtin is unshadowed and the
+ * receiver's own convention is known.
+ *
+ * `receiver` is the operand of the PROPERTY READ that produced the call's
+ * callee -- the function value itself -- not the invocation's own `receiver`
+ * operand, which names that same function and is never read as `this`.
+ */
+export interface DeferredCallee {
+    readonly member: 'call' | 'apply' | 'bind';
+    readonly receiver: SemanticOperand;
+    readonly abi: CallableAbi;
+    readonly functionId: FunctionId | null;
+    /**
+     * WHICH frame the rewritten call fills -- the one question `abi` above does
+     * not answer, and the one both consumers of this record were assuming.
+     *
+     * `abi` is the underlying callable's own physical convention, recovered for
+     * a `dynamic` receiver out of `functionId` so that a boxed Function can
+     * still be bound and reasoned about. It is NOT the frame such a call fills:
+     * `emit-callable.ts`'s `callee.kind === 'dynamic'` arm renders
+     * `Value::callWithReceiver` with a flat `std::vector<Value>` and says why in
+     * its own comment -- "there is no convention to build a frame against, so
+     * the arguments cross as boxes and the callable's own declared parameters
+     * are recovered by the thunk". Two authorities on one frame, and the
+     * emitter is the one that is right.
+     *
+     * Measured: `routedFn.call(receiver, 'called', 4, 5)` over a rest-taking
+     * `Routed` (`test/runtime/dynamic-callable-abi-recovery.runtime.js`). The
+     * slot census converted `4, 5` to the rest ELEMENT carrier and the lowering
+     * PACKED them into an `ArrayObject<double>`, which the emitter then boxed as
+     * ONE argument -- and the callee's own `DynamicRestCallSignature` thunk,
+     * doing the job the boxed convention gives it, packed a second time and
+     * unboxed an array where a `double` was declared. `Function.prototype.call`
+     * SPREADS; in the boxed frame the packing is the thunk's and the call
+     * site's alone would be enough only if the call bypassed the box.
+     */
+    readonly frame: 'native' | 'boxed';
+    /**
+     * The RECEIVER's own carrier -- the boxed frame's argument carrier, and the
+     * carrier the this-argument must keep its identity in. Carried here because
+     * `receiver` above is an operand of the deferred property READ, not of the
+     * invocation, so a consumer holding only the invocation cannot ask for it.
+     */
+    readonly receiverCarrier: Representation;
+}
+export interface DeferredCalleeInput {
+    readonly graph: SemanticGraph;
+    readonly plan: SealedRepresentationPlan;
+    readonly abis: ReadonlyMap<FunctionId, CallableAbi>;
+    readonly constructs: ReadonlyMap<FunctionId, CallableAbi>;
+    readonly callableOrigins: ReadonlyMap<SemanticResultId, FunctionId>;
+    readonly classes: ReadonlyMap<DeclarationId, ClassLayout>;
+}
+/**
+ * The source function a method read as a VALUE names: `host.readFile` read
+ * off a class instance, or `Host.create` off its constructor, is the member
+ * declaration's own body -- provenance `callableOriginsOf` cannot carry,
+ * since it follows allocations and the cells that alias them, and a method
+ * is never allocated. `null` for a read that is not that: a computed key, a
+ * receiver that is no class, a member that is a field or an accessor, or a
+ * value whose convention states no receiver (a bound callable, an arrow
+ * field), which the read cannot have produced from a method body.
+ *
+ * Asked by the property lowering, which records the receiver a method value
+ * must be bound to (`LoweringProgram.methodValueReceivers`), and by the
+ * `Function.prototype.bind` rewrite below, which binds the same body.
+ */
+export declare const methodValueOriginOf: (classes: ReadonlyMap<DeclarationId, ClassLayout>, receiver: Representation, key: string, representation: Representation) => FunctionId | null;
+export declare const deferredCalleeOf: (input: DeferredCalleeInput, operation: InvocationOperation) => DeferredCallee | null;
+/**
+ * How a call reaches its callee: through a callable VALUE with a physical
+ * convention (`callable`), or through a TEMPLATE the backend spells from the
+ * call's own operands (`template`) -- a host member on a native handle, a
+ * `String`/`Array`/`Promise`/`RegExp` prototype method, a host-placed
+ * function, a generator cursor's `next`. A template never sees the declared
+ * convention: `substring`'s optional `end` is a C++ overload there, not a
+ * `gea::Optional<double>` formal, so an argument reaching one must stay in
+ * its own carrier. The slot census reads this to answer `host-overload` for
+ * those arguments instead of the lib.d.ts formal the callee's carrier states.
+ *
+ * Decided from the callee's provenance -- the read that produced it and the
+ * carrier that read went through -- which is the same fact the printer's
+ * property-read emitters decide it from when they defer a read into
+ * `hostMemberReads`/`prototypeMethodReads` rather than materializing a
+ * value. A receiver this cannot see is read as `callable`, which is the
+ * conservative side for nothing: a template rendered for an argument the
+ * census converted is a C++ overload mismatch, so every receiver kind the
+ * printer spells from a template must be named here.
+ */
+export type CalleeRendering = 'callable' | 'template';
+/**
+ * `hasOwnProperty`/`propertyIsEnumerable` reached as instance methods off a
+ * known-shape receiver (`record`/`class-ref`/a `native-record-ref` naming no
+ * native type) -- the two ambient `Object.prototype` members the C++
+ * backend's object-shape protocol (`targets/cpp/host/object-protocol.ts`'s
+ * `objectShapePrototypeMemberRead`) claims regardless of the receiver's own
+ * layout: the GET renders nothing and the CALL fuses receiver, key and field
+ * list into one expression, never going through `Object.prototype`'s
+ * declared `(v: PropertyKey) => boolean` convention. `calleeRenderingOf`
+ * below is the ONE authority for whether a call renders from a template or a
+ * convention, so it states this claim too, rather than leaving the printer
+ * as a second, silent authority the census cannot see: a census that let
+ * this call's ABI apply would convert a literal string key into the
+ * `PropertyKey` tagged union, which `objectShapeCallText` explicitly refuses.
+ */
+export declare const objectShapePrototypeMethods: ReadonlySet<string>;
+export interface CalleeRenderingInput {
+    readonly graph: SemanticGraph;
+    readonly plan: SealedRepresentationPlan;
+    readonly deriver: RepresentationDeriver;
+    readonly placements: ReadonlyMap<DeclarationId, BindingPlacement>;
+    /** Declarations that hold one host method forever -- see `hostMethodAliasDeclarations`. */
+    readonly hostMethodAliasDeclarations: ReadonlySet<DeclarationId>;
+    readonly hostMembers?: HostMemberTable;
+}
+/** A direct read of a host callable whose numeric rest frame need not escape to an array. */
+export declare const numericRestHostCallOf: (input: CalleeRenderingInput, operation: InvocationOperation) => {
+    readonly protocol: string;
+    readonly member: string;
+} | null;
+/**
+ * Declarations written exactly once, from a direct read of a host METHOD --
+ * `var __isArray = Array.isArray`, the shape test262's propertyHelper and any
+ * program guarding a later monkey-patch names a builtin through.
+ *
+ * `targets/cpp/host/host-method-aliases.ts` proves the identical fact, but
+ * over the LOWERED ir, for the printer to fold a read of the cell back into a
+ * bare host-member name. `calleeRenderingOf` needs the same fact one stage
+ * earlier, over the semantic graph and its sealed plan -- before lowering
+ * builds a call's argument `convert`s -- because a call through such a cell
+ * renders as a host call-site template exactly like `Array.isArray(v)`
+ * itself, and a template's arguments enter their OWN carrier
+ * (`invocationSlot`'s `host-overload`), never the `dynamic` an ordinary
+ * callable's declared-`any` formal would otherwise ask the census for. Both
+ * live on the sealed plan, which is why this can answer without waiting for
+ * a lowered body: a `native-handle` receiver and a host member table are
+ * exactly what the plan and `hosts.members` already state.
+ */
+export declare const hostMethodAliasDeclarations: (graph: SemanticGraph, plan: SealedRepresentationPlan, deriver: RepresentationDeriver, hostMembers: HostMemberTable) => ReadonlySet<DeclarationId>;
+export declare const calleeRenderingOf: (input: CalleeRenderingInput, operation: InvocationOperation) => CalleeRendering;