@geastack/compiler 1.0.15

package/dist/semantics/normalize/producers/shared.d.ts

@@ -0,0 +1,561 @@
+import ts from 'typescript';
+import type { OperationId, StructuralTypeId } from '../../../identity/ids.js';
+import type { SemanticEdge } from '../../model/edges.js';
+import type { OperandSource, SemanticOperand } from '../../model/operands.js';
+import type { CandidateContribution } from '../contribution.js';
+import { type StructuralMember } from '../../model/structural-types.js';
+import { blocked } from './mint.js';
+import type { ProducerContext } from '../producer-context.js';
+import { type CitedBranch } from './references.js';
+export { unwrapErasedExpression as unwrapErased } from './erasure.js';
+/**
+ * Helpers every producer needs, kept in one place.
+ *
+ * Each of these existed as three or four private copies, and the copies did not
+ * stay identical: one `resultEdge` published ordinal zero for every operand
+ * while another carried the real one, so two producers disagreed about which
+ * operand an edge described. A duplicated helper is not a style problem here --
+ * it is a second authority waiting to drift, and drift in this layer is silent
+ * (a wrong citation produces no error, just an operation that never appears).
+ */
+/** `blocked()` mints a `CensusBlocker`; a producer's `contribute` must return a `CandidateContribution`. */
+export declare const asBlocked: (...args: Parameters<typeof blocked>) => CandidateContribution;
+/**
+ * The `ValueEdge` a cited result needs to stay visible to whole-program
+ * authority-connectivity analysis. A `constant`/`absent` source crosses no
+ * operation boundary, so it needs none.
+ *
+ * The ordinal is a parameter and not a constant: an operand's role and ordinal
+ * together name it, and an edge that always claimed ordinal zero would describe
+ * the first argument of a call no matter which argument it actually carried.
+ */
+export declare const resultEdge: (source: OperandSource, to: OperationId, role: string, ordinal: number) => SemanticEdge | null;
+/** Every operand of an operation that cites a result, as edges into it. */
+export declare const valueEdgesInto: (to: OperationId, operands: readonly SemanticOperand[]) => SemanticEdge[];
+export declare const isAssignmentOperatorKind: (kind: ts.SyntaxKind) => boolean;
+/**
+ * Whether this source position evaluates in ECMAScript strict mode.
+ *
+ * An ES MODULE is strict in its entirety, unconditionally (ECMA-262 11.2.2) --
+ * no prologue, no `export`, nothing else required.
+ *
+ * Established against real `node`, not argued: the same `delete` of a
+ * non-configurable property answers `false` when the emitted file is loaded as
+ * CommonJS and throws `TypeError` when it is loaded as an ES module. Both
+ * `strict-delete.ts` and `native-handle-computed-access.runtime.js` throw under
+ * the module setting their own tsconfig states.
+ *
+ * THE `module` SETTING IS NOT THE QUESTION. It used to short-circuit this walk
+ * -- `module: ESNext` was read as "every file is a module, so every file is
+ * strict" -- and that is false for a file with no import and no export, which
+ * is a Script whatever the emit setting says. What actually makes every file in
+ * a build strict is `alwaysStrict` (implied by `strict`): tsc parses strict and
+ * writes a `'use strict'` prologue into each emitted file. That is
+ * `buildIsStrict`, and it is the only whole-build fact this needs; the rest --
+ * external module, prologue, class body -- is per position and walked here.
+ *
+ * `test/runtime/tsconfig.json` sets `strict: true`, so the suite's answer does
+ * not change. A build with `module: CommonJS` and `strict: true` was the case
+ * this got wrong in both directions at once.
+ */
+export declare const isStrictContext: (node: ts.Node, buildIsStrict: boolean) => boolean;
+/**
+ * A logical assignment writes only when the short-circuit does not fire, so it
+ * is not a read-operate-write at all; decomposing it as one would write a value
+ * the source program leaves untouched.
+ */
+export declare const logicalAssignmentOperators: ReadonlySet<ts.SyntaxKind>;
+/**
+ * A compound assignment reads its target, so the property and computation
+ * families must agree on exactly which operators those are. Derived from the
+ * assignment range minus the two forms that are not read-operate-write.
+ */
+export declare const isCompoundAssignmentOperator: (kind: ts.SyntaxKind) => boolean;
+/**
+ * Where an expression's value comes from, as an operand source.
+ *
+ * The identity is predictive, not observed: the owning family's producer mints
+ * this exact id independently from the same node, so the graph is wired by
+ * agreement on identity and never by execution order. Citation has exactly one
+ * implementation for that agreement to be worth anything -- three private
+ * copies of this drifted from it, kept citing a name's Reference Record after
+ * the shared rule moved to the value GetValue publishes, and every operand they
+ * built named a result nobody published. The publication guard then withheld
+ * those operations silently: no error, no blocker, just missing operations.
+ *
+ * The throw is deliberate. Every runtime-producing expression is censused, a
+ * literal, or `this`/`super`; reaching it means a form exists that neither this
+ * layer nor the census knows about, which is an implementation gap to fix here
+ * rather than a missing capability to report about the program.
+ */
+export declare const sourceForValue: (context: ProducerContext, expr: ts.Expression, branch?: CitedBranch) => OperandSource;
+/**
+ * `Object.getOwnPropertyDescriptor(receiver, key)`'s result, minted from the
+ * RECEIVER's own structural shape rather than the ambient `PropertyDescriptor`
+ * interface's own declared `value?: any` -- see `structural.ts`'s own
+ * `objectDescriptorReturnTypeAt` for the full reasoning and the actual
+ * decision. Delegates rather than re-deriving: `context.types.typeAt(call)`
+ * (the general per-node structural authority, asked by a property access's
+ * own receiver typing, a local binding's declared type, and everything else
+ * that asks "what is this node's type") already computes this exact answer
+ * for the bare CallExpression, and `validateInvocationResult`
+ * (`model/selected-signature.ts`) requires this producer's own
+ * `resultType`/`selectedSignature.returnType` to agree with it exactly --
+ * two independently-written copies of the same decision is precisely the
+ * shape that disagreement bit once already this session (a `buildSelectedSignature`-only
+ * version published a native record for the call's own SSA value while
+ * `context.types.typeAt` kept answering the old boxed one for every other
+ * reader of the same node).
+ */
+export declare const objectDescriptorReturnTypeAt: (context: ProducerContext, call: ts.CallExpression | ts.NewExpression) => StructuralTypeId | null;
+export declare const resolvedCalleeSignatureType: (context: ProducerContext, node: ts.Expression) => StructuralTypeId | null;
+export declare const calleeAwareTypeAt: (context: ProducerContext, node: ts.Expression) => StructuralTypeId;
+/**
+ * Whether a structural type is a plain `T[]`/`Array<T>` -- never a tuple,
+ * never a union, never an interned `unresolved`.
+ *
+ * This is the one predicate that decides whether a spread or a destructuring
+ * pattern's source may take the array/string fast path (index reads,
+ * `appendRange`) instead of needing the general iterator protocol. A tuple's
+ * elements are individually typed and keyed by position, not a single
+ * repeated element type, so it is deliberately excluded even though it is
+ * also array-shaped at runtime -- `lower-allocation.ts`'s own tuple-vs-array
+ * carrier split already draws this exact line, and this predicate answers it
+ * from the same source of truth (the interned shape), not a second opinion.
+ */
+export declare const isPlainArrayType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * The members an object spread copies, when the source's own-property set is
+ * statically known -- or the reason it is not.
+ *
+ * `{ ...a }` is `CopyDataProperties` (ECMA-262 7.3.25) over the source's OWN
+ * ENUMERABLE properties, and for a data-only object shape that set is exactly
+ * its members. This is the one authority on when that holds, asked by BOTH
+ * halves that must agree about it: `producers/allocations.ts` copies the
+ * members field by field, and `producers/protocol.ts` publishes its generic
+ * `spread` protocol operation only when this says no -- the same bypass shape,
+ * and for the same reason, that `isPlainArrayType` gives an array-literal
+ * spread. Two independent predicates here would let one half copy the fields
+ * while the other published a protocol step nothing lowers.
+ *
+ * A named interface interns as `declared` around its body; the BODY carries the
+ * members, so one level is unwrapped. Every other shape -- and every member
+ * this cannot copy correctly -- answers with a reason instead:
+ *
+ *  - an INDEX SIGNATURE: the own-property set is not known until runtime, and
+ *    copying only the declared members would silently drop the rest;
+ *  - an ACCESSOR: `{ ...o }` copies a getter's RETURNED value, so it must be
+ *    called, which is user code this layer does not invoke;
+ *  - a `signature`-shaped member: a method on a class instance lives on the
+ *    prototype and is not own-enumerable at all, and the shape alone cannot
+ *    tell that from an own function-valued field;
+ *  - `membersDropped`: a projection already filtered this body, so its member
+ *    list is not the source's own-property set (see `representation/object-shape.ts`);
+ *  - a SYMBOL key: `CopyDataProperties` skips a non-enumerable one, and the
+ *    shape does not record enumerability.
+ */
+export declare const staticSpreadMembersOf: (context: ProducerContext, type: StructuralTypeId) => {
+    readonly members: readonly StructuralMember[];
+} | {
+    readonly blocked: string;
+};
+/**
+ * Whether a structural type is the standard `Set<T>` -- the second source
+ * whose iteration needs no dynamic `@@iterator` lookup.
+ *
+ * The sibling of `isPlainArrayType` above, answering the same question about a
+ * shape whose answer is a DECLARATION identity rather than a shape kind. It
+ * reads `context.keyedCollections`, the frontend's one census
+ * (`host-protocols.ts`'s `keyedCollectionDeclarationsOf`), which is also what
+ * `representation/derive.ts` selects the collection carrier from -- so the
+ * producer's "skip the method lookup" decision and the carrier's "this is a
+ * `keyed-collection`" decision can never be made about different declarations.
+ *
+ * `'set'` ONLY -- `isNativeIterableMapType` below answers the Map half, which
+ * needs a different fact from the carrier side and so cannot share one
+ * predicate. The weak families have no iteration at all (ECMA-262 24.3/24.4)
+ * and are covered by neither.
+ */
+export declare const isNativeIterableSetType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * Whether a structural type is the standard `Map<K, V>` -- the fourth source
+ * whose iteration needs no dynamic `@@iterator` lookup, and the only one whose
+ * element is not storage the source already holds.
+ *
+ * ECMA-262 24.1.5.1 `%MapIteratorPrototype%.next` yields a `[K, V]` PAIR, and
+ * this compiler carries a tuple as a record of "0"/"1" fields. That is why the
+ * decision has two halves that must agree: this one, which says the census may
+ * skip the method lookup, and `representation/publish.ts`'s
+ * `nativeCursorIteratorOf`, which must be able to publish a cursor over the
+ * pair's own carrier. The carrier side is the stricter of the two -- it reads
+ * the pair's record layout back out of the iterator record's declared element
+ * type and refuses unless the fields really are "0"/"1" carrying the
+ * collection's own key and value -- so a Map whose pair this compiler cannot
+ * lay out publishes no cursor, keys as the unclaimed
+ * `protocol:iterator:next:record`, and refuses at preflight. Skipping the
+ * method lookup for it is therefore safe in the one direction that matters:
+ * it can only ever cost a refusal, never a wrong lowering.
+ */
+export declare const isNativeIterableMapType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * Whether a structural type is a `string` -- the third source whose iteration
+ * needs no dynamic `@@iterator` lookup.
+ *
+ * ECMA-262 22.1.3.36 `String.prototype[@@iterator]` walks the receiver by CODE
+ * POINT, and a String is an immutable primitive, so the step sequence is fixed
+ * the moment the loop starts: there is nothing for `GetIterator` to resolve
+ * that the value itself does not already answer. `gea::Iterator<std::string>`'s
+ * string source (`runtime/gea_runtime.h`) is that walk.
+ *
+ * Deliberately narrower than "everything that CARRIES as `string`": a union of
+ * string literals collapses to the `string` carrier in `derive.ts`, and this
+ * answers `false` for it. That asymmetry is safe in exactly one direction --
+ * `publish.ts` would publish the cursor, this producer would still mint the
+ * `get-method` step, and `protocol:iterator:get-method:string` is claimed by no
+ * manifest, so the program refuses at preflight by name. The reverse (claiming
+ * the fast path for a shape whose carrier is not `string`) would emit a
+ * constructor call that does not exist, so the predicate is written to fail in
+ * the safe direction rather than to re-derive `deriveUnion`'s collapse rule as
+ * a second authority.
+ */
+export declare const isNativeIterableStringType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * Whether a source is a tuple with a fixed arity -- every element at a known
+ * position, none of them rest or variadic.
+ *
+ * A tuple IS an Array at runtime, so `for (const x of ['a', 'b'] as const)` is
+ * ordinary TypeScript that every JavaScript engine iterates through
+ * `Array.prototype[Symbol.iterator]`. This compiler carries a tuple as "a
+ * record whose keys are its indices" (`derive.ts`'s `deriveTuple`), which has
+ * no `@@iterator` FIELD, so the general dynamic protocol correctly refused
+ * every such loop -- nine of them in the mongodb driver alone, each over a
+ * `const [...] as const` option list.
+ *
+ * A fixed arity is what makes the walk settled: the elements are the record's
+ * own fields, in order, known before the program runs. Whether they also share
+ * ONE element carrier is a question about representations, which this layer
+ * cannot ask -- `preflight/runtime-helper-key.ts`'s `iteratorMethodCarrierKind`
+ * refines the carrier per site and leaves a heterogeneous tuple on an
+ * unclaimed key, so it refuses at preflight rather than reaching an emitter
+ * with nothing to build.
+ */
+export declare const isFixedArityTupleType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * A tuple with a `rest` position and no variadic one -- `[A, ...B[]]`. Its
+ * carrier is an ARRAY (`representation/derive.ts`'s `deriveTuple`: the array
+ * carrier over the union of its positions), so iterating it is the array's
+ * own native cursor, the same one a plain `T[]` has.
+ */
+export declare const isOpenTupleType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * Whether a source's iteration is settled before the program runs -- an
+ * `array`, a `Set<T>`, a `Map<K, V>`, a `string`, a `Generator<T, ...>`, a
+ * fixed-arity tuple, or a union whose every present arm is one of those.
+ *
+ * The ONE predicate every consumer of the native iterator cursor asks, so that
+ * `for`-`of` (`control.ts`), array-literal spread (`allocations.ts`),
+ * call-argument spread (`spread-arguments.ts`, `protocol.ts`) and array
+ * destructuring (`destructuring.ts`) can never disagree about which sources it
+ * covers. They did disagree before it existed: a `for`-`of` over a `Set` took
+ * the fast path while `[...set]` in the same program minted a `get-method`
+ * step for the identical value and refused.
+ */
+/**
+ * The one PRESENT arm of a union whose only other arms are absent -- `T[] |
+ * undefined`, `Set<T> | null` -- or `null` for every other shape.
+ *
+ * Iterating an absent value is a runtime `TypeError` in ECMA-262 (7.4.2
+ * `GetIterator` calls `GetMethod` on `undefined`, which throws), never a
+ * static impossibility, so `T[] | undefined` iterates through exactly the
+ * cursor `T[]` does with a presence assertion in front of it. The ONLY thing
+ * absence changes is whether the walk starts.
+ *
+ * That distinction is the reason this looks through the wrapper rather than
+ * `hasNativeIterationCursor` growing an arm per absent-shaped source: the
+ * cursor, its element and every capability claim behind it are the payload's,
+ * and the absence is a separate, single fact the backend spells once
+ * (`targets/cpp/emit-iterator.ts`'s presence assertion) for whichever payload
+ * shape it wraps.
+ *
+ * Exactly one present arm, deliberately. Two would be a real union needing a
+ * discriminated walk -- a question about representations this layer cannot
+ * ask -- and zero is `never`, which iterates nothing.
+ */
+export declare const presentIterationArm: (context: ProducerContext, type: StructuralTypeId) => StructuralTypeId | null;
+export declare const hasNativeIterationCursor: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * The type an iteration actually reads FROM, once a union that names one real
+ * iterable has been peeled to it.
+ *
+ * ONE authority, because two questions are asked about this same peeled type
+ * and they must not be able to disagree: `hasNativeIterationCursor` below asks
+ * whether it has a native cursor, and `producers/protocol.ts`'s
+ * `iterationElementType` asks what that cursor yields. Those are the two
+ * callers, and they are the only two.
+ *
+ * They HAD disagreed, in three different spellings of the same peel:
+ * `presentIterationArm` answers only when something nullish was actually
+ * removed, `soleDistinctPresentArm` dedupes members first, and
+ * `iterationElementType` carried a third, inline copy that did neither. A
+ * union whose arms intern to ONE id (`NodeArray<BindingElement> |
+ * NodeArray<ArrayBindingElement>`, tsc's `Node` family being one layout) is
+ * peeled by the deduping spelling and not by the inline one -- so the cursor
+ * predicate said "native cursor, no dynamic `Symbol.iterator` lookup needed"
+ * while the element reader fell through to the checker walk and refused with
+ * `the source declares no @@iterator/next/IteratorResult chain this can read
+ * an element type from`. That is `nested-array-assignment-pattern.runtime.js`'s
+ * for-`of` arm: a certified cursor whose element type nothing could state.
+ *
+ * Returns `null` when the type is not such a union at all -- the caller then
+ * uses the type it already had, which is what both callers did before.
+ */
+export declare const iterationPayloadArm: (context: ProducerContext, type: StructuralTypeId) => StructuralTypeId | null;
+/**
+ * Whether a `for`-`in` over this source enumerates one of the NATIVE cursors
+ * `targets/cpp/emit-iterator.ts` renders: a runtime key TABLE
+ * (`gea::Dictionary<V>`), a STATIC field-name snapshot built from a
+ * statically shaped receiver's own compile-time member set
+ * (`emitStaticEnumerateIterator`, over `gea::nativeDynamicKeys`), or a
+ * genuinely DYNAMIC receiver's real own-enumerable-key walk
+ * (`emitDynamicEnumerateIterator`, over `Value::ownEnumerableStringKeys`).
+ *
+ * The enumerate sibling of `hasNativeIterationCursor`, and the same kind of
+ * fact for the first two: the keys are storage the receiver already holds
+ * (a runtime table, or a compile-time field list), so `for (const k in t)`
+ * needs no `[[OwnPropertyKeys]]` machinery and no dynamic protocol.
+ *
+ * The dictionary test mirrors `representation/object-shape.ts`'s
+ * `dictionaryIndexOf` exactly -- no members, exactly one index signature,
+ * string-keyed -- because the two have to agree: this decides the LOOP SHAPE
+ * and that decides the CARRIER, and a loop reshaped for a cursor the deriver
+ * then does not produce would refuse with a key naming neither. It is a
+ * structural test rather than a call into `representation/`, which normalize
+ * runs before and must not depend on -- `producer-context.ts`'s own doc says
+ * as much: a question this predicate cannot answer from the sealed structural
+ * table alone needs a NEW primitive threaded onto `ProducerContext`, never a
+ * second derivation of a representation-layer policy.
+ *
+ * A NAMED type (`'declared'`: an interface or type alias) COULD be
+ * intercepted by a declaration-identity policy in `representation/derive.ts`
+ * before ever reaching a plain `record`/`record-with-index` carrier --
+ * `Date`, `RegExp`, `Promise`, a data-only host-bound plugin struct via
+ * `nativeTypes` (`GeaEmbeddedImage`, `FetchResponse`, ...) -- and none of
+ * those policies' censuses (`DateDeclarationPolicy`, `RegExpDeclarationPolicy`,
+ * the host binding table, ...) are threaded onto `ProducerContext`, so this
+ * predicate cannot ask the identity question `derive.ts` asks and get the
+ * same answer; it can only ask the STRUCTURAL question (is the body a
+ * complete record) that `object-anchor` and bare `'object'` already answer
+ * below. The host-binding case is the one that matters: `derive.ts`'s own
+ * `'declared'` case hardcodes `{ kind: 'native-record-ref', ownership:
+ * 'owned', native: bound.native }` for a data-only bound type -- the EXACT
+ * `native !== null` combination `emitStaticEnumerateIterator` refuses -- and
+ * it shares its `.kind` (`'native-record-ref'`) with the safe,
+ * compiler-defined case (a plain interface derives the identical kind with
+ * `native: null`), so a carrier-kind obligation keyed only on `.kind` cannot
+ * tell the two apart. That is not a reason to keep `'declared'` OUT of this
+ * widening, though -- it is a reason the DISTINGUISHING question has to be
+ * asked somewhere that still has the full representation to inspect.
+ * `'declared'` is therefore treated exactly like `object-anchor` below (both
+ * unwrap to their body and take the identical dictionary/record checks), and
+ * the host-bound sub-case is caught downstream instead, at preflight:
+ * `runtime-helper-key.ts`'s `enumerateGetIteratorCarrierKind` re-resolves the
+ * `get-iterator` target's own representation (not just its bare kind, which
+ * is all this structural predicate has) and reports a host-bound
+ * `native-record-ref` under its own, deliberately unclaimed key --
+ * `native-record-ref(host-bound)` -- the same "refine the receiver key" move
+ * `preflight/property-access.ts`'s `nativeRecordRefHasIndexSidecar` makes for
+ * a `native-record-ref` property read. So a host-bound `for`-`in` is still
+ * refused by NAME, still at preflight, still before either loop shape is
+ * lowered -- it is just a different file that owns the distinction, because
+ * that file is the one still holding the representation once normalize's own
+ * structural view of it has been discarded.
+ *
+ * A compiler-defined CLASS instance (`'class-instance'` with a non-null
+ * `body`) does not share that risk, for a reason specific to it:
+ * `derive.ts`'s `'class-instance'` case checks the SAME host-binding census
+ * before ever looking at `shape.body`, but a bound class -- data-only or not
+ * -- resolves to a DIFFERENT kind there, `native-handle`, never `class-ref`;
+ * there is no shared-kind trap for the carrier-kind obligation to miss. And
+ * `class-ref`'s ownership is never the value-record `'owned'` override either
+ * -- `compiler.ts`'s own policy only overrides `shape.kind === 'object'`,
+ * never `'class-instance'` -- so it is always `shared-refcount`. A bound
+ * class is caught cleanly (unclaimed `native-handle` key); an unbound one is
+ * exactly the `class-ref` `emitStaticEnumerateIterator` renders.
+ *
+ * `'object'` (bare, or unwrapped from a callable-bearing object-literal
+ * anchor) needs none of that caution either: it names no declaration a policy
+ * could intercept by identity, so a plain, non-generic `record`/
+ * `record-with-index` is the only carrier `derive.ts`'s `deriveObject` can
+ * ever produce for it.
+ */
+export declare const hasNativeEnumerationCursor: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * Whether a structural type is the standard `Generator<T, TReturn, TNext>` --
+ * what a `function*` returns, and the fifth source with no `@@iterator` lookup
+ * behind it.
+ *
+ * A generator IS its own iterator: ECMA-262 27.5.1.2
+ * `%GeneratorPrototype%[@@iterator]` returns `this`, so `GetIterator` over one
+ * resolves to the value already in hand and there is nothing dynamic to look
+ * up. `representation/derive.ts`'s `GeneratorDeclarationPolicy` carries it as
+ * the same `iterator(T)` cursor for exactly that reason -- one value, one
+ * carrier, whether it is being called or being walked.
+ *
+ * Keyed on the declaration the frontend resolved, never on the name, for the
+ * reason `isNativeIterableSetType` states about `Set`: the deriver reads the
+ * SAME identity, so the two cannot disagree about which declaration is meant.
+ */
+export declare const isGeneratorType: (context: ProducerContext, type: StructuralTypeId) => boolean;
+/**
+ * The canonical *static* key text a bracketed key expression resolves to when
+ * it names a `unique symbol`, or `null` when it does not.
+ *
+ * `this[GEA_STATIC_ELEMENT]` is not a dynamic property access. The checker
+ * resolves it to a declared member exactly as it resolves `this.rendered`: a
+ * `unique symbol` is a compile-time identity, `class C { [S]: T }` declares a
+ * member named by it, and `keyof C` includes it. So the key here is static in
+ * the only sense this layer's `computed` flag means -- "the key resolved to a
+ * constant text" -- which is already why `o["0"]` and `o[0]` are reported
+ * non-computed despite being written in brackets.
+ *
+ * The text is `structural-types.ts`'s `symbolPropertyKeyText`, which is also
+ * what `representation/object-shape.ts` names the record field by, so the
+ * access and the layout cannot disagree about which member is meant. The
+ * `unique-symbol` shape is read back out of the interned table rather than
+ * asked of the checker a second time: `structural.ts` already resolved the
+ * declaration anchor (and already answered `unresolved` for a symbol that has
+ * none), and a second resolution here would be a second authority over one
+ * fact.
+ */
+export declare const uniqueSymbolKeyTextOf: (context: ProducerContext, type: StructuralTypeId) => string | null;
+/** The shared layout fact that requires retaining a symbol's evaluated identity. */
+export declare const isRuntimeSymbolMember: (context: ProducerContext, receiver: StructuralTypeId, keyType: StructuralTypeId) => boolean;
+/**
+ * `ToPropertyKey` of a key whose value is fixed at compile time, or `null` when
+ * it is not.
+ *
+ * `{ [K]: v }` is not a dynamic property definition when `K`'s *type* pins the
+ * key: the checker itself types `{ [K]: 1 }` as `{ a: number }` for
+ * `const K = 'a'`, lists `a` in `keyof`, and resolves `o.a` against it. So the
+ * key is static in the only sense this layer's `computed` flag means -- the
+ * same sense in which `o["0"]` and `o[0]` are already reported non-computed --
+ * and lowering it as anything else would put a member the layout declares into
+ * a dictionary the layout does not have.
+ *
+ * The answer is read out of the interned shape rather than off the key's
+ * syntax, which is what makes `const K = 'a'` and `'a'` one case: a
+ * declaration's literal type is exactly as fixed as a literal written in place,
+ * and `structural-leaves.ts` has already interned both as the same shape.
+ * Reading syntax would see two different programs.
+ *
+ * Every literal shape resolves, because ECMA-262 7.1.19 `ToPropertyKey` is
+ * total over them and `structural-leaves.ts` already interned each one's text
+ * in the exact spelling `ToString` produces: a number through `String(value)`
+ * (which is `Number::toString`, and answers `"0"` for `-0` as the language
+ * does), a bigint in decimal, a boolean as `"true"`/`"false"`. A `unique
+ * symbol` needs no `ToString` at all -- it is already a property key -- and
+ * shares `uniqueSymbolKeyTextOf`'s spelling so a computed definition and a
+ * `receiver[K]` read name one member.
+ */
+export declare const staticPropertyKeyTextOf: (context: ProducerContext, type: StructuralTypeId) => string | null;
+/**
+ * The static member key `receiver[SOME_SYMBOL]` names, or `null` when the
+ * access is not a declared-member read at all.
+ *
+ * This is the whole difference between two accesses that look identical:
+ *
+ *   this[GEA_STATIC_ELEMENT]                       // a declared class member
+ *   (obj as Record<symbol, unknown>)[GEA_DIRTY]    // an index signature
+ *
+ * The first is a struct member load with a compile-time name -- the checker
+ * resolves it to a declared member exactly as it resolves `this.rendered`. The
+ * second is a genuine dynamic-table lookup keyed by the symbol's RUNTIME
+ * value, and spelling it as a static text would file it under the string half
+ * of the object's key space, where `Object.keys` would list a property whose
+ * whole purpose is not being enumerated.
+ *
+ * The RECEIVER'S MEMBER LIST decides, and it is asked of the checker rather
+ * than of the already-interned shape: `structural.ts` interns some bodies
+ * data-only (its `MemberMode`), so a symbol-named METHOD -- which
+ * `this[GEA_STATIC_TEMPLATE]()` is -- is absent from the interned body while
+ * being a perfectly ordinary declared member. Reading the interned body would
+ * therefore answer "dynamic" for a member the class really declares.
+ *
+ * Matching is by DECLARATION IDENTITY, never by spelling:
+ * `symbolKeyDeclarationOf` resolves a member's key to the `const` the symbol
+ * was bound to, which is the identical anchor `structural.ts`'s
+ * `UniqueESSymbol` branch gives the key expression's own type, so the two
+ * sides compare one fact.
+ */
+export declare const symbolMemberKeyOf: (context: ProducerContext, receiver: ts.Expression, keyType: StructuralTypeId) => string | null;
+type NamedCallableNode = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration;
+/**
+ * ECMA-262's `[[Name]]` internal slot for a callable, decided entirely at
+ * compile time from its syntax: a function/method/accessor's own written
+ * name (with `get `/`set ` prefixed for an accessor, exactly as
+ * `MethodDefinitionEvaluation`'s own `SetFunctionName` calls do), or --
+ * for an anonymous function/arrow expression -- the `NamedEvaluation` name
+ * from wherever it was defined (`namedEvaluationNameOf`).
+ *
+ * Both halves are pure syntax facts, independent of any value the callable
+ * ever carries at runtime, which is what makes this safe to decide once per
+ * allocation site and register in the runtime's static `SourceRegistration`
+ * table exactly as `functionSource` already is -- see
+ * `producers/allocations.ts`'s and `producers/class-lifecycle.ts`'s own
+ * `functionName` fields.
+ */
+/**
+ * ECMA-262's `[[Name]]` for a class constructor, the same way
+ * `staticFunctionNameOf` below decides it for a function: the class's own
+ * written name, or -- for an anonymous class expression -- the
+ * `NamedEvaluation` name of the position it was written in (`const A = class
+ * {}` is `"A"`, `[cls = class {}]` is `"cls"`), or `"default"` for an
+ * anonymous `export default class`. A class that declares its own static
+ * `name` member shadows this at the read site, which is the reader's rule
+ * (`emit-class-properties.ts`'s static-member walk runs first), not this one's.
+ */
+export declare const staticClassNameOf: (node: ts.ClassLikeDeclaration) => string;
+/**
+ * `Function.prototype.length` for a class constructor: the written
+ * constructor's `ExpectedArgumentCount` (`expectedParameterCountOf`), or 0
+ * for a class relying on the implicit one -- the default constructor of a
+ * base class takes no parameters, and a derived class's `(...args)` has a
+ * rest parameter first, so both count 0.
+ */
+export declare const staticClassLengthOf: (node: ts.ClassLikeDeclaration) => number;
+export declare const staticFunctionNameOf: (node: NamedCallableNode) => string;
+/**
+ * ECMA-262 `ExpectedArgumentCount`: the leading run of a callable's own
+ * written parameters, up to (and excluding) the first one that has a default
+ * initializer or is a rest parameter. This is `Function.prototype.length`,
+ * and it is a fact about the written parameter list alone -- independent of
+ * `NamedEvaluation`, and independent of the calling convention this compiler
+ * projects, which erases exactly the "has a default" bit this needs (a
+ * defaulted parameter is narrowed to its own storage type same as a required
+ * one). So it is read directly off the syntax here, once, the same way
+ * `functionSource` is.
+ *
+ * TypeScript's synthetic `this` parameter (`function f(this: Foo, x: number)`)
+ * binds no argument position and is invisible to `.length`; the grammar
+ * allows it only in leading position, so skipping index 0 when it names
+ * `this` is exhaustive.
+ */
+export declare const expectedParameterCountOf: (node: ts.SignatureDeclarationBase) => number;
+/**
+ * Whether the declaration performs ECMA-262 10.2.5 `MakeConstructor`, and so
+ * owns a `prototype` object, or `null` where the answer exists but this
+ * compiler does not model it.
+ *
+ * A syntax fact decided once per allocation site, exactly as
+ * `expectedParameterCountOf` above is: an ordinary `function` declaration or
+ * expression makes a constructor, while an arrow, a method, an accessor and
+ * an `async function` are created by `OrdinaryFunctionCreate` with no such
+ * step and own no `prototype` at all.
+ *
+ * A generator answers `null` rather than `true`. It does own a `prototype`,
+ * but 27.3.1's object inherits `%GeneratorFunction.prototype.prototype%`,
+ * which this runtime has no object for -- and reporting `true` would hand a
+ * read a plain object whose `constructor` chain is wrong. `null` keeps the
+ * read refused, which is the honest answer while that intrinsic is missing.
+ */
+export declare const ownPrototypePropertyOf: (node: ts.Node) => boolean | null;