@geastack/compiler 1.0.15

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

@@ -0,0 +1,53 @@
+import ts from 'typescript';
+import { type SemanticResultId } from '../../../identity/ids.js';
+import type { FamilyProducer } from '../contribution.js';
+import { type OperandSource } from '../../model/operands.js';
+import type { NamespacePathCensus } from '../namespace-paths.js';
+import type { ArgumentsObjectCensus } from '../arguments-objects.js';
+import type { IdentityTable } from '../identities.js';
+import type { ProducerContext } from '../producer-context.js';
+import type { UnresolvableNameCensus } from '../unresolvable-names.js';
+export type ExpressionCitation = {
+    readonly kind: 'source';
+    readonly source: OperandSource;
+    /** Present only for a name: the Reference Record, for an assignment target. */
+    readonly reference?: SemanticResultId;
+}
+/** No family was censused for this node, so no result exists to cite. */
+ | {
+    readonly kind: 'unmodelled';
+    readonly reason: string;
+};
+/**
+ * Which value of a `?.`-carrying link a citer wants.
+ *
+ * `expression` is what the source expression evaluates to -- the property on
+ * one branch and `undefined` on the other -- and is what every ordinary
+ * consumer means. `present` is the `[[Get]]`'s own answer, which exists only
+ * inside the guard's present arm. An optional call is the one citer that needs
+ * it: it *runs* in that arm, gated on the same guard, and the merge that makes
+ * the `expression` value does not exist until both arms have joined, which is
+ * after the call has already happened.
+ */
+export type CitedBranch = 'expression' | 'present';
+/**
+ * What `citeExpressionResult` needs beyond the syntax in front of it.
+ *
+ * It is a PREDICTOR: it names the result a producer will publish for an
+ * expression without running that producer, so every fact it branches on has
+ * to be one both sides can read. `identities` was the whole of that until
+ * `arguments` -- whose citation depends on a question only the checker can
+ * answer -- so the checker answers once in the frontend and both sides read
+ * the same census.
+ *
+ * `ProducerContext` satisfies this structurally, so a producer passes itself.
+ */
+export interface CitationFacts {
+    readonly identities: IdentityTable;
+    readonly argumentsObjects: ArgumentsObjectCensus;
+    readonly unresolvableNames: UnresolvableNameCensus;
+    /** Which property accesses are namespace paths or qualified members (`namespace-paths.ts`). */
+    readonly namespacePaths: NamespacePathCensus;
+}
+export declare const citeExpressionResult: (expression: ts.Expression, facts: CitationFacts, branch?: CitedBranch) => ExpressionCitation;
+export declare const createReferenceProducer: (context: ProducerContext) => FamilyProducer;