@geastack/compiler 1.0.15

package/dist/semantics/normalize/producers/dynamic-language.d.ts

@@ -0,0 +1,3 @@
+import type { FamilyProducer } from '../contribution.js';
+import type { ProducerContext } from '../producer-context.js';
+export declare const createDynamicLanguageProducer: (context: ProducerContext) => FamilyProducer;

package/dist/semantics/normalize/producers/dynamic-language.js

@@ -0,0 +1,70 @@
+import ts from 'typescript';
+import { normalCompletion } from '../../model/operands.js';
+import { mintOperationId, mintResult, operand } from './mint.js';
+import { asBlocked } from './shared.js';
+import { citeExpressionResult } from './references.js';
+export const createDynamicLanguageProducer = (context) => {
+    const stringType = context.table.intern({ kind: 'primitive', primitive: 'string' });
+    const contributeDynamicImport = (candidate, node) => {
+        const source = candidate.id;
+        const specifierExpression = node.arguments[0];
+        const operands = [];
+        const edges = [];
+        const id = mintOperationId(context.ordinals, source, 'dynamic-language');
+        if (specifierExpression && ts.isStringLiteralLike(specifierExpression)) {
+            // The specifier's text is a language-level VALUE here (the module request
+            // string HostResolveImportedModule receives), not an identity: the module
+            // this call reaches is genuinely unresolvable at compile time -- an `open`
+            // target is the correct, complete answer, never a guess from this text.
+            operands.push(operand('specifier', 0, { kind: 'constant', text: specifierExpression.text, literal: 'string' }, stringType));
+        }
+        else if (specifierExpression) {
+            // A non-literal specifier (`import(path())`) is itself another family's
+            // operation; cite its already/about-to-be-published result rather than
+            // omitting the operand, exactly as properties.ts and bindings.ts do for
+            // their own operand sources.
+            const cited = citeExpressionResult(specifierExpression, context);
+            if (cited.kind === 'unmodelled') {
+                return asBlocked(candidate.id, 'dynamic-language', `dynamic import specifier ${cited.reason}`, 'H0');
+            }
+            operands.push(operand('specifier', 0, cited.source, stringType));
+            if (cited.source.kind === 'result') {
+                edges.push({ kind: 'value', result: cited.source.result, to: id, role: 'specifier', ordinal: 0 });
+            }
+        }
+        const attributesArgument = node.arguments[1];
+        if (attributesArgument && !ts.isObjectLiteralExpression(attributesArgument)) {
+            return asBlocked(candidate.id, 'dynamic-language', 'dynamic import attributes argument of an unmodelled shape', 'H0');
+        }
+        // `import()` never throws synchronously (PerformDynamicImportEvaluation
+        // always returns a promise); a resolution or evaluation failure surfaces as
+        // a rejected promise, which is a data-level fact about the produced value,
+        // not an abrupt completion of this expression.
+        const resultType = context.types.typeAt(node);
+        const operation = {
+            id,
+            caller: candidate.caller,
+            operands,
+            results: [mintResult(id, 'value', resultType)],
+            completion: normalCompletion,
+            effects: { readsMutableState: false, writesMutableState: false, allocates: true, callsUserCode: false },
+            evaluationOrdinal: candidate.evaluationOrdinal,
+            family: 'dynamic-language',
+            form: 'dynamic-import'
+        };
+        return { kind: 'operations', operations: [operation], edges };
+    };
+    const contribute = (candidate) => {
+        const { node } = candidate;
+        if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+            return contributeDynamicImport(candidate, node);
+        }
+        // The census (see `familyOf` in census.ts) currently routes only `import()`
+        // call expressions to this family; `direct-eval` requires proving a callee
+        // resolves to the un-shadowed global `eval` binding, which is checker
+        // identity this producer does not yet perform, and no census candidate
+        // reaches it under this family regardless.
+        return asBlocked(candidate.id, 'dynamic-language', 'direct eval requires checker-resolved global-eval binding identity, not yet available here', 'H0');
+    };
+    return { family: 'dynamic-language', contribute };
+};

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

