compiler 0.0.2-preview.1
The Zena self-hosted compiler
compiler#
The Zena compiler, written in Zena. It parses, type-checks, and compiles Zena source code to WebAssembly (Wasm GC) and WebAssembly Text (WAT).
Usage#
Parsing a Single File#
Use compiler/parser to parse Zena source text into an AST (Module):
import { parse } from 'compiler/parser';
let ast = parse('export let answer = 42;', 'example.zena');
Loading and Checking a Program#
Use compiler (createCompiler and checkCompilation) with a CompilerHost to resolve imports across a module graph and type-check a program:
import {
createCompiler, checkCompilation, buildStdlibConfig
} from 'compiler';
import { FsCompilerHost } from 'compiler/fs-host';
let stdlibRoot = '/stdlib';
let host = new FsCompilerHost(stdlibRoot);
let packages = buildStdlibConfig(stdlibRoot, 'host');
let compiler = createCompiler(host, {
stdlibRoot,
packages,
});
let result = await compiler.compile({
entry: '/workspace/main.zena',
target: 'host',
});
let checked = checkCompilation(result);
Compiling a File to WebAssembly#
Use compiler/compile-file to compile an entry file on disk to a .wasm or .wat output file:
import { compileFile } from 'compiler/compile-file';
let ok = await compileFile({
entry: 'src/main.zena',
outPath: 'out/main.wasm',
stdlibRoot: '/stdlib',
});
Libraries#
compiler/compiler/compiler— compiler entry point (Compiler,createCompiler,checkCompilation,ProgramCheckResult)compiler/compile-file— end-to-end file compilation (compileFile,CompileFileOptions)compiler/tokenizer— lexer and token definitions (tokenize,Token,TokenType)compiler/parser— recursive-descent parser (parse,Parser)compiler/ast— AST node definitions (Node,Module,Statement,Expression,TypeAnnotation)compiler/visitor— AST traversal helpers (walk,Visitor)compiler/scope— lexical scope and symbol resolution (ScopeBuilder,ScopeResult,Symbol)compiler/checker— static type checker (checkModule,CheckResult)compiler/semantic-model— semantic queries over a checked module (SemanticModel)compiler/types— compiler type representations (Type,ClassType,FunctionType,typeToString)compiler/diagnostics— compiler diagnostics and source spans (Diagnostic,DiagnosticCode,DiagnosticSeverity,SourceSpan)compiler/package-manifest—zena-package.jsonmanifest and workspace loader (loadWorkspace,loadPackageMap)compiler/module-resolver— package and relative module specifier resolution (ModuleResolver,PackageConfig)compiler/library-loader— module graph loader (LibraryLoader,CompilerHost,SourceFile)compiler/codegen/binary-generator— WebAssembly GC binary emitter (BinaryGenerator)compiler/codegen/wat-generator— WebAssembly Text (WAT) emitter (WatGenerator)
License#
MIT
54.1 KiB
Raw
/**
* Semantic Model for the Zena compiler.
*
* The SemanticModel is a single query surface for all semantic
* information about a module. It combines:
*
* 1. Node types — the inferred type for any AST node (expression,
* declaration pattern, parameter, etc.).
* 2. Binding types — the type carried by a named binding, keyed by
* Symbol.id so each destructured name gets its own entry.
* 3. Name resolution — delegates to the ReferenceMap from scope
* analysis to find the Symbol for any identifier reference.
* 4. Diagnostics collected during type checking.
*
* Two kinds of "type" live here, both accessible via getNodeType():
*
* - **Binding type**: Stored on a declaration node (IdentifierPattern,
* Parameter, ClassDeclaration). This is the type the name carries —
* either from an explicit annotation or inferred from the initializer.
* Query: `getNodeType(symbolInfo.declaration)`.
*
* - **Expression type**: Stored on an expression node (NumberLiteral,
* BinaryExpression, Identifier, etc.). This is the fully resolved
* type at that use site, including control-flow narrowing.
* Query: `getNodeType(someExpr)`.
*
* These share the same map keyed by source offset, since declaration
* nodes and expression nodes have disjoint offsets. There is no separate
* "declared vs inferred" API — the AST's TypeAnnotation tells you
* whether the type was explicit; the SemanticModel just gives you the
* resolved result.
*
* A future global analysis pass (e.g., monomorphization) would produce
* its own result, not overwrite this model. No third type level is
* needed for single-module checking.
*/
import { Set, HashMap, HashSet } from 'zena:collections';
import { IterableUtils } from 'zena:core';
import {
Type, ClassType, InterfaceType, FunctionType, RecordType, TupleType, UnionType, TypeId,
} from './types.zena';
import { Diagnostic } from './diagnostics.zena';
import {
Node, NodeId, Expression, ClassDeclaration, InterfaceDeclaration, MixinDeclaration, EnumDeclaration, IdGenerator, syntacticMemberName, MemberExpression, getMemberPropertyName,
} from './ast.zena';
import { Symbol, SymbolId } from './scope/symbol.zena';
import { SymbolMap } from './scope/scope-builder.zena';
import { NodeMap, DenseNodeMap } from './node-map.zena';
/**
* The key a member is registered under: the plain name for a name-keyed
* member, and for a symbol-keyed one the key the checker recorded, which
* carries the symbol's identity so two same-named symbols key two
* different members.
*
* Every pass that looks a member up goes through here. Falling back to
* the spelling keeps a member whose symbol failed to resolve consistent
* between passes; that failure is already reported at its declaration.
*/
export function memberKeyOf(model: SemanticModel, nameNode: Node): String {
let recorded = model.memberKey(nameNode);
if (recorded != null) {
return recorded as String;
}
return syntacticMemberName(nameNode);
}
/**
* The key a symbol-keyed ACCESS looks its member up by.
*
* The checker records it on the access node, because `x.[Reader.act]()`
* and `x.[Writer.act]()` differ only in the symbol the path resolves to
* and nothing downstream can resolve one. A name-keyed access is its
* property name, as it has always been.
*/
export function accessKeyOf(model: SemanticModel, expr: MemberExpression): String {
let recorded = model.memberKey(expr as Node);
if (recorded != null) {
return recorded as String;
}
return getMemberPropertyName(expr.isSymbolAccess, expr.property.name);
}
export type SemanticModelProgramUnit = {
path: String,
model: SemanticModel,
};
/**
* Which model owns each node and each binding.
*
* A model answers questions about its own file; a query about a node
* from another file — cross-module inlining, a generic instantiated
* from elsewhere — needs to find the model that owns it, and this is
* that map.
*
* It belongs to the *check*, not to a compile. Every `Program` built
* over the same `CheckResult`s would compute exactly the same index,
* so building it per compile made each compile walk every node in the
* program (which the execution suite then paid 465 times over), and
* left `Program` writing a back-pointer into `SemanticModel`s it
* shares with every other compile in the batch. `SharedCheckerState`
* holds one of these for exactly as long as the models it indexes
* live, and a model is registered once, when its check finishes.
*/
/** One registered model and the node-id range its module was parsed into. */
final class ModelRange {
first: i32;
last: i32;
model: SemanticModel;
/**
* Whether `model` still speaks for its file. `register` clears it
* when the file gets a newer model with a different range, so a
* lookup that lands here need not consult `currentByPath`.
*/
var current = true;
new(this.first, this.last, this.model);
}
export final class ModelIndex {
/**
* Which model owns a node, by range. A module's nodes are the
* contiguous ids `[Module.id, Module.lastNodeId]`, so the whole
* index for a parsed node is one entry per module and a binary
* search — where it used to be one map entry per node, 561K of them
* at ~37 bytes for a large compile (issue #199). Kept sorted by
* `first`; a re-registration of the same module replaces its entry.
*/
#ranges = new GrowableArray<ModelRange>();
/**
* Nodes minted after parsing — by the scope builder or the checker —
* fall outside every module's range and are recorded one by one, as
* before. A few thousand in a large compile.
*/
#nodeToModel = new Map<NodeId, SemanticModel>();
symbolToModel = new Map<SymbolId, SemanticModel>();
/** How many nodes are indexed individually rather than by range. */
overflowCount: i32 {
get { return this.#nodeToModel.size; }
}
/** How many module ranges are registered. */
rangeCount: i32 {
get { return this.#ranges.length; }
}
/**
* The model that currently speaks for each file.
*
* A cycle-driven re-check (`checkCompilation`'s second pass) replaces
* a file's model, and the superseded one must stop answering: its
* types were inferred before the back edge resolved, which is the
* whole reason for the second pass. Re-registering the replacement
* overwrites its claims node by node, but a node the first pass
* typed and the second did not would otherwise be left pointing at
* the dead model — so ownership is checked against this rather than
* assumed from the map. Missing is the right answer there; a
* superseded type is not.
*/
currentByPath = new Map<String, SemanticModel>();
/** The live model owning `id`, or null if nothing current owns it. */
ownerOfNode(id: NodeId): SemanticModel | null {
let ranges = this.#ranges;
let n = id as i32;
var lo = 0;
var hi = ranges.length - 1;
while (lo <= hi) {
let mid = lo + (((hi - lo) / 2) as i32);
let range = ranges[mid];
if (n < range.first) {
hi = mid - 1;
} else if (n > range.last) {
lo = mid + 1;
} else {
return if (range.current) range.model else null;
}
}
if (let (true, m) = this.#nodeToModel.get(id)) {
return this.#ifCurrent(m);
}
return null;
}
/**
* Records `model` as the owner of its module's id range, in sorted
* position, replacing the entry of an earlier check of the same
* module.
*/
#addRange(model: SemanticModel): void {
let first = model.firstNodeId as i32;
let last = model.lastNodeId as i32;
if (last < first) { return; }
let ranges = this.#ranges;
var i = 0;
while (i < ranges.length && ranges[i].first < first) {
i += 1;
}
if (i < ranges.length && ranges[i].first == first) {
ranges[i] = new ModelRange(first, last, model);
return;
}
ranges.push(new ModelRange(first, last, model));
var j = ranges.length - 1;
while (j > i) {
ranges[j] = ranges[j - 1];
j -= 1;
}
ranges[i] = new ModelRange(first, last, model);
}
/** Claims `id` for `model` unless the model's range already does. */
#claim(model: SemanticModel, id: NodeId): void {
let n = id as i32;
if (n >= (model.firstNodeId as i32) && n <= (model.lastNodeId as i32)) {
return;
}
this.#nodeToModel[id] = model;
}
/** The live model owning the binding `id`, or null. */
ownerOfBinding(id: SymbolId): SemanticModel | null {
if (let (true, m) = this.symbolToModel.get(id)) {
return this.#ifCurrent(m);
}
return null;
}
#ifCurrent(m: SemanticModel): SemanticModel | null {
if (let (true, current) = this.currentByPath.get(m.sourcePath)) {
if (current != m) {
return null;
}
}
return m;
}
/**
* Claims every node and binding `model` knows about, and makes it the
* model for its file. Nodes are keyed by the AST, which the parse
* cache keeps stable across checks, so a re-check's claims land on
* the same keys and the latest check wins.
*/
register(model: SemanticModel): void {
if (let (true, previous) = this.currentByPath.get(model.sourcePath)) {
if (previous != model) {
for (let range in this.#ranges) {
if (range.model == previous) {
range.current = false;
}
}
}
}
this.currentByPath[model.sourcePath] = model;
this.#addRange(model);
// The range answers for every parsed node; what is left to record
// is the nodes minted later, which each table holds outside its
// module's range.
for (let k in model.nodeTypes.overflowKeys()) { this.#claim(model, k); }
for (let k in model.parents.overflowKeys()) { this.#claim(model, k); }
let raKeys = model.recordAdaptations.map.keys();
for (let k in raKeys) { this.#claim(model, k); }
let ruKeys = model.recordUnionAdaptations.map.keys();
for (let k in ruKeys) { this.#claim(model, k); }
let iaKeys = model.interfaceAdaptations.map.keys();
for (let k in iaKeys) { this.#claim(model, k); }
let baKeys = model.boxAdaptations.map.keys();
for (let k in baKeys) { this.#claim(model, k); }
let faKeys = model.functionAdaptations.map.keys();
for (let k in faKeys) { this.#claim(model, k); }
let ucKeys = model.unionCallCalleeTypes.map.keys();
for (let k in ucKeys) { this.#claim(model, k); }
let acKeys = model.originalArgCounts.map.keys();
for (let k in acKeys) { this.#claim(model, k); }
let doKeys = model.defaultArgsOwners.map.keys();
for (let k in doKeys) { this.#claim(model, k); }
let dpKeys = model.defaultArgParamNames.map.keys();
for (let k in dpKeys) { this.#claim(model, k); }
let saKeys = model.staticAccesses.map.keys();
for (let k in saKeys) { this.#claim(model, k); }
let mkKeys = model.memberKeys.map.keys();
for (let k in mkKeys) { this.#claim(model, k); }
let sdKeys = model.scopeExitDrops.map.keys();
for (let k in sdKeys) { this.#claim(model, k); }
let edKeys = model.edgeDrops.map.keys();
for (let k in edKeys) { this.#claim(model, k); }
let xdKeys = model.exitDrops.map.keys();
for (let k in xdKeys) { this.#claim(model, k); }
let odKeys = model.ownDropIntervals.map.keys();
for (let k in odKeys) { this.#claim(model, k); }
let arKeys = model.assignmentReleases.map.keys();
for (let k in arKeys) { this.#claim(model, k); }
let mfKeys = model.movedOutFields.map.keys();
for (let k in mfKeys) { this.#claim(model, k); }
let ftKeys = model.fieldTakes.map.keys();
for (let k in ftKeys) { this.#claim(model, k); }
let sfKeys = model.scopedFieldStores.map.keys();
for (let k in sfKeys) { this.#claim(model, k); }
let rsKeys = model.revivingStores.map.keys();
for (let k in rsKeys) { this.#claim(model, k); }
let symbols = model.symbols;
if (symbols != null) {
// Only the nodes outside the module's range need claiming; the
// range itself is the model's by construction.
for (let k in symbols.byNode.overflowKeys()) { this.#claim(model, k); }
}
let btKeys = model.bindingTypes.keys();
for (let k in btKeys) { this.symbolToModel[k] = model; }
}
}
/**
* One compensating drop at a branch join: release `symbolId` at the end
* of one arm, because another arm moved it. On an `if` (armIndex -1)
* `onTrueArm` names the side; on a `match`, armIndex is the case index
* and `onTrueArm` is unused.
*/
export final class EdgeDrop {
symbolId: SymbolId;
onTrueArm: boolean;
var armIndex: i32 = -1;
new(this.symbolId, this.onTrueArm);
}
export final class RecordAdaptation {
source: RecordType;
target: RecordType;
new(this.source, this.target);
}
/**
* A use that reads a union of record types by one record shape. The
* value is one of `members` at run time, each with its own layout, so
* the repack that `RecordAdaptation` does for a known source shape has
* to pick the member first — codegen tests the value against each
* member's fat pointer type and repacks that member to `target`.
*/
export final class RecordUnionAdaptation {
members: GrowableArray<RecordType>;
target: RecordType;
/**
* The adapted expression can be null (`{a} | {a, b} | null` flowing
* into `{a} | null`), so null branches around the member chain
* instead of matching no member and trapping.
*/
sourceNullable: boolean;
new(this.members, this.target, this.sourceNullable = false);
}
export final class InterfaceAdaptation {
source: Type;
target: InterfaceType;
/**
* The adapted expression can be null (`C | null` flowing into
* `I | null`), so the pack runs under a null guard and null passes
* through as a null fat pointer.
*/
sourceNullable: boolean;
new(this.source, this.target, this.sourceNullable = false);
}
export final class FunctionAdaptation {
source: FunctionType;
target: FunctionType;
new(this.source, this.target);
}
/**
* The bodies of a module that are checked when something reaches
* them, rather than when the module is checked. The checker implements
* this; reachability calls it from its walk, through the model, so that
* neither pass has to import the other.
*
* Both calls are no-ops for a body that has already been checked, and
* for an id that names nothing this module defers.
*/
export interface DeferredBodies {
/** Check the top-level declaration that binds `symId`. */
checkGlobalBody(symId: SymbolId): void;
/**
* Check the body `nodeId` belongs to: the class member it names, or
* the top-level `let` or `function` whose arrow it is.
*/
checkBodyOfNode(nodeId: i32): void;
}
/**
* An expression that must not change anything a caller can see: the
* condition of a `static` clause, or the argument of `old`
* (docs/design/pure-functions.md). The checker records one where it
* meets the expression, and `checkCompilation` settles them when every
* module is checked, since the answer depends on the bodies of what
* the expression calls.
*/
export final class PurityObligation(
expression: Expression,
/** What the expression is, to begin the error with: "A 'static requires' condition". */
subject: String,
/** Whether the expression may name `result`. */
inEnsures: boolean
)
export final class SemanticModel {
var typeIdGenerator: IdGenerator<TypeId> | null = null;
/** The expressions of this module that must be free of effects. */
purityObligations = new Array<PurityObligation>();
/** Records `obligation`, once however often its expression is checked. */
addPurityObligation(obligation: PurityObligation): void {
for (let recorded in this.purityObligations) {
if (recorded.expression === obligation.expression) { return; }
}
this.purityObligations.push(obligation);
}
/**
* Set on a module whose bodies wait for something to reach them: a
* dependency, outside the local project. Null on a module checked in
* full, which is every module of the local project and every module
* at all when the whole compilation is checked eagerly.
*/
var deferredBodies: DeferredBodies | null = null;
/**
* The index that can name the owner of a node this model does not
* own. Set once, when this model's check finishes; never by a
* compile, which is why two compiles over these models cannot fight
* over it.
*/
var index: ModelIndex | null = null;
var sourcePath: String = "";
/**
* Map from node.id → inferred Type.
* Used for both expression types and declaration/binding types.
*/
/**
* Dense over the module's node ids once `setNodeRange` has run (the
* checker calls it as soon as it has the AST); anything stored
* before that lands in the table's overflow map and is moved.
*/
#nodeTypes = new DenseNodeMap<Type>(0 as NodeId, -1 as NodeId);
/** The node-id range of this model's module; see `Module.lastNodeId`. */
var firstNodeId: NodeId = 0 as NodeId;
var lastNodeId: NodeId = -1 as NodeId;
/**
* Tells the model which ids its module's nodes have, so the per-node
* tables can be arrays over that range rather than hash maps.
*/
setNodeRange(first: NodeId, last: NodeId): void {
this.firstNodeId = first;
this.lastNodeId = last;
this.#nodeTypes.reserve(first, last);
this.#parents.reserve(first, last);
}
/**
* The record types this module converts to a slot that does not know
* the record's shape (`anyref`, a union with other kinds of value),
* and the record types in their fields. Only these reach the erased
* `==`, so only these need its field-by-field comparison
* (ir/equality.zena, `lowerErasedEqDispatch`).
*/
erasedRecordTypes = new Array<RecordType>();
/**
* Where this module uses a tuple of one type as a tuple of another,
* element by element (`(Bird, i32)` as `(Animal, i32)`), outermost and
* nested. Codegen joins each pair's representation, so the widening
* copies nothing (#1137, codegen/wasm-module.zena `getTupleStruct`).
*/
tupleWidenings = new Array<TupleWidening>();
/**
* The tuple types this module converts to a slot that does not know
* the tuple's type (`anyref`, a type parameter's erasure, an interface,
* a union with other kinds of value), and those an `is` or `as` tests
* or casts to from such a slot. Codegen joins each tested type with the
* erased ones of its family, which a value can reach it from (#1181).
*/
erasedTupleTypes = new Array<TupleType>();
testedTupleTypes = new Array<TupleType>();
/**
* Map from node.id → RecordAdaptation for implicit fat pointer adaptation.
*/
#recordAdaptations = new NodeMap<RecordAdaptation>();
setRecordAdaptation(node: Node, source: RecordType, target: RecordType): void {
this.#recordAdaptations[node] = new RecordAdaptation(source, target);
}
getRecordAdaptationDirect(node: Node): RecordAdaptation | null {
if (let (true, t) = this.#recordAdaptations.get(node)) {
return t;
}
return null;
}
getRecordAdaptation(node: Node): RecordAdaptation | null {
let t = this.getRecordAdaptationDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getRecordAdaptationDirect(node);
}
}
return null;
}
/**
* Map from node.id → RecordUnionAdaptation, for a use that reads a
* union of record types by one record shape.
*/
#recordUnionAdaptations = new NodeMap<RecordUnionAdaptation>();
setRecordUnionAdaptation(node: Node, members: GrowableArray<RecordType>,
target: RecordType, sourceNullable: boolean = false): void {
this.#recordUnionAdaptations[node] =
new RecordUnionAdaptation(members, target, sourceNullable);
}
getRecordUnionAdaptationDirect(node: Node): RecordUnionAdaptation | null {
if (let (true, t) = this.#recordUnionAdaptations.get(node)) {
return t;
}
return null;
}
getRecordUnionAdaptation(node: Node): RecordUnionAdaptation | null {
let t = this.getRecordUnionAdaptationDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getRecordUnionAdaptationDirect(node);
}
}
return null;
}
/**
* Map from node.id → InterfaceAdaptation for implicit interface fat pointer adaptation.
*/
#interfaceAdaptations = new NodeMap<InterfaceAdaptation>();
#resolvedOverloads = new NodeMap<FunctionType>();
#resolvedCompoundOperators = new NodeMap<FunctionType>();
/**
* Map from node.id → the `Box<P>` a tagged template's primitive
* interpolation is wrapped in, recorded when the tag's value type
* accepts the box and not the primitive. Codegen constructs the box
* around the lowered value; nothing else in the tree names the class.
*/
#boxAdaptations = new NodeMap<ClassType>();
setBoxAdaptation(node: Node, box: ClassType): void {
this.#boxAdaptations[node] = box;
}
getBoxAdaptationDirect(node: Node): ClassType | null {
if (let (true, t) = this.#boxAdaptations.get(node)) {
return t;
}
return null;
}
getBoxAdaptation(node: Node): ClassType | null {
let t = this.getBoxAdaptationDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getBoxAdaptationDirect(node);
}
}
return null;
}
setInterfaceAdaptation(node: Node, source: Type, target: InterfaceType,
sourceNullable: boolean = false): void {
this.#interfaceAdaptations[node] =
new InterfaceAdaptation(source, target, sourceNullable);
}
/**
* The overload the checker selected for a call or index expression,
* recorded ONLY when the callee had overloads. Codegen must consume
* this instead of re-deriving the choice from argument node types:
* overload selection is subtype-sensitive and belongs to the checker
* alone (registration mangles overloaded members with the DECLARED
* signature key, so the recorded FunctionType reproduces the exact
* registration name).
*/
setResolvedOverload(node: Node, ft: FunctionType): void {
this.#resolvedOverloads[node] = ft;
}
getResolvedOverloadDirect(node: Node): FunctionType | null {
if (let (true, t) = this.#resolvedOverloads.get(node)) {
return t;
}
return null;
}
getResolvedOverload(node: Node): FunctionType | null {
let t = this.getResolvedOverloadDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getResolvedOverloadDirect(node);
}
}
return null;
}
/**
* The operator overload selected for the binary step of a compound
* assignment (`x += y`, `arr[i] += y`), kept separate from
* `#resolvedOverloads` because `arr[i] += y` already records its
* `[]=` overload on the same AssignmentExpression node.
*/
setResolvedCompoundOperator(node: Node, ft: FunctionType): void {
this.#resolvedCompoundOperators[node] = ft;
}
getResolvedCompoundOperatorDirect(node: Node): FunctionType | null {
if (let (true, t) = this.#resolvedCompoundOperators.get(node)) {
return t;
}
return null;
}
getResolvedCompoundOperator(node: Node): FunctionType | null {
let t = this.getResolvedCompoundOperatorDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getResolvedCompoundOperatorDirect(node);
}
}
return null;
}
getInterfaceAdaptationDirect(node: Node): InterfaceAdaptation | null {
if (let (true, t) = this.#interfaceAdaptations.get(node)) {
return t;
}
return null;
}
getInterfaceAdaptation(node: Node): InterfaceAdaptation | null {
let t = this.getInterfaceAdaptationDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getInterfaceAdaptationDirect(node);
}
}
return null;
}
/**
* Map from node.id → FunctionAdaptation for implicit function argument adaptation.
*/
#functionAdaptations = new NodeMap<FunctionAdaptation>();
setFunctionAdaptation(node: Node, source: FunctionType, target: FunctionType): void {
this.#functionAdaptations[node] = new FunctionAdaptation(source, target);
}
getFunctionAdaptationDirect(node: Node): FunctionAdaptation | null {
if (let (true, t) = this.#functionAdaptations.get(node)) {
return t;
}
return null;
}
getFunctionAdaptation(node: Node): FunctionAdaptation | null {
let t = this.getFunctionAdaptationDirect(node);
if (t != null) return t;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getFunctionAdaptationDirect(node);
}
}
return null;
}
/**
* Map from node.id -> UnionType representing the original union type of a callee.
*/
#unionCallCalleeTypes = new NodeMap<UnionType>();
setUnionCallCalleeType(node: Node, type: UnionType): void {
this.#unionCallCalleeTypes[node] = type;
}
getUnionCallCalleeTypeDirect(node: Node): UnionType | null {
if (let (true, t) = this.#unionCallCalleeTypes.get(node)) {
return t;
}
return null;
}
getUnionCallCalleeType(node: Node): UnionType | null {
let t = this.getUnionCallCalleeTypeDirect(node);
if (t != null) return t;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getUnionCallCalleeTypeDirect(node);
}
}
return null;
}
/**
* Map from node.id -> original argument count (before checker filled in defaults)
*/
#originalArgCounts = new NodeMap<i32>();
setOriginalArgCount(node: Node, count: i32): void {
this.#originalArgCounts[node] = count;
}
getOriginalArgCountDirect(node: Node): i32 {
if (let (true, count) = this.#originalArgCounts.get(node)) {
return count;
}
return -1;
}
getOriginalArgCount(node: Node): i32 {
let c = this.getOriginalArgCountDirect(node);
if (c != -1) return c;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getOriginalArgCountDirect(node);
}
}
return -1;
}
/**
* Map from node.id -> ClassType of the class that owns the method defaults
*/
#defaultArgsOwners = new NodeMap<Type>();
setDefaultArgsOwner(node: Node, type: Type): void {
this.#defaultArgsOwners[node] = type;
}
getDefaultArgsOwnerDirect(node: Node): Type | null {
if (let (true, t) = this.#defaultArgsOwners.get(node)) {
return t;
}
return null;
}
getDefaultArgsOwner(node: Node): Type | null {
let t = this.getDefaultArgsOwnerDirect(node);
if (t != null) return t;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getDefaultArgsOwnerDirect(node);
}
}
return null;
}
/**
* Map from node.id -> Parameter names
*/
#defaultArgParamNames = new NodeMap<GrowableArray<String>>();
setDefaultArgParamNames(node: Node, names: GrowableArray<String>): void {
this.#defaultArgParamNames[node] = names;
}
getDefaultArgParamNamesDirect(node: Node): GrowableArray<String> | null {
if (let (true, ns) = this.#defaultArgParamNames.get(node)) {
return ns;
}
return null;
}
getDefaultArgParamNames(node: Node): GrowableArray<String> | null {
let ns = this.getDefaultArgParamNamesDirect(node);
if (ns != null) return ns;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getDefaultArgParamNamesDirect(node);
}
}
return null;
}
/**
* The key a symbol-keyed member is registered under, per name node and
* per symbol-keyed member access.
*
* Two symbols may share a name, so the name alone cannot key a member:
* a class implementing two interfaces whose symbols are both called
* `act` needs two members. The key therefore carries the symbol's
* identity, which only the checker knows — every later pass reads it
* back from here rather than rebuilding it from the source text.
*/
#memberKeys = new NodeMap<String>();
setMemberKey(node: Node, key: String): void {
this.#memberKeys[node] = key;
}
/** The recorded key, or null where the checker recorded none. */
memberKeyDirect(node: Node): String | null {
if (let (true, k) = this.#memberKeys.get(node)) {
return k;
}
return null;
}
/**
* The recorded key, following the node to the model that owns it — a
* member declared in one module is keyed by that module's checker and
* read by codegen walking from another.
*/
memberKey(node: Node): String | null {
let direct = this.memberKeyDirect(node);
if (direct != null) {
return direct;
}
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.memberKeyDirect(node);
}
}
return null;
}
/**
* Map from node.id → boolean to record whether a member/call expression is a static access.
*/
#staticAccesses = new NodeMap<boolean>();
setStaticAccess(node: Node, isStatic: boolean): void {
this.#staticAccesses[node] = isStatic;
}
isStaticAccessDirect(node: Node): boolean {
if (let (true, s) = this.#staticAccesses.get(node)) {
return s;
}
return false;
}
isStaticAccess(node: Node): boolean {
if (this.isStaticAccessDirect(node)) return true;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.isStaticAccessDirect(node);
}
}
return false;
}
/**
* Declarations (keyed by their IdentifierPattern node) whose binding
* the compiler releases at scope exit: an `Own` of a resource class
* that is never moved, reassigned, captured or otherwise escaped.
* The checker decides (ownership.md §Implicit drop); ZIR lowering
* materializes the release through the shared finally region. The
* verdict is overwritten on a re-check, so stale trues cannot
* survive a pass that reached a different conclusion.
*/
#scopeExitDrops = new NodeMap<boolean>();
/**
* The release regions of a `var` owner binding, keyed by its
* declaration's pattern node: pairs of statement indices [start, end)
* in the declaring block, end -1 standing for the block's end, over
* which the binding holds a value nothing has moved. A region's
* finalizer releases whatever the binding holds at its exit. Empty
* when the binding is not released at all (ownership.md §Implicit
* drop, "`var` owner bindings").
*/
#ownDropIntervals = new NodeMap<GrowableArray<i32>>();
setOwnDropIntervals(node: Node, intervals: GrowableArray<i32>): void {
this.#ownDropIntervals[node] = intervals;
}
ownDropIntervalsOfDirect(node: Node): GrowableArray<i32> | null {
if (let (true, d) = this.#ownDropIntervals.get(node)) {
return d;
}
return null;
}
ownDropIntervalsOf(node: Node): GrowableArray<i32> | null {
let direct = this.ownDropIntervalsOfDirect(node);
if (direct != null) return direct;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.ownDropIntervalsOfDirect(node);
}
}
return null;
}
ownDropIntervals: NodeMap<GrowableArray<i32>> { get { return this.#ownDropIntervals; } }
/**
* Plain stores into a `var` owner binding that release the value the
* binding held before them: the checker found the binding live there.
* Keyed by the assignment node.
*/
#assignmentReleases = new NodeMap<boolean>();
setAssignmentRelease(node: Node): void {
this.#assignmentReleases[node] = true;
}
hasAssignmentReleaseDirect(node: Node): boolean {
if (let (true, d) = this.#assignmentReleases.get(node)) {
return d;
}
return false;
}
hasAssignmentRelease(node: Node): boolean {
if (this.hasAssignmentReleaseDirect(node)) return true;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.hasAssignmentReleaseDirect(node);
}
}
return false;
}
assignmentReleases: NodeMap<boolean> { get { return this.#assignmentReleases; } }
/**
* Reads of a nullable owner field of `this` that move the owner out
* of a consuming method: a take, which stores null into the field
* after the read (ownership.md §Affine fields). Keyed by the member
* expression.
*/
#fieldTakes = new NodeMap<boolean>();
setFieldTake(node: Node): void {
this.#fieldTakes[node] = true;
}
isFieldTakeDirect(node: Node): boolean {
if (let (true, d) = this.#fieldTakes.get(node)) {
return d;
}
return false;
}
isFieldTake(node: Node): boolean {
if (this.isFieldTakeDirect(node)) return true;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.isFieldTakeDirect(node);
}
}
return false;
}
fieldTakes: NodeMap<boolean> { get { return this.#fieldTakes; } }
/**
* Plain stores into a field whose declared type holds its class's
* `scoped T`, at a receiver that may be a restricted instantiation.
* What the store does with the value it replaces is decided per
* specialization: an owner is released, a `Scoped<T>` refused, and
* anything else overwritten. Keyed by the assignment node.
*/
#scopedFieldStores = new NodeMap<boolean>();
setScopedFieldStore(node: Node): void {
this.#scopedFieldStores[node] = true;
}
isScopedFieldStoreDirect(node: Node): boolean {
if (let (true, d) = this.#scopedFieldStores.get(node)) {
return d;
}
return false;
}
isScopedFieldStore(node: Node): boolean {
if (this.isScopedFieldStoreDirect(node)) return true;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.isScopedFieldStoreDirect(node);
}
}
return false;
}
scopedFieldStores: NodeMap<boolean> { get { return this.#scopedFieldStores; } }
/**
* Stores into an owner field of `this` that a dispose moved out on
* every path to the store: the field held nothing, so the store
* releases nothing and revives it. Keyed by the assignment node.
*/
#revivingStores = new NodeMap<boolean>();
setRevivingStore(node: Node): void {
this.#revivingStores[node] = true;
}
isRevivingStoreDirect(node: Node): boolean {
if (let (true, d) = this.#revivingStores.get(node)) {
return d;
}
return false;
}
isRevivingStore(node: Node): boolean {
if (this.isRevivingStoreDirect(node)) return true;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.isRevivingStoreDirect(node);
}
}
return false;
}
revivingStores: NodeMap<boolean> { get { return this.#revivingStores; } }
setScopeExitDrop(node: Node, drop: boolean): void {
this.#scopeExitDrops[node] = drop;
}
hasScopeExitDropDirect(node: Node): boolean {
if (let (true, d) = this.#scopeExitDrops.get(node)) {
return d;
}
return false;
}
hasScopeExitDrop(node: Node): boolean {
if (this.hasScopeExitDropDirect(node)) return true;
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.hasScopeExitDropDirect(node);
}
}
return false;
}
/**
* Compensating drops, keyed by an IfStatement node: bindings a branch
* join must release at the end of one arm because the other arm moved
* them (ownership.md §"The branch-join rule"). Lowering emits the
* dispose at the flagged arm's end, before the merge.
*/
#edgeDrops = new NodeMap<GrowableArray<EdgeDrop>>();
setEdgeDrops(node: Node, drops: GrowableArray<EdgeDrop>): void {
this.#edgeDrops[node] = drops;
}
edgeDropsOfDirect(node: Node): GrowableArray<EdgeDrop> | null {
if (let (true, d) = this.#edgeDrops.get(node)) {
return d;
}
return null;
}
edgeDropsOf(node: Node): GrowableArray<EdgeDrop> | null {
let direct = this.edgeDropsOfDirect(node);
if (direct != null) { return direct; }
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.edgeDropsOfDirect(node);
}
}
return null;
}
/**
* Drops owed at an early exit, keyed by its `return`, `break` or
* `continue`: bindings still live there that a move elsewhere kept
* from being released at their scope's end. Lowering releases them
* after the exit's value is computed and before control leaves.
*/
#exitDrops = new NodeMap<GrowableArray<SymbolId>>();
setExitDrops(node: Node, drops: GrowableArray<SymbolId>): void {
this.#exitDrops[node] = drops;
}
exitDropsOfDirect(node: Node): GrowableArray<SymbolId> | null {
if (let (true, d) = this.#exitDrops.get(node)) {
return d;
}
return null;
}
exitDropsOf(node: Node): GrowableArray<SymbolId> | null {
let direct = this.exitDropsOfDirect(node);
if (direct != null) { return direct; }
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.exitDropsOfDirect(node);
}
}
return null;
}
/**
* The affine fields a consuming method's body moved out, keyed by
* its MethodDefinition: dispose glue skips them
* (ownership.md §Affine fields).
*/
#movedOutFields = new NodeMap<GrowableArray<String>>();
setMovedOutFields(node: Node, names: GrowableArray<String>): void {
this.#movedOutFields[node] = names;
}
movedOutFieldsOfDirect(node: Node): GrowableArray<String> | null {
if (let (true, d) = this.#movedOutFields.get(node)) {
return d;
}
return null;
}
movedOutFieldsOf(node: Node): GrowableArray<String> | null {
let direct = this.movedOutFieldsOfDirect(node);
if (direct != null) { return direct; }
if (this.index != null) {
let owner = (this.index as ModelIndex).ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.movedOutFieldsOfDirect(node);
}
}
return null;
}
/**
* Map from Symbol.id → Type for named bindings.
* Parallel to #nodeTypes but keyed by binding identity, which is
* stable across reference sites. The checker populates this when
* processing declarations; identifier resolution looks up here.
*/
#bindingTypes = new Map<SymbolId, Type>();
/**
* Scope analysis symbol map (nodes → Symbol).
* Owned by the SemanticModel so consumers have a single object to query.
*/
var #symbols: SymbolMap | null = null;
/**
* Parent pointer map from node → parent node.
* Useful for analyses (like DCE) that need to walk up from a node.
* Populated during scope analysis.
*/
var #parents: DenseNodeMap<Node> = new DenseNodeMap<Node>(0 as NodeId, -1 as NodeId);
/**
* All diagnostics from type checking.
*/
#diagnostics = new Array<Diagnostic>();
/**
* Map from exported names to their resolved Type.
* Used for cross-module type lookups, especially for built-in
* primitives where Symbol ids may differ natively.
*/
#exportTypes = new Map<String, Type>();
// --- Reference and declaration maps ---
symbols: SymbolMap | null {
get { return this.#symbols; }
}
/**
* Attach the scope analysis maps.
*/
setSymbols(symbols: SymbolMap): void {
this.#symbols = symbols;
}
/**
* Bulk add parent pointers.
*/
setParents(parents: DenseNodeMap<Node>): void {
this.#parents = parents;
}
/**
* Set the parent of a node.
*/
setParent(child: Node, parent: Node): void {
this.#parents[child] = parent;
}
getParentDirect(child: Node): Node | null {
if (let (true, parent) = this.#parents.get(child)) {
return parent;
}
return null;
}
getParent(child: Node): Node | null {
let p = this.getParentDirect(child);
if (p != null) return p;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(child.id);
if (owner != null && owner != this) {
return owner.getParentDirect(child);
}
}
return null;
}
resolveDirect(node: Node): Symbol | null {
if (this.#symbols == null) {
return null;
}
return (this.#symbols as SymbolMap).getByNode(node);
}
resolveByOffset(offset: i32): Symbol | null {
if (this.#symbols == null) {
return null;
}
return (this.#symbols as SymbolMap).getByOffset(offset);
}
resolve(node: Node): Symbol | null {
let sym = this.resolveDirect(node);
if (sym != null) return sym;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.resolveDirect(node);
}
}
return null;
}
/**
* Find the Symbol for a declaration-site node.
* Used at declaration-processing time (e.g., when the checker processes
* a VariableDeclaration and needs to store the type for its binding).
*/
resolveDeclaration(node: Node): Symbol | null {
return this.resolve(node);
}
// --- Node types (expressions and declaration nodes) ---
/**
* Record the inferred type for an AST node.
*/
setNodeType(node: Node, type: Type): void {
this.#nodeTypes[node] = type;
}
getNodeTypeDirect(node: Node): Type | null {
if (let (true, t) = this.#nodeTypes.get(node)) {
return t;
}
return null;
}
getNodeType(node: Node): Type | null {
let t = this.getNodeTypeDirect(node);
if (t != null) return t;
let {index} = this;
if (index != null) {
let owner = index.ownerOfNode(node.id);
if (owner != null && owner != this) {
return owner.getNodeTypeDirect(node);
}
}
return null;
}
// --- Binding types (keyed by Symbol.id) ---
/**
* Store the type for a named binding.
*/
setBindingType(info: Symbol, type: Type): void {
this.#bindingTypes[info.id] = type;
}
getBindingTypeDirect(info: Symbol): Type | null {
if (this.#bindingTypes.has(info.id)) {
return this.#bindingTypes[info.id];
}
return null;
}
getBindingTypeById(id: SymbolId): Type | null {
if (this.#bindingTypes.has(id)) {
return this.#bindingTypes[id];
}
return null;
}
getBindingType(info: Symbol): Type | null {
let t = this.getBindingTypeDirect(info);
if (t != null) return t;
let {index} = this;
if (index != null) {
let owner = index.ownerOfBinding(info.id);
if (owner != null && owner != this) {
return owner.getBindingTypeDirect(info);
}
}
return null;
}
// --- Exports ---
/**
* Register a type as exported under the given name.
*/
setExportType(name: String, type: Type): void {
this.#exportTypes[name] = type;
}
/**
* Get an exported type by name.
*/
getExportType(name: String): Type | null {
if (this.#exportTypes.has(name)) {
return this.#exportTypes[name];
}
return null;
}
// --- Diagnostics ---
addDiagnostic(diagnostic: Diagnostic): void {
this.#diagnostics.push(diagnostic);
}
diagnostics: GrowableArray<Diagnostic> {
get { return this.#diagnostics; }
}
nodeTypes: DenseNodeMap<Type> {
get { return this.#nodeTypes; }
}
#symbolDependencies = new Map<SymbolId, SymbolDependencies>();
#nodeDependencies = new Map<i32, SymbolDependencies>();
symbolNames = new Map<SymbolId, String>();
/**
* Locals that some closure assigns, or captures before their
* declaration runs. Every closure that captures one of these captures
* its heap cell, including a closure that only reads it, so that the
* reader sees the writer's assignments. Filled by the checker as it
* leaves each closure; `capturedInCell` adds the locals the declaring
* scope assigns after a capture.
*/
mutablyCapturedSymbols = new Set<SymbolId>();
/**
* For each variable assigned after its declaration, the largest node
* id among its assignments. Node ids are handed out in source order,
* so this is the textually last one. See `capturedInCell`.
*/
lastAssignment = new Map<SymbolId, i32>();
/**
* The locals closures capture, each with the closures that capture
* it. See `capturedInCell`.
*/
capturedLocals = new Map<SymbolId, CapturedLocal>();
recordCapture(sym: Symbol, closure: Node): void {
if (let (true, local) = this.capturedLocals.get(sym.id)) {
local.closures.push(closure);
return;
}
let local = new CapturedLocal(sym);
local.closures.push(closure);
this.capturedLocals[sym.id] = local;
}
#declaredClasses = new Array<SymbolId>();
#declaredInterfaces = new Array<SymbolId>();
#declaredMixins = new Array<SymbolId>();
#declaredEnums = new Array<SymbolId>();
#declaredGlobals = new Array<SymbolId>();
#classDeclarations = new Map<SymbolId, ClassDeclaration>();
#interfaceDeclarations = new Map<SymbolId, InterfaceDeclaration>();
#mixinDeclarations = new Map<SymbolId, MixinDeclaration>();
#enumDeclarations = new Map<SymbolId, EnumDeclaration>();
// Ordered, and in declaration order: reachability roots a module's
// exports by iterating this, and the order decides function indices
// in the emitted module. Keyed by symbol id in a hash map, the order
// followed the ids' hash buckets, which shift whenever a module
// loaded ahead of this one gains or loses a symbol — so two targets
// whose preludes differ in size emitted the same program with its
// functions permuted.
#globalDeclarations = new Map<SymbolId, Node>.ordered();
#globalDeclarationOverloads = new Map<SymbolId, GrowableArray<Node>>();
symbolDependencies: HashMap<SymbolId, SymbolDependencies> {
get { return this.#symbolDependencies; }
}
nodeDependencies: HashMap<i32, SymbolDependencies> {
get { return this.#nodeDependencies; }
}
declaredClasses: GrowableArray<SymbolId> {
get { return this.#declaredClasses; }
}
declaredInterfaces: GrowableArray<SymbolId> {
get { return this.#declaredInterfaces; }
}
declaredMixins: GrowableArray<SymbolId> {
get { return this.#declaredMixins; }
}
declaredEnums: GrowableArray<SymbolId> {
get { return this.#declaredEnums; }
}
declaredGlobals: GrowableArray<SymbolId> {
get { return this.#declaredGlobals; }
}
classDeclarations: HashMap<SymbolId, ClassDeclaration> {
get { return this.#classDeclarations; }
}
interfaceDeclarations: HashMap<SymbolId, InterfaceDeclaration> {
get { return this.#interfaceDeclarations; }
}
mixinDeclarations: HashMap<SymbolId, MixinDeclaration> {
get { return this.#mixinDeclarations; }
}
enumDeclarations: HashMap<SymbolId, EnumDeclaration> {
get { return this.#enumDeclarations; }
}
globalDeclarations: HashMap<SymbolId, Node> {
get { return this.#globalDeclarations; }
}
addDeclaredClass(id: SymbolId, cd: ClassDeclaration): void {
this.#classDeclarations[id] = cd;
this.#declaredClasses.push(id);
}
addDeclaredInterface(id: SymbolId, idDec: InterfaceDeclaration): void {
this.#interfaceDeclarations[id] = idDec;
this.#declaredInterfaces.push(id);
}
addDeclaredMixin(id: SymbolId, md: MixinDeclaration): void {
this.#mixinDeclarations[id] = md;
this.#declaredMixins.push(id);
}
addDeclaredEnum(id: SymbolId, ed: EnumDeclaration): void {
this.#enumDeclarations[id] = ed;
this.#declaredEnums.push(id);
}
addDeclaredGlobal(id: SymbolId, node: Node): void {
if (!this.#globalDeclarations.has(id)) {
this.#globalDeclarations[id] = node;
this.#declaredGlobals.push(id);
}
let list = if (let (true, l) = this.#globalDeclarationOverloads.get(id)) {
l
} else {
let nl = new Array<Node>();
this.#globalDeclarationOverloads[id] = nl;
nl
};
list.push(node);
}
getGlobalDeclarations(id: SymbolId): GrowableArray<Node> | null {
if (let (true, l) = this.#globalDeclarationOverloads.get(id)) {
return l;
}
return null;
}
setSymbolDependencies(id: SymbolId, deps: SymbolDependencies): void {
this.#symbolDependencies[id] = deps;
}
setNodeDependencies(id: i32, deps: SymbolDependencies): void {
this.#nodeDependencies[id] = deps;
}
recordAdaptations: NodeMap<RecordAdaptation> { get { return this.#recordAdaptations; } }
recordUnionAdaptations: NodeMap<RecordUnionAdaptation> { get { return this.#recordUnionAdaptations; } }
interfaceAdaptations: NodeMap<InterfaceAdaptation> { get { return this.#interfaceAdaptations; } }
boxAdaptations: NodeMap<ClassType> { get { return this.#boxAdaptations; } }
functionAdaptations: NodeMap<FunctionAdaptation> { get { return this.#functionAdaptations; } }
unionCallCalleeTypes: NodeMap<UnionType> { get { return this.#unionCallCalleeTypes; } }
originalArgCounts: NodeMap<i32> { get { return this.#originalArgCounts; } }
defaultArgsOwners: NodeMap<Type> { get { return this.#defaultArgsOwners; } }
defaultArgParamNames: NodeMap<GrowableArray<String>> { get { return this.#defaultArgParamNames; } }
staticAccesses: NodeMap<boolean> { get { return this.#staticAccesses; } }
memberKeys: NodeMap<String> { get { return this.#memberKeys; } }
scopeExitDrops: NodeMap<boolean> { get { return this.#scopeExitDrops; } }
edgeDrops: NodeMap<GrowableArray<EdgeDrop>> { get { return this.#edgeDrops; } }
exitDrops: NodeMap<GrowableArray<SymbolId>> { get { return this.#exitDrops; } }
movedOutFields: NodeMap<GrowableArray<String>> { get { return this.#movedOutFields; } }
parents: DenseNodeMap<Node> { get { return this.#parents; } }
bindingTypes: HashMap<SymbolId, Type> { get { return this.#bindingTypes; } }
}
/** A local some closure captures, and every closure that captures it. */
export final class CapturedLocal {
sym: Symbol;
closures = new Array<Node>();
new(this.sym);
}
export final class ClosureDependency {
id: i32;
node: Node;
capturesThis: boolean;
captures: GrowableArray<SymbolId>;
dependencies: SymbolDependencies;
new(this.id, this.node, this.capturesThis, this.captures, this.dependencies);
}
/** A tuple of type `source` used as a tuple of type `target` (`tupleWidenings`). */
export final class TupleWidening {
source: TupleType;
target: TupleType;
new(this.source, this.target);
}
export final class FunctionAdaptationDependency {
node: Node;
source: FunctionType;
target: FunctionType;
new(this.node, this.source, this.target);
}
/**
* A set of types that iterates in the order they were added.
*
* Insertion order, not hash order. `Type.hashCode` is a process-global
* uid handed out at construction and never reset — it cannot be, since
* a long-lived compiler interns types across compiles, and restarting
* the sequence would collide fresh types with cached ones. So a
* `HashSet<Type>` iterates in an order that depends on how many types
* the process had already built, which is to say on how many modules
* were compiled before this one.
*
* That order reaches the emitted bytes: RTA walks this set to intern
* wasm types and register function-value wrappers, so compiling one
* file twice in a single process emitted two different (equally
* correct, equally sized) modules — a permuted type section, and
* whichever of two same-signature wrappers was registered first.
* The checker adds types during a deterministic AST walk, so insertion
* order is stable; hash order was the only thing that was not.
*/
export final class OrderedTypeSet with IterableUtils<Type> implements Iterable<Type> {
#seen = new Set<Type>();
#order = new Array<Type>();
/** Adds `t` if it is not already present. Returns whether it was new. */
add(t: Type): boolean {
if (!this.#seen.add(t)) { return false; }
this.#order.push(t);
return true;
}
[Iterable.iterator](): Iterator<Type> {
return this.#order.[Iterable.iterator]();
}
}
export final class SymbolDependencies {
referencedSymbols = new Set<SymbolId>();
referencedClassMethods = new Set<String>(); // Format: ClassSymbolId.methodName
usedInterfaceAdaptations = new Set<String>(); // Format: ClassSymbolId::InterfaceSymbolId
referencedTypes = new OrderedTypeSet();
closures = new Array<ClosureDependency>();
functionAdaptations = new Array<FunctionAdaptationDependency>();
var needsExceptionInfra = false;
/**
* This body can cause a cancellation: it calls `cancel` on a
* `TaskGroup`, the one operation that marks a scope cancelled.
* Aggregated over reached bodies, this is the whole-program gate
* the async cancellation machinery is emitted under.
*/
var causesCancellation = false;
/**
* This body has a `for`-in that iterates through the Iterator
* protocol (not an array index loop). Half of the generator-disposal
* gate: a reached protocol loop in a program that also creates a
* generator makes disposal possible, so those loops get a disposal
* finalizer and generators get the machinery it drives.
*/
var hasIteratorForIn = false;
/** This body creates a generator (`gen` function). The other half
* of the generator-disposal gate. */
var createsGenerator = false;
/** This body creates an async generator (`async gen` function). Together
* with `hasIteratorForIn`, this also opens the scope-cancellation gate so
* `for await` early-exit disposal can cancel pending work. */
var createsAsyncGenerator = false;
/**
* Enclosing locals assigned inside a `try` body. RTA cells them, so
* the handler observes assignments the body completed before it
* threw (see `analysis/capture.zena`).
*/
tryMutatedSymbols = new Set<SymbolId>();
}
- zena-lang:wit-parser wit-parser.zena-lang.pkg.zena-lang.dev ~0.0.1-preview.1
| Version | Published | Dependencies | Approved by |
|---|---|---|---|
| 0.0.2-preview.1 | 2026-11-19 |
|
|