@velarscript/compiler 0.12.0 → 0.13.0

package/dist/analyzer.d.ts

@@ -1,6 +1,6 @@
 import type { Expression, FunctionDeclaration, Program, Statement, TypeParameterDeclaration, TypeReference, TypeSyntax } from "./ast.ts";
 import { type PermanentNamespaceName } from "./core-vocabulary.ts";
-import { type Diagnostic, type DiagnosticFix } from "./diagnostic.ts";
+import { type Advisory, type Diagnostic, type DiagnosticFix } from "./diagnostic.ts";
 import type { CompilerAnalysisExtension } from "./extension.ts";
 import { type Span } from "./source.ts";
 import { type EnumInfo, type BinaryStorageKind, type ExtensionValueType, type GenericTypeInfo, type TypeEnvironment, type TypeParameterBound, type ValueType } from "./types.ts";
@@ -12,6 +12,12 @@ interface Binding {
     readonly storageBinding?: Binding;
     readonly span: Span;
     narrowingFrame: number | null;
+    /**
+     * The scope depth this binding was created at. A flow snapshot only visits
+     * bindings whose facts have actually moved, and this is how the set of those
+     * is emptied again when the scope holding them exits.
+     */
+    readonly flowScope?: number;
     /**
      * D44 rule 71: true while the active narrowing was established by an
      * assignment (or a declaration initializer) rather than a check. Only
@@ -42,6 +48,8 @@ interface AnalyzableFunctionDeclaration {
     readonly body: FunctionDeclaration["body"];
     readonly span: Span;
     readonly asynchronous?: boolean;
+    readonly exported?: boolean;
+    readonly private?: boolean;
 }
 export interface ClassField {
     readonly mutable: boolean;
@@ -58,6 +66,14 @@ export interface ClassInfo {
      * than composes.
      */
     readonly iterate?: ValueType;
+    /**
+     * D90 R18: the element the class's asynchronous `@iterate:` form answers
+     * with. The block is the declared spelling of the pull contract `async for`
+     * consumes — pulled once per element, it may await, it answers `T?`, and
+     * null is exhaustion. A class declares one form or the other; the answer's
+     * shape (a collection against `T?`) is what tells them apart.
+     */
+    readonly iterateAsync?: ValueType;
     readonly parameters: readonly ValueType[];
     readonly parameterNames?: readonly string[];
     readonly requiredParameters: number;
@@ -206,6 +222,18 @@ export interface LoweringHints {
      * returns and every consumer keeps the lowering it already had.
      */
     readonly iterationContracts: ReadonlySet<string>;
+    /**
+     * D90 R18: start offsets of `async for` statements whose source's class
+     * declares the asynchronous `@iterate:` form. The emitter pulls these
+     * through the declared member instead of capturing a structural `next`.
+     */
+    readonly asyncIterationStatements: ReadonlySet<number>;
+    /**
+     * D90 R18: span identities of the `@iterate:` blocks that are the
+     * asynchronous pull form, keyed by their keyword span, so the emitter lands
+     * each one as an async method under its own key.
+     */
+    readonly asyncIterateBlocks: ReadonlySet<string>;
     /**
      * Span identities of JavaScript-boundary calls in synchronous
      * module-initialization position. A non-Error value thrown there would
@@ -275,6 +303,14 @@ export declare const disposeMemberKey = "__velar:dispose";
  * member can answer it by accident and no author call can reach it.
  */
 export declare const iterateMemberKey = "__velar:iterate";
+/**
+ * The emitted member behind the asynchronous `@iterate:` form (D90 R18). It is
+ * a separate key because the two forms answer different questions — the
+ * synchronous member returns the finished collection once, this one is an
+ * async method `async for` pulls once per element — so no lowering can confuse
+ * one for the other.
+ */
+export declare const iterateAsyncMemberKey = "__velar:iterateAsync";
 /** How a `using` binding releases its value at scope exit. */
 export interface DisposalContract {
     readonly member: string;
@@ -293,8 +329,22 @@ export declare function permanentNamespaceCoveringModule(source: string, exports
 export declare function isCorePrimitiveName(name: string): boolean;
 export declare class Analyzer implements TypeEnvironment {
     protected readonly diagnostics: Diagnostic[];
+    protected readonly advisories: Advisory[];
+    private readonly advisedIdentities;
     private readonly scopes;
     private readonly memberNarrowings;
+    /** Per scope depth, the names a narrowing has written there; see `narrowingsForVisibleBindings`. */
+    private readonly narrowedNames;
+    /** How many loop back-edge passes are running; see `reanalyzeLoopBackEdge`. */
+    private loopReanalysisDepth;
+    /** The "did you mean" roster, and the names each scope depth contributed to it. */
+    private readonly nearestNames;
+    private readonly scopedNames;
+    private nearestNamesSeeded;
+    /** Per scope depth, the bindings flow analysis has written; see `snapshotFlowFacts`. */
+    private readonly flowTouched;
+    /** What each of those held before its first write, or null for a shadow born mid-flow. */
+    private readonly flowOrigins;
     private readonly namedTypes;
     private readonly namedTypeReadonlyFields;
     private readonly namedTypeIdentities;
@@ -345,12 +395,10 @@ export declare class Analyzer implements TypeEnvironment {
     private readonly classDisposeChains;
     /** D68 rule 177: expression spans a consumer iterates through `@iterate:`. */
     private readonly iterationContracts;
-    /**
-     * D68 rule 177: the function depth of each `@iterate:` body being analyzed.
-     * A nested arrow inside the block is an ordinary callable and keeps the
-     * ordinary advice, so the contract's own message needs the exact depth.
-     */
-    private readonly iterateContractDepths;
+    /** D90 R18: `async for` statements pulling a declared asynchronous `@iterate:`. */
+    private readonly asyncIterationStatements;
+    /** D90 R18: `@iterate:` blocks that are the asynchronous pull form, by keyword span. */
+    private readonly asyncIterateBlocks;
     /** D51 rule 101: arrows that read a `using`-owned binding, by arrow span. */
     private readonly arrowOwnedCaptures;
     private readonly arrowCaptureFrames;
@@ -413,6 +461,22 @@ export declare class Analyzer implements TypeEnvironment {
     private readonly inferredFunctionResultSeeds;
     private readonly inferredFunctionResultTypes;
     private readonly finalizeFunctionResultInference;
+    /**
+     * D85 rule 209: one mistake is reported once. A reported VEL4039 hands its
+     * position `invalidType`, and an invalid body-inferred result is otherwise a
+     * convergence failure — so the four collections below carry the *reported*
+     * hole forward, and only that hole, to the place VEL4025 is decided.
+     * `reportedCollectionHoles` are the names bound to one, `reportedResultHoles`
+     * the local function results that are one, `functionResultKeys` maps a
+     * callable name to the result a call to it reaches, and
+     * `deferredConvergenceReports` holds the reports whose answer needs a callee
+     * that may be declared further down the module.
+     */
+    private readonly reportedCollectionHoles;
+    private readonly bindingHoleCauses;
+    private readonly reportedResultHoles;
+    private readonly functionResultKeys;
+    private readonly deferredConvergenceReports;
     private readonly logicalConditionNarrowings;
     private readonly privateFields;
     private readonly privateGetters;
@@ -438,8 +502,27 @@ export declare class Analyzer implements TypeEnvironment {
     /** Namespace import locals by name, known before signature validation runs (ENM-I9 teaching). */
     private readonly namespaceImportLocals;
     private readonly initializationImportReadSites;
+    /**
+     * D31 item 23's recorded residual: a top-level call of a module-local
+     * function runs that body during module evaluation, so a read of an imported
+     * binding inside it is an initialization-position read reached through one
+     * hop. The stack is the function frame a deferred read belongs to; the map
+     * is that frame by the name it was bound to, so a call resolves to it after
+     * the whole module is analyzed and hoisting order stops mattering.
+     */
+    private readonly deferredReadFrames;
+    private readonly localFunctionFrames;
+    private readonly arrowDeferredFrames;
+    private readonly initializationLocalCalls;
     /** Local class bindings mapped to the source offset where their `class` statement evaluates (CLS-D8). */
     private readonly hoistedClassDeclarations;
+    /**
+     * D90 R12: public class members whose omitted annotation inferred an output
+     * `any`. Whether the member is at an export position depends on whether a
+     * consumer can reach its class, which is not settled until the whole module
+     * is analyzed, so the report waits for reportExportPositionAny.
+     */
+    private readonly exportPositionCandidates;
     /** Module-scope names bound to runtime Type objects (local and imported); see LoweringHints.runtimeTypeObjectNames. */
     private readonly runtimeTypeObjectNames;
     private staticFieldInitialization;
@@ -474,11 +557,29 @@ export declare class Analyzer implements TypeEnvironment {
      * answer applies.
      */
     private guidanceForGlobal;
+    /**
+     * D90 (coherence): the one report an unresolved name earns, wherever it was
+     * written. A reserved global names the module that replaced it, a foreign
+     * builtin with no successor stops at the bare message rather than guessing,
+     * and everything else may carry the nearest visible name. Both unresolved-
+     * name sites reach this, because `exports = {run: run}` is the same mistake
+     * as `const value = exports` and used to earn a strictly worse answer for
+     * standing on the left of the `=`.
+     */
+    private reportUnresolvedName;
     private nearestVisibleBindingName;
+    /** Files a scope's name in the "did you mean" roster and takes it back out when the scope exits. */
+    private recordScopedName;
     private readonly modulePath;
     private readonly importBindings;
     private readonly dynamicImports;
     analyze(program: Program): readonly Diagnostic[];
+    /**
+     * D89: the advisories this analysis raised. `analyze` keeps returning the
+     * diagnostics alone, so the caller reads the two channels separately and the
+     * cursor arithmetic over `this.diagnostics` stays exact.
+     */
+    analyzedAdvisories(): readonly Advisory[];
     private registerExternTypeImports;
     private validateDataTypeDeclarations;
     private validateCoreDeclarationSignatures;
@@ -616,6 +717,21 @@ export declare class Analyzer implements TypeEnvironment {
     private registerClassNames;
     private registerClassShapes;
     protected analyzeStatement(statement: Statement): void;
+    /**
+     * D89 A2: the two-slot `for` over a List, Set, or string binds
+     * `value, index`, which matches JavaScript's `forEach((v, i) => …)` and
+     * inverts Python's `enumerate`. Python's own spelling is already a loud
+     * error, so nothing silent comes from it; the silence happens when a model
+     * writes `for i, v in nums`, a hybrid neither language has, and both names
+     * quietly hold the other one's value.
+     *
+     * Both rosters must hit. One name alone proves nothing — `for index, total
+     * in scores` may be counting exactly what it says — and a wrong guess here
+     * would tell a correct author to break working code. The value slot also
+     * accepts the singular of the collection's own name, because `for i, user
+     * in users` is the same reflex spelled from the data instead of a letter.
+     */
+    private adviseSwappedLoopSlots;
     private checkFloatingPromiseStatement;
     private checkDiscardedExpressionResult;
     private carriesPromise;
@@ -704,23 +820,44 @@ export declare class Analyzer implements TypeEnvironment {
      * result has and gets the same solution.
      */
     private seededIterationSource;
+    /**
+     * D90 R18: the seed routed to the field its form owns. An optional seed can
+     * only have come from the asynchronous pull form — the synchronous form
+     * never validates to `T?` — so the shape pre-pass reads the form off the
+     * seed the previous convergence pass learned.
+     */
+    private seededIterationInfo;
     /**
      * `@iterate:` answers the compiler's question "what does
-     * iterating you mean?" with a collection the language already iterates. It
-     * shares `@dispose:`'s compiler-name path, then supplies its own role: it is
-     * a contract, not a method, it produces a value, and it may not `await`,
-     * because every one of the eight consumers reads it synchronously.
+     * iterating you mean?". It shares `@dispose:`'s compiler-name path, then
+     * supplies its own role: it is a contract, not a method, and it produces a
+     * value. D90 R18 gives it two forms, told apart by the answer's shape the
+     * same way `@dispose:`'s async-ness is read off its own body: the
+     * synchronous form answers a collection the language already iterates and
+     * the eight plain consumers read it once; the asynchronous pull form
+     * answers `T?` — `async for` drives it once per element, it may await, and
+     * null is exhaustion.
      */
     private analyzeClassIterate;
     /**
-     * The four collections are the whole answer space: the block says "iterating
-     * me is iterating this", and the language already fixed what iterating a
-     * List, Set, Map, or Record means. Anything else would be a second iteration
-     * semantics, which is the thing charter section 19 keeps out.
+     * The answer space is the four collections plus `T?` (D90 R18): the
+     * synchronous form says "iterating me is iterating this", and the language
+     * already fixed what iterating a List, Set, Map, or Record means; the
+     * asynchronous pull form answers one element per pull, null for exhaustion.
+     * Anything else would be a second iteration semantics, which is the thing
+     * charter section 19 keeps out.
      */
     private validatedIterationSource;
     /** The `@iterate:` answer a class inherits, most derived ancestor first. */
     private inheritedIterationSource;
+    /** D90 R18: the asynchronous `@iterate:` element a class inherits, most derived ancestor first. */
+    private inheritedAsyncIterationSource;
+    /**
+     * D90 R18: what pulling this value under `async for` means. A class answers
+     * through the asynchronous `@iterate:` form — its own, or the one it
+     * inherits, mirroring the synchronous contract exactly.
+     */
+    private asyncIterationContract;
     /**
      * D68 rule 177: what iterating this value means. A class answers through
      * `@iterate:` — its own, or the one it inherits, because overriding replaces
@@ -782,6 +919,15 @@ export declare class Analyzer implements TypeEnvironment {
      */
     private inferredNullResultAnnotation;
     private reportInferredNullResult;
+    /**
+     * D89 (message correction): the one report a `self` parameter earns, and the
+     * deletion it names. The removed range reaches to the next parameter's start
+     * (or back to the previous one's end), so the separating comma and its
+     * whitespace come with it without reading the source text — the rewrite is a
+     * spelling change with no judgment in it, which is what D38 §48 requires of
+     * a registered fix.
+     */
+    private reportImplicitSelfParameter;
     protected analyzeFunctionDeclaration(statement: AnalyzableFunctionDeclaration, className: string | null, method?: boolean, declareSelf?: boolean, forceAsynchronous?: boolean, declarationKind?: string): void;
     /**
      * A target-owned declaration may use an ordinary default expression as a
@@ -814,14 +960,57 @@ export declare class Analyzer implements TypeEnvironment {
     private containsCoreDuration;
     private inferCoreDurationExpression;
     private inferBinary;
+    /**
+     * D89 A3: `%` follows JavaScript and keeps the dividend's sign, so `-7 % 3`
+     * is `-1` where Python answers `2`. Nothing here reports an error — both
+     * languages accept the spelling, they just disagree about the result.
+     *
+     * Only a literal negative dividend triggers. A variable's sign is not
+     * knowable, and advising every `%` whose left side might go negative would
+     * be the noise the tier exists to avoid. The shape matched is a unary minus
+     * wrapping a numeric literal, because that is what `-7` parses as; there is
+     * no negative-valued literal for a value test to find.
+     *
+     * The admission bar is "Vel accepts the spelling as a different meaning", so
+     * every shape whose two answers are the same is silent rather than advised:
+     * a remainder of zero (`-6 % 3`) agrees, `% 0` answers NaN here and raises
+     * in Python so there is no Python answer to name, and a non-finite dividend
+     * answers NaN on both sides. A message that states a disagreement and then
+     * prints the same number twice is a new defect, not a weaker advisory.
+     */
+    private adviseNegativeLiteralModulo;
     private requireIntersectingEquality;
     private rejectFreshCollectionEquality;
     private freshCollectionOperand;
     private requireMembershipIntersection;
+    private rejectFreshCollectionProbe;
     private rejectDisjointEnumTest;
     /** The enum/null arms of a type, or null when any arm falls outside that domain. */
     private pureEnumDomainArms;
     private rejectDisjointEnumValidatorProbe;
+    /**
+     * D59 rule 141 settled that `toBe` *is* `==` ("toBe 必须用语言自己的 `==`")
+     * and rule 141.1 settled that `toContain` *is* `values.has(item)`. The
+     * runtime half of both landed; the compile-time half did not travel with
+     * them, so `expect([1]).toBe([1])` compiled and failed at run time with
+     * both operands rendering byte-identically, while `[1] == [1]` is refused
+     * where it is written. This runs the operator's own two gates on the
+     * matcher: D42 item 64's intersection requirement, and COL-I3's rejection
+     * of a freshly built literal in an identity comparison.
+     *
+     * `toBe` and `toEqual` deliberately part company on the fresh-literal gate.
+     * `toBe` asks the `==` question, where a new object can never be identical
+     * to anything, so the literal proves the answer. `toEqual` asks the
+     * `equals(a, b)` question, where a fresh literal is the normal and correct
+     * spelling of the expected value — rejecting it there would refuse the very
+     * repair the `toBe` message teaches. The intersection gate has no such
+     * split: two types with no values in common never deeply equal either.
+     *
+     * `toHaveLength` and `toMatch` are left alone. Neither takes a comparand:
+     * `toHaveLength` takes a count, and `toMatch` takes a regular-expression
+     * pattern whose relation to the subject is matching, not equality.
+     */
+    private checkTestMatcherComparand;
     private enumTargetOfValidatorObject;
     /** The enum behind a type alias name, or null when the alias does not resolve to an enum. */
     private aliasedEnumTarget;
@@ -960,6 +1149,21 @@ export declare class Analyzer implements TypeEnvironment {
     private narrowingSubjectExpression;
     /** The property name when an expression reads a getter rather than a stored field. */
     private getterAccessProperty;
+    /**
+     * D90 R17: the author's own spelling of a boundary value, for the
+     * diagnostics that teach `Type.parse`. Identifier and member paths render
+     * exactly, a simple call renders as `name(...)`, and anything else answers
+     * null so the caller falls back to the word `value`.
+     */
+    private boundaryReceiverText;
+    /** A type name suggested from the receiver's last name segment, or 'X' when none reads naturally. */
+    private boundaryTypeNameSuggestion;
+    /**
+     * D90 R17: an undeclared foreign value arrives as unknown, and the way into
+     * the typed world is `Type.parse` at the edge. Every refusal on an unknown
+     * teaches that ritual with the author's own expression spelled into it.
+     */
+    private boundaryValidationGuidance;
     private conditionSubjectText;
     protected requireAssignable(actual: ValueType, expected: ValueType, valueSpan: Span): void;
     /**
@@ -1058,10 +1262,32 @@ export declare class Analyzer implements TypeEnvironment {
      * carried whole so the author never sees a half-migrated module.
      */
     private reportPermanentNamespaceImports;
+    /**
+     * D50 rule 97.3: a retirement that leaves one surviving spelling did not
+     * happen. `export {stringify} from "velar/json"` is an import spelling with
+     * an export in front of it — the barrel republishes the retired bare name
+     * and every downstream `import {stringify} from "./barrel.vel"` is clean
+     * forever after. No mechanical fix: which reads in which other modules
+     * wanted the name is not a rewrite this module can make.
+     */
+    private reportPermanentNamespaceReExports;
     /** A member name to show in the rule 106 guidance, so the fix is concrete. */
     private firstNamespaceMember;
     protected typeError(message: string, errorSpan: Span, fix?: DiagnosticFix): void;
     protected recoveredTypeError(message: string, errorSpan: Span, fix?: DiagnosticFix): void;
+    /**
+     * D89: raises a roster advisory. It cannot reach `this.diagnostics`, so it
+     * cannot fail a build and cannot shift the diagnostic cursors this analyzer
+     * reads as array lengths.
+     *
+     * One report per code and span. `reanalyzeLoopBackEdge` runs a loop body a
+     * second time whenever the back edge invalidates a fact, and its diagnostic
+     * answer is `deduplicateDiagnostics`, which only ever touches
+     * `this.diagnostics`. Deduplicating where the advisory is raised covers that
+     * pass and every other re-analysis without a second pair of cursors, which
+     * is the whole reason the two channels are separate arrays.
+     */
+    protected advise(code: string, message: string, adviceSpan: Span, fix?: DiagnosticFix): void;
     private analyzeMatchPattern;
     private matchLocationNarrowing;
     private retargetNarrowings;
@@ -1100,17 +1326,93 @@ export declare class Analyzer implements TypeEnvironment {
      * constructor's own arguments. Nothing infers it from a later mutation, so a
      * binding left with no source is reported at the construction rather than
      * kept as `unknown` for a following line to fill in.
+     *
+     * The value written at this position is not always the construction itself.
+     * A ternary arm, a list element or its spread, a record-literal field, a
+     * `??` fallback, a receiver and an argument all become part of the value the
+     * name holds, so each is its own settling position and each reports at its
+     * own `[]`. What stops the walk is the value, not the syntax: it descends
+     * only while `carriesUnsettledCollection` still sees the hole in the type
+     * arriving here, so `print(Set().size)` and `const n = Set().size` stay
+     * legal per rule 208 — neither of those names holds a collection — while a
+     * spread whose `unknown` the merge absorbs (`["x", ...[]]`) leaves nothing
+     * to report. A sibling settles nothing for its neighbour: `[["a"], []]`
+     * merges through `unionOf`, so the union still carries the hole and the
+     * empty `[]` reports on its own.
+     *
+     * Returns whether it reported, so the caller can hand the name `invalidType`
+     * instead of the hole. Rule 209 requires one mistake to be reported once,
+     * and `List<unknown>` reaching a later line is what produces the second,
+     * contradicting report the ruling exists to delete.
+     */
+    protected requireSettledCollectionElement(initializer: Expression, declared: ValueType, annotated: boolean): boolean;
+    /**
+     * D85 rule 209: where the value at this position came from, when it came
+     * from a hole VEL4039 already reported. The answer is two-part because a
+     * callee can be declared after its caller: `true` is a hole already on
+     * record, and `causes` are the local results that make this position a hole
+     * too if theirs turn out to be one.
+     *
+     * Only a name and a call to a local name are modelled — the two shapes an
+     * author writes between an empty collection and the `return` that publishes
+     * it. Anything else contributes nothing, so an unmodelled position keeps the
+     * report it has today rather than losing one.
+     */
+    private collectResultHoleSources;
+    /**
+     * D85 rule 209: a name bound to a reported hole carries it, so `const a = []`
+     * followed by `return a` is the same one mistake `return []` is. Only an
+     * unannotated `const`/`let` of a single name carries anything: an annotation
+     * settles the construction, and a destructuring pattern takes the hole apart
+     * rather than passing it on.
+     */
+    private recordBindingHoleSource;
+    /**
+     * D85 rule 209: delete the convergence report of every function whose result
+     * is invalid only because a hole VEL4039 already explained reached it through
+     * a local call. The set grows until it stops growing, because a chain of
+     * forwarding functions is still one mistake however long it is — and a cycle
+     * with no empty collection anywhere in it never enters the set, so a genuine
+     * convergence failure still reports on both of its halves.
      */
-    protected requireSettledCollectionElement(initializer: Expression, declared: ValueType, annotated: boolean): void;
+    private resolveDeferredConvergenceReports;
+    private reportUnsettledCollection;
     private isFreshUnresolvedCollection;
     protected declareBinding(name: string, mutable: boolean, type: ValueType, declarationSpan: Span, internal?: boolean, declaredType?: ValueType, importSource?: string): void;
     private recordImportedBindingSource;
     private recordImportedBindingOrigin;
     private recordInitializationImportRead;
+    /**
+     * D31 item 23: the call edge. Inside a deferred body it is an edge of the
+     * reachability graph; at module top level it is a root, because that call
+     * runs the callee while the module itself evaluates. The callee is held as
+     * a binding, not as a frame — a `def` is hoisted, so `const x = pull()` can
+     * be analyzed before `def pull()` is.
+     */
+    private recordDeferredCallEdge;
+    /** Files an arrow's deferred frame under the module-local name it was bound to. */
+    private claimArrowDeferredFrame;
     /** True while analysis is directly in a declaration body rather than a function frame. */
     protected inComponentSetupPosition(): boolean;
     protected inModuleInitializationPosition(): boolean;
-    /** Initialization-position reads of imported bindings, for the project module-cycle check. */
+    /**
+     * Initialization-position reads of imported bindings, for the project
+     * module-cycle check.
+     *
+     * D31 item 23 recorded the indirect shape as a v1 residual: a top-level call
+     * of a module-local function runs that body while the module evaluates, so
+     * an imported binding read inside it is an initialization-position read too
+     * — and following VEL3019's own remediation ("Move this read into a
+     * function") and then calling that function at top level re-created the bare
+     * `ReferenceError` the check exists to delete. The closure below is the
+     * intra-module reachability pass that closes it: one module, one walk over
+     * the call edges already collected, no cross-module analysis.
+     *
+     * An indirect read is reported at the *call*, not at the read. The call is
+     * the line that runs during module evaluation and the line an author can
+     * move; the read inside the body is already in a function, which is what the
+     * remediation asks for.
+     */
     moduleInitializationImportReads(): readonly InitializationImportRead[];
     private requireTextConvertible;
     private isTextConvertible;
@@ -1131,6 +1433,47 @@ export declare class Analyzer implements TypeEnvironment {
     private runtimeTypeObjectValue;
     private displayExternalClasses;
     protected prescanScopeDeclarations(statements: readonly Statement[]): void;
+    /**
+     * D90 R12: "exported" is a property of the declaration a consumer can reach,
+     * not of the `def` keyword. A module-level declaration carries the flag
+     * itself and is judged here and now. A class member carries none — a public
+     * member of a class this module publishes is read by a consumer exactly as
+     * an exported `const` is — but whether the class is published is a question
+     * about the whole module, so the member waits for reportExportPositionAny. A
+     * `private` member is never reachable, and R12's boundary does not move:
+     * module-internal `any` stays legal.
+     */
+    private recordExportedAny;
+    /**
+     * D90 R12: the class members that turned out to be at an export position.
+     * Reported once the module is analyzed, because the answer is reachability
+     * and reachability is a property of the module, not of the declaration.
+     */
+    private reportExportPositionAny;
+    /**
+     * D90 R12: which class declarations a consuming module can reach. Exported
+     * classes seed the set; from there it follows every position a consumer can
+     * read a value *out of* — the type of anything else this module exports, the
+     * base a reachable class names, and the public surface of a class already
+     * reachable. `export class Box extends Base:` publishes `Base`'s members,
+     * and `def make() -> Inner` publishes `Inner`'s, whether or not either name
+     * is exported.
+     *
+     * Input positions are deliberately absent, for the same reason
+     * `typeContainsAnyOutput` omits them: a consumer that has to *supply* an
+     * instance obtained it from an output position first, and that position is
+     * what makes the class reachable.
+     */
+    private exportReachableClasses;
+    /**
+     * D90 R12: the diagnostic has to teach the way out, not only refuse. A
+     * consuming module never writes `unsafe`, so an exported `any` hands it a
+     * value carrying no guarantee at all; the escape is to validate the value
+     * into a declared type in the module that owns the boundary, which is what
+     * `Type.parse` exists for. No new diagnostic code and no unsafe marker: this
+     * is the rule at validateTypeReference finished, not a second rule.
+     */
+    private reportExportedAny;
     private collectPatternNames;
     private checkShadowedRead;
     private declarePattern;
@@ -1171,10 +1514,44 @@ export declare class Analyzer implements TypeEnvironment {
     private memberNarrowingRootType;
     private runtimeCheckedType;
     private matchPatternReflectionMayExecute;
+    /**
+     * A snapshot used to copy every binding of every live scope, which made a
+     * branch cost O(names in the module) and whole-module analysis quadratic in
+     * module size. A binding nothing ever narrows cannot differ between two
+     * moments, so only the bindings flow analysis has actually written are
+     * visited — `flowTouched`, kept per scope depth so an exiting scope drops
+     * its own, and `flowOrigins`, which remembers what each one held before its
+     * first write. `flowOrigins` answers for a binding a *later* write touched
+     * than the snapshot being restored: the snapshot has no entry, and its
+     * pre-write state is exactly the state that snapshot recorded. A narrowing
+     * shadow born after the snapshot stores `null` instead, because a full-scope
+     * snapshot had nothing to restore it to either.
+     */
+    private flowFactState;
+    /** Called immediately before flow analysis writes a binding, so the recorded state is the pre-write one. */
+    private recordFlowFactOrigin;
+    /** A narrowing shadow created mid-flow: no older snapshot has a state for it. */
+    private trackNarrowingShadow;
+    private trackFlowBinding;
+    /** Every binding whose flow facts may differ from another moment's, outermost scope first. */
+    private touchedFlowBindings;
+    /** The state `snapshot` recorded for `binding`, or null when it did not exist yet. */
+    private flowStateIn;
     private snapshotFlowFacts;
     private restoreFlowFacts;
     private analyzeIsolatedFlow;
     private flowInvalidationsSince;
+    /**
+     * A loop's back-edge pass re-runs the whole body, and a nested loop inside
+     * that pass runs its own, so the work doubled with every level of loop
+     * nesting: fourteen levels of `while` in a 91-line file took 2.4 seconds and
+     * seventeen took 35. The passes are budgeted by how many back-edge passes
+     * are already running. Past the budget a loop analyzes its body once and its
+     * exit keeps nothing — `widened` — which is what the loop would answer if
+     * its back edge had falsified every fact, so the degradation only ever
+     * removes a fact, never invents one. Real code does not nest loops four
+     * deep, so nothing reachable by hand reaches the budget.
+     */
     private reanalyzeLoopBackEdge;
     private flowInvalidationsAffectFacts;
     private deduplicateDiagnostics;
@@ -1182,7 +1559,18 @@ export declare class Analyzer implements TypeEnvironment {
     private clearCachedFlowTypesInSpan;
     private flowSnapshotAfterInvalidations;
     private visibleBindings;
+    /** The binding a name resolved to when `visible` was captured. */
+    private visibleBinding;
+    /**
+     * Only a name a narrowing has written can carry a fact, and `narrowedNames`
+     * is the roster of those per scope — so this walks the narrowings rather
+     * than every name in scope. The member half matches a dotted path against
+     * the binding its root names instead of spreading the whole root set per
+     * path, which is O(one lookup) rather than O(names in the module).
+     */
     private narrowingsForVisibleBindings;
+    /** Whether a member path's root — `<declaration offset>:<name>` — names a binding visible then. */
+    private memberNarrowingRootIsVisible;
     private narrowingsInSnapshot;
     private commonNarrowings;
     /**