@@ -0,0 +1,51 @@
+import ts from 'typescript';
+/**
+ * The wrappers that erase at compile time.
+ *
+ * Parentheses change grouping only; `as`, `satisfies`, `<T>x`, and `!` are
+ * assertions the runtime never evaluates as a step of their own. A producer
+ * that built an operand from the wrapper instead of the wrapped expression
+ * would cite a family the census never assigned, and the citation would name a
+ * result nobody publishes.
+ *
+ * This lives alone, importing nothing but `typescript`, because three producers
+ * had grown three private copies of it and the copies had already drifted: one
+ * saw through `satisfies` and another did not, so the same expression was two
+ * different expressions depending on which producer asked. A rule this small is
+ * exactly the kind that gets re-typed rather than imported, and the drift is
+ * silent -- so there is one, and it is the only one.
+ */
+export declare const unwrapErased: (node: ts.Node) => ts.Node;
+/** The same rule where the caller already knows it holds an expression. */
+export declare const unwrapErasedExpression: (expression: ts.Expression) => ts.Expression;
+/**
+ * The node whose PARENT decides this expression's syntactic position.
+ *
+ * `unwrapErased` answers "which expression really produces this value"; this
+ * answers the mirror question, "which node really occupies this value's place
+ * in its parent". `l[1]! += 5` is an assignment whose target is the element
+ * access, but the access's own `parent` is the `!`, so a producer that read
+ * `node.parent` to learn its position saw a `NonNullExpression` and concluded
+ * it was in no assignment at all. The store was then published by nobody --
+ * neither this family nor the binding family, which correctly declines a
+ * property target -- and `l[1]! = 9` compiled to nothing at all. Silently: a
+ * dropped write is not a diagnostic, it is a wrong answer.
+ *
+ * The walk is the exact inverse of `unwrapErased`'s, and stops at the same
+ * five wrappers, so the two can never disagree about which nodes erase.
+ */
+export declare const outermostErasureOf: (node: ts.Node) => ts.Node;
+/**
+ * The call-like expression this node is invoked through, seeing past the same
+ * erasable wrappers `unwrapErased` sees through -- `(arr.map)(cb)` invokes
+ * `arr.map` exactly as `arr.map(cb)` does, so a parenthesized or asserted
+ * callee must resolve to the same call as an unwrapped one.
+ *
+ * One position question asked of `outermostErasureOf`'s answer: it finds the
+ * node the call would actually see, and this asks whether that node is the
+ * call's callee. It exists so a property access's own published value type can
+ * ask "am I being invoked, and by which call" without a producer inventing its
+ * own walk -- the exact kind of small, easily-drifted rule `unwrapErased`'s own
+ * comment warns about.
+ */
+export declare const enclosingCallIfCallee: (node: ts.Node) => ts.CallExpression | ts.NewExpression | ts.TaggedTemplateExpression | null;

package/dist/semantics/normalize/producers/erasure.js

@@ -0,0 +1,90 @@
+import ts from 'typescript';
+/**
+ * The wrappers that erase at compile time.
+ *
+ * Parentheses change grouping only; `as`, `satisfies`, `<T>x`, and `!` are
+ * assertions the runtime never evaluates as a step of their own. A producer
+ * that built an operand from the wrapper instead of the wrapped expression
+ * would cite a family the census never assigned, and the citation would name a
+ * result nobody publishes.
+ *
+ * This lives alone, importing nothing but `typescript`, because three producers
+ * had grown three private copies of it and the copies had already drifted: one
+ * saw through `satisfies` and another did not, so the same expression was two
+ * different expressions depending on which producer asked. A rule this small is
+ * exactly the kind that gets re-typed rather than imported, and the drift is
+ * silent -- so there is one, and it is the only one.
+ */
+export const unwrapErased = (node) => {
+    let current = node;
+    for (;;) {
+        if (ts.isParenthesizedExpression(current) ||
+            ts.isNonNullExpression(current) ||
+            ts.isAsExpression(current) ||
+            ts.isSatisfiesExpression(current) ||
+            ts.isTypeAssertionExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        return current;
+    }
+};
+/** The same rule where the caller already knows it holds an expression. */
+export const unwrapErasedExpression = (expression) => unwrapErased(expression);
+/**
+ * The node whose PARENT decides this expression's syntactic position.
+ *
+ * `unwrapErased` answers "which expression really produces this value"; this
+ * answers the mirror question, "which node really occupies this value's place
+ * in its parent". `l[1]! += 5` is an assignment whose target is the element
+ * access, but the access's own `parent` is the `!`, so a producer that read
+ * `node.parent` to learn its position saw a `NonNullExpression` and concluded
+ * it was in no assignment at all. The store was then published by nobody --
+ * neither this family nor the binding family, which correctly declines a
+ * property target -- and `l[1]! = 9` compiled to nothing at all. Silently: a
+ * dropped write is not a diagnostic, it is a wrong answer.
+ *
+ * The walk is the exact inverse of `unwrapErased`'s, and stops at the same
+ * five wrappers, so the two can never disagree about which nodes erase.
+ */
+export const outermostErasureOf = (node) => {
+    let current = node;
+    for (;;) {
+        const parent = current.parent;
+        if (parent !== undefined &&
+            (ts.isParenthesizedExpression(parent) ||
+                ts.isNonNullExpression(parent) ||
+                ts.isAsExpression(parent) ||
+                ts.isSatisfiesExpression(parent) ||
+                ts.isTypeAssertionExpression(parent)) &&
+            parent.expression === current) {
+            current = parent;
+            continue;
+        }
+        return current;
+    }
+};
+/**
+ * The call-like expression this node is invoked through, seeing past the same
+ * erasable wrappers `unwrapErased` sees through -- `(arr.map)(cb)` invokes
+ * `arr.map` exactly as `arr.map(cb)` does, so a parenthesized or asserted
+ * callee must resolve to the same call as an unwrapped one.
+ *
+ * One position question asked of `outermostErasureOf`'s answer: it finds the
+ * node the call would actually see, and this asks whether that node is the
+ * call's callee. It exists so a property access's own published value type can
+ * ask "am I being invoked, and by which call" without a producer inventing its
+ * own walk -- the exact kind of small, easily-drifted rule `unwrapErased`'s own
+ * comment warns about.
+ */
+export const enclosingCallIfCallee = (node) => {
+    const current = outermostErasureOf(node);
+    const parent = current.parent;
+    if (parent === undefined)
+        return null;
+    if ((ts.isCallExpression(parent) || ts.isNewExpression(parent)) && parent.expression === current)
+        return parent;
+    if (ts.isTaggedTemplateExpression(parent) && parent.tag === current)
+        return parent;
+    return null;
+};

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

@@ -0,0 +1,3 @@
+import type { FamilyProducer } from '../contribution.js';
+import type { ProducerContext } from '../producer-context.js';
+export declare const installedProducers: (pluginProducers: (context: ProducerContext) => readonly FamilyProducer[]) => (context: ProducerContext) => readonly FamilyProducer[];

package/dist/semantics/normalize/producers/installed.js

@@ -0,0 +1,55 @@
+import { createAllocationProducer } from './allocations.js';
+import { createBindingProducer } from './bindings.js';
+import { createBoundaryProducer } from './boundary.js';
+import { createClassLifecycleProducer } from './class-lifecycle.js';
+import { createComputationProducer } from './computations.js';
+import { createControlProducer } from './control.js';
+import { createDeclarationLifecycleProducer } from './declaration-lifecycle.js';
+import { createDestructuringProducer } from './destructuring.js';
+import { createDynamicLanguageProducer } from './dynamic-language.js';
+import { createElementProducer } from './jsx.js';
+import { createInvocationProducer } from './invocations.js';
+import { createPropertyProducer } from './properties.js';
+import { createProtocolProducer } from './protocol.js';
+import { createReferenceProducer } from './references.js';
+/**
+ * The producers this build installs.
+ *
+ * A family absent from this list is reported `not-installed` by the census with
+ * its complete candidate set, which is the whole point of listing them in one
+ * place: the difference between "this family publishes nothing" and "this
+ * program contains none of it" stays measurable instead of being inferred from
+ * an empty result.
+ *
+ * Every producer is built from the same context, so they share one ordinal
+ * authority. Constructing one with its own counter would let two families mint
+ * the same identity for two different operations.
+ *
+ * A plugin producer for a family the core also installs *replaces* it, and the
+ * replacement is total rather than layered. Running both would publish the same
+ * operation twice under the same identity; letting the plugin only annotate
+ * what the core already decided would mean a library could never see a
+ * construct differently, which is exactly what a library that gives it new
+ * meaning needs to do.
+ */
+const coreProducers = (context) => [
+    createReferenceProducer(context),
+    createPropertyProducer(context),
+    createBindingProducer(context),
+    createInvocationProducer(context),
+    createAllocationProducer(context),
+    createComputationProducer(context),
+    createControlProducer(context),
+    createProtocolProducer(context),
+    createBoundaryProducer(context),
+    createClassLifecycleProducer(context),
+    createDeclarationLifecycleProducer(context),
+    createDestructuringProducer(context),
+    createDynamicLanguageProducer(context),
+    createElementProducer(context)
+];
+export const installedProducers = (pluginProducers) => (context) => {
+    const contributed = pluginProducers(context);
+    const claimed = new Set(contributed.map((producer) => producer.family));
+    return [...coreProducers(context).filter((producer) => !claimed.has(producer.family)), ...contributed];
+};

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

@@ -0,0 +1,35 @@
+import ts from 'typescript';
+import { type StructuralTypeId } from '../../../identity/ids.js';
+import type { FamilyProducer } from '../contribution.js';
+import type { ProducerContext } from '../producer-context.js';
+/**
+ * `Object.create(null)`'s call-site override -- the same shape
+ * `arrayConstructResultOverride` above answers, at a third ambient signature
+ * whose declared return type is `any`.
+ *
+ * `lib.es5.d.ts` declares `create(o: object | null): any`, so this call's own
+ * published result is `dynamic(declared-any-never-narrowed)` no matter what
+ * the program says it is making. `const emptyParams: Params =
+ * Object.create(null)` (hono's pattern router) therefore emitted a
+ * `gea::Value::object()` -- a runtime `DynamicObject` -- stored into a
+ * `gea::Ref<gea::Dictionary<std::string>>` cell through `unboxValue`, whose
+ * payload-type check finds two different C++ types and aborts. Not a compile
+ * error, not a wrong answer: a program that dies on its first statement.
+ *
+ * Safe for exactly the reason the other overrides are, and no weaker one:
+ * this compiler renders `Object.create`'s own implementation
+ * (`targets/cpp/host/emit-host-object.ts`'s `createText`), so it is
+ * physically capable of minting the declared carrier directly -- 20.1.2.2's
+ * OrdinaryObjectCreate with a null prototype and no own properties IS an
+ * empty `gea::Dictionary<V>` or a value-initialized record struct. A carrier
+ * `createText` cannot mint keeps the dynamic rendering it always had, so a
+ * nonsense annotation fails the same way it did before rather than reading a
+ * lie into the call.
+ *
+ * Only the null-prototype, one-argument form: every other form refuses at
+ * emission (a real prototype chain and a properties object are both features
+ * this backend has not installed), and a call that will refuse has no result
+ * carrier worth overriding.
+ */
+export declare const objectCreateResultOverride: (context: ProducerContext, node: ts.CallExpression, calleeUnwrapped: ts.Node) => StructuralTypeId | null;
+export declare const createInvocationProducer: (context: ProducerContext) => FamilyProducer;