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
22.0 KiB
Raw
import { HashMap, Set } from 'zena:collections';
import { growable } from 'zena:core';
import { walk } from '../visitor.zena';
import {
AssignmentExpression, BinaryExpression, BlockStatement, BooleanLiteral,
BreakStatement, CallExpression, ClassDeclaration, ContinueStatement,
Expression, ExpressionStatement, ForInStatement, ForStatement,
FunctionExpression, Identifier, IfExpression, IfStatement, IsExpression,
MatchExpression, MemberExpression, Node, NullLiteral, NumberLiteral, ReturnStatement,
StringLiteral,
ShieldedStatement, Statement, ThisExpression, ThrowExpression, UnaryExpression,
WhileStatement, getMemberPropertyName
} from '../ast.zena';
import {
ClassType, FieldInfo, InterfaceType, NeverType, NullType,
RecordType as RecordT, Type, UnionType as UnionT, baseType
} from '../types.zena';
import { SemanticModel } from '../semantic-model.zena';
import { Symbol, SymbolId, noSymbolId } from '../scope/symbol.zena';
import { resolveTypeAnnotation } from './annotations.zena';
import { CheckerContext } from './context.zena';
import { checkExpression } from './expressions.zena';
import { literalFits, recordUnionMembersOf } from './members.zena';
import {
createUnionType, subtractNullFromType, subtractTypeFromUnion,
unwrapNullableForMemberLookup
} from './unions.zena';
// ============================================================================
// Control-Flow Narrowing Helpers
// ============================================================================
/**
* Check if a statement definitely exits (return, break, continue, throw).
* Used to propagate narrowing past null-guard patterns like:
* if (x == null) { return; }
* // x is now non-null here
*
* `neverCompletingLoops` counts a loop that never completes
* (`loopNeverCompletes`) as exiting. The unreachable-code reports pass
* false until the bootstrap's checker knows the rule (#509).
*/
function exprDefinitelyExits(expr: Expression, model: SemanticModel | null = null,
neverCompletingLoops: boolean = true): boolean {
return match (expr) {
case ThrowExpression {}: true
case CallExpression as call: {
// A call to a never-returning function ends the path like a
// `throw`; the type is only known when a model is provided.
if (model == null) { false }
else {
let t = model.getNodeType(call);
t != null && t is NeverType
}
}
case MatchExpression {cases}: {
if (cases.length == 0) { return false; }
var allExit = true;
for (let c in cases) {
let caseExits = if (c.body is Statement) {
branchDefinitelyExits(c.body as Statement, model, neverCompletingLoops)
} else {
exprDefinitelyExits(c.body as Expression, model, neverCompletingLoops)
};
if (!caseExits) { allExit = false; }
}
allExit
}
case IfExpression {consequent, alternate}: {
let consExits = if (consequent is Statement) {
branchDefinitelyExits(consequent, model, neverCompletingLoops)
} else {
exprDefinitelyExits(consequent as Expression, model, neverCompletingLoops)
};
let altExits = if (alternate == null) {
false
} else if (alternate is Statement) {
branchDefinitelyExits(alternate, model, neverCompletingLoops)
} else {
exprDefinitelyExits(alternate as Expression, model, neverCompletingLoops)
};
consExits && altExits
}
case _: false
};
}
export function branchDefinitelyExits(stmt: Statement, model: SemanticModel | null = null,
neverCompletingLoops: boolean = true): boolean {
return match (stmt) {
case ReturnStatement {}: true
case BreakStatement {}: true
case ContinueStatement {}: true
case ExpressionStatement {expression}:
exprDefinitelyExits(expression, model, neverCompletingLoops)
case BlockStatement {body}: {
if (body.length == 0) { false }
else { branchDefinitelyExits(body[body.length - 1], model, neverCompletingLoops) }
}
// A shielded block always runs, and exits when its body does.
case ShieldedStatement {body}:
branchDefinitelyExits(body, model, neverCompletingLoops)
case IfStatement {consequent, alternate}: {
if (alternate == null) { false }
else {
branchDefinitelyExits(consequent, model, neverCompletingLoops) &&
branchDefinitelyExits(alternate, model, neverCompletingLoops)
}
}
case WhileStatement {test, body}:
neverCompletingLoops && loopNeverCompletes(test, body)
case ForStatement {test, body}:
neverCompletingLoops && loopNeverCompletes(test, body)
case _: false
};
}
/** Whether `test` is the literal `true`. */
export function isTrueLiteral(test: Node): boolean {
if (let BooleanLiteral {value} = test) {
return value;
}
return false;
}
/**
* Whether a loop never completes normally: its condition is the literal
* `true`, or a `for` has none, and no `break` in its body leaves it. A
* `return` or a `throw` is the only way out.
*/
function loopNeverCompletes(test: Node | null, body: Statement): boolean {
if (test != null && !isTrueLiteral(test)) {
return false;
}
return !breaksOutOf(body);
}
/**
* Whether `node` holds a `break` for the loop around it: one outside
* every loop body and function nested in `node`. A nested loop's
* condition, initializer and update belong to the outer loop, so a
* `break` in one of them counts.
*/
function breaksOutOf(node: Node): boolean {
var found = false;
walk(node, (n) => {
if (found) { return false; }
if (n is BreakStatement) {
found = true;
return false;
}
if (let WhileStatement {test} = n) {
found = breaksOutOf(test);
return false;
}
if (let ForStatement {init, test, update} = n) {
found = (init != null && breaksOutOf(init)) ||
(test != null && breaksOutOf(test)) ||
(update != null && breaksOutOf(update));
return false;
}
if (let ForInStatement {iterable} = n) {
found = breaksOutOf(iterable);
return false;
}
// A function's breaks belong to its own loops, and a class holds
// only functions.
return !(n is FunctionExpression) && !(n is ClassDeclaration);
}, (_) => {});
return found;
}
/**
* The root binding of a member-path narrowing key: "s42.inner" roots at
* symbol 42, "this.x" at nothing assignable. The inverse of the "s<id>"
* prefix getMemberPathKey builds.
*/
export function pathRootSymbolId(path: String): SymbolId {
if (path.length < 2 || path.sliceBytes(0, 1) != "s") { return noSymbolId; }
var end = 1;
// 46 is '.'.
while (end < path.length && path.getByteAt(end) != 46) { end += 1; }
if (let (true, id) = parseI32(path.sliceBytes(1, end))) {
return id as SymbolId;
}
return noSymbolId;
}
export function getMemberPathKey(ctx: CheckerContext, expr: Expression): String | null {
match (expr) {
case Identifier: {
let info = ctx.model.resolve(expr);
if (info == null) {
return null;
}
return "s" + i32ToString(info.id as i32);
}
case ThisExpression: {
return "this";
}
case MemberExpression {object, property, isSymbolAccess}: {
let base = getMemberPathKey(ctx, object);
if (base == null) {
return null;
}
let propStr = getMemberPropertyName(isSymbolAccess, property.name);
return `${base}.${propStr}`;
}
case _: {
return null;
}
}
}
export function getMemberPathKeyFromAccess(
ctx: CheckerContext,
object: Expression,
property: Identifier,
isSymbolAccess: boolean
): String | null {
let base = getMemberPathKey(ctx, object);
if (base == null) {
return null;
}
let propStr = getMemberPropertyName(isSymbolAccess, property.name);
return `${base}.${propStr}`;
}
function isImmutableFieldAccess(objectType: Type, propName: String): boolean {
let base = unwrapNullableForMemberLookup(objectType);
if (base == null) {
return false;
}
match (base) {
case ClassType as ct: {
if (!ct.members.has(propName)) {
return false;
}
let m = ct.members[propName];
match (m) {
case FieldInfo as fi: {
return !fi.isMutable;
}
case _: { return false; }
}
}
case InterfaceType as it: {
if (!it.members.has(propName)) {
return false;
}
let m = it.members[propName];
match (m) {
case FieldInfo as fi: {
return !fi.isMutable;
}
case _: { return false; }
}
}
case RecordT {properties}: {
return properties.has(propName);
}
case _: {
return false;
}
}
}
/**
* Whether `expr` is a member path whose every step is an immutable
* field read off a binding or `this`, so that a narrowing of it holds
* for as long as the root does. The object types are the ones the
* expression's own check recorded; a path no check has reached yet is
* checked here once.
*/
export function isImmutableMemberPath(ctx: CheckerContext, expr: Expression): boolean {
if (let MemberExpression {object, property, isSymbolAccess} = expr) {
let objectType = ctx.model.getNodeType(object) ?? checkExpression(ctx, object, null);
let propName = getMemberPropertyName(isSymbolAccess, property.name);
if (!isImmutableFieldAccess(objectType, propName)) {
return false;
}
match (object) {
case Identifier: {
return true;
}
case ThisExpression: {
return true;
}
case MemberExpression: {
return isImmutableMemberPath(ctx, object);
}
case _: {
return false;
}
}
} else {
return false;
}
}
/**
* What a condition narrows: a binding, keyed by its symbol, or an
* immutable member path, keyed by `getMemberPathKey`, with the type the
* subject has where the condition is tested — the flow type a read
* there sees, which is what the condition's own check recorded.
*/
final class NarrowingSubject {
binding: SymbolId;
path: String | null;
type: Type;
new(this.binding, this.path, this.type);
}
/** The subject `expr` names, or null when a condition on it narrows nothing. */
function narrowingSubject(ctx: CheckerContext, expr: Expression): NarrowingSubject | null {
match (expr) {
case Identifier: {
let info = ctx.model.resolve(expr);
if (info == null) {
return null;
}
let t = ctx.model.getNodeType(expr) ?? ctx.resolveIdentifier(expr);
if (t == null) {
return null;
}
return new NarrowingSubject(info.id, null, t);
}
case MemberExpression: {
if (!isImmutableMemberPath(ctx, expr)) {
return null;
}
let key = getMemberPathKey(ctx, expr);
if (key == null) {
return null;
}
let t = ctx.model.getNodeType(expr) ?? checkExpression(ctx, expr, null);
return new NarrowingSubject(noSymbolId, key, t);
}
case _: {
return null;
}
}
}
export final class ConditionNarrowings {
bindings: HashMap<SymbolId, Type>;
paths: HashMap<String, Type>;
new() :
bindings = new Map<SymbolId, Type>(),
paths = new Map<String, Type>();
/** Records that `subject` is a `t` on this branch. */
narrow(subject: NarrowingSubject, t: Type): void {
let {path} = subject;
if (path != null) {
this.paths[path] = t;
} else {
this.bindings[subject.binding] = t;
}
}
}
/**
* What a condition establishes on each of its branches: the narrowings
* in force where it was true, and where it was false.
*/
export final class BranchNarrowings {
whenTrue: ConditionNarrowings;
whenFalse: ConditionNarrowings;
new(this.whenTrue, this.whenFalse);
}
function mergeNarrowings(ctx: CheckerContext, dest: ConditionNarrowings, src: ConditionNarrowings) {
for (let id in src.bindings.keys()) {
if (let (true, t) = src.bindings.get(id)) {
dest.bindings[id] = t;
}
}
for (let path in src.paths.keys()) {
if (let (true, t) = src.paths.get(path)) {
dest.paths[path] = t;
}
}
}
function intersectNarrowings(
ctx: CheckerContext,
dest: ConditionNarrowings,
left: ConditionNarrowings,
right: ConditionNarrowings
) {
for (let id in left.bindings.keys()) {
if (let (true, leftType) = left.bindings.get(id)) {
if (let (true, rightType) = right.bindings.get(id)) {
let types = growable<Type>([leftType, rightType]);
dest.bindings[id] = createUnionType(types, ctx, null);
}
}
}
for (let path in left.paths.keys()) {
if (let (true, leftType) = left.paths.get(path)) {
if (let (true, rightType) = right.paths.get(path)) {
let types = growable<Type>([leftType, rightType]);
dest.paths[path] = createUnionType(types, ctx, null);
}
}
}
}
/** The one-sided conjunction: both held, so both narrowings hold. */
function both(ctx: CheckerContext, a: ConditionNarrowings, b: ConditionNarrowings) {
let result = new ConditionNarrowings();
mergeNarrowings(ctx, result, a);
mergeNarrowings(ctx, result, b);
return result;
}
/** The one-sided disjunction: one of them held, so a subject is what
* either says, and a subject only one speaks of is unnarrowed. */
function either(ctx: CheckerContext, a: ConditionNarrowings, b: ConditionNarrowings) {
let result = new ConditionNarrowings();
intersectNarrowings(ctx, result, a, b);
return result;
}
/**
* The narrowings `condition` establishes on its true and false
* branches, in one pass over it. Two rules, each on a binding or an
* immutable member path: a null test (`s == null`, `s != null`, either
* way round) narrows the subject to `null` on one branch and takes
* `null` off it on the other; an `is` test narrows it to the tested
* type on one branch and takes that type out of its union on the
* other. `!` swaps the branches. `a && b` holds both when true, and
* when false one of them failed, so a subject is what either side's
* false branch says; `a || b` the other way around. The right operand
* is read under the left's narrowings in force where it runs — the
* left's true branch for `&&`, its false branch for `||`.
*/
export function conditionNarrowings(ctx: CheckerContext, condition: Expression): BranchNarrowings {
match (condition) {
case UnaryExpression {operator, argument}: {
if (operator == "!") {
let inner = conditionNarrowings(ctx, argument);
return new BranchNarrowings(inner.whenFalse, inner.whenTrue);
}
}
case BinaryExpression {operator, left, right}: {
if (operator == "&&" || operator == "||") {
let isAnd = operator == "&&";
let a = conditionNarrowings(ctx, left);
// The right side is analyzed under the left's narrowings: a
// temporary node on the flow, removed by restoring.
let savedFlow = ctx.currentFlow;
ctx.pushFlowNarrowings(if (isAnd) a.whenTrue else a.whenFalse);
let b = conditionNarrowings(ctx, right);
ctx.setFlow(savedFlow);
return if (isAnd) {
new BranchNarrowings(both(ctx, a.whenTrue, b.whenTrue), either(ctx, a.whenFalse, b.whenFalse))
} else {
new BranchNarrowings(either(ctx, a.whenTrue, b.whenTrue), both(ctx, a.whenFalse, b.whenFalse))
};
}
if (operator == "==" || operator == "!=" || operator == "===" || operator == "!==") {
let tested: Expression | null = if (right is NullLiteral) {
left
} else if (left is NullLiteral) {
right
} else {
null
};
if (tested == null) {
let discriminated = discriminantNarrowings(ctx, left, right) ??
discriminantNarrowings(ctx, right, left);
if (discriminated == null) {
return new BranchNarrowings(new ConditionNarrowings(), new ConditionNarrowings());
}
let found = discriminated;
return if (operator == "==" || operator == "===") {
found
} else {
new BranchNarrowings(found.whenFalse, found.whenTrue)
};
}
let subject = narrowingSubject(ctx, tested);
if (subject == null) {
return new BranchNarrowings(new ConditionNarrowings(), new ConditionNarrowings());
}
let isNull = new ConditionNarrowings();
isNull.narrow(subject, new NullType());
let isNotNull = new ConditionNarrowings();
isNotNull.narrow(subject, subtractNullFromType(subject.type));
return if (operator == "==" || operator == "===") {
new BranchNarrowings(isNull, isNotNull)
} else {
new BranchNarrowings(isNotNull, isNull)
};
}
}
case IsExpression {expression, typeAnnotation}: {
let subject = narrowingSubject(ctx, expression);
if (subject == null) {
return new BranchNarrowings(new ConditionNarrowings(), new ConditionNarrowings());
}
let target = resolveTypeAnnotation(ctx, typeAnnotation);
let whenTrue = new ConditionNarrowings();
whenTrue.narrow(subject, target);
let whenFalse = new ConditionNarrowings();
whenFalse.narrow(subject, subtractTypeFromUnion(subject.type, target));
return new BranchNarrowings(whenTrue, whenFalse);
}
case _: {}
}
return new BranchNarrowings(new ConditionNarrowings(), new ConditionNarrowings());
}
/**
* What `x.f == literal` establishes when `x` is a union of record types
* told apart by `f`, as a discriminated union is: where it holds, `x` is
* the members whose `f` can be that literal; where it does not, the
* members whose `f` is not exactly it. A member whose `f` is wider than a
* literal (`i32`) stays on both sides. Null when `access` is not such a
* read or `literal` not a literal.
*/
function discriminantNarrowings(ctx: CheckerContext, access: Expression,
literal: Expression): BranchNarrowings | null {
if (!(access is MemberExpression) ||
!(literal is NumberLiteral || literal is BooleanLiteral || literal is StringLiteral)) {
return null;
}
let member = access;
let subject = narrowingSubject(ctx, member.object);
if (subject == null) {
return null;
}
let union = baseType(subject.type);
if (!(union is UnionT)) {
return null;
}
let members = recordUnionMembersOf(union);
if (members == null) {
return null;
}
let field = member.property.name;
let equal = new Array<Type>();
let unequal = new Array<Type>();
for (let rec in members) {
if (!rec.properties.has(field)) {
return null;
}
let fits = literalFits(rec.properties[field], literal);
if (fits != 0) {
equal.push(rec);
}
if (fits != 1) {
unequal.push(rec);
}
}
if (equal.length == members.length && unequal.length == members.length) {
return null;
}
let whenTrue = new ConditionNarrowings();
whenTrue.narrow(subject, narrowedMembers(ctx, equal));
let whenFalse = new ConditionNarrowings();
whenFalse.narrow(subject, narrowedMembers(ctx, unequal));
return new BranchNarrowings(whenTrue, whenFalse);
}
/** The union of the members a narrowing keeps: `never` for none. */
function narrowedMembers(ctx: CheckerContext, members: GrowableArray<Type>): Type {
if (members.length == 0) {
return new NeverType();
}
return if (members.length == 1) members[0] else createUnionType(members, ctx, null);
}
/** Puts `condition`'s true-branch narrowings on the flow: for a
* consumer that has only that branch, such as `&&`'s right operand or
* a match guard's arm. A consumer with both branches calls
* `conditionNarrowings` once. */
export function applyTrueNarrowingFromCondition(ctx: CheckerContext, condition: Expression): void {
ctx.pushFlowNarrowings(conditionNarrowings(ctx, condition).whenTrue);
}
/** Puts `condition`'s false-branch narrowings on the flow: `||`'s
* right operand. */
export function applyFalseNarrowingFromCondition(ctx: CheckerContext, condition: Expression): void {
ctx.pushFlowNarrowings(conditionNarrowings(ctx, condition).whenFalse);
}
/** The symbols assigned under one loop, collected by the walk below. */
final class LoopAssignments {
ids = new Array<SymbolId>();
#seen = new Set<i32>();
add(id: SymbolId): void {
if (!this.#seen.has(id as i32)) {
this.#seen.add(id as i32);
this.ids.push(id);
}
}
}
function isLoopStatement(n: Node) {
return n is WhileStatement || n is ForStatement || n is ForInStatement;
}
/**
* Every symbol assigned anywhere under `node`, deduplicated. Loops
* record these at the loop header as unknown-type flow assignments:
* a reference in the body is checked before the loop's back edge
* exists, yet on every iteration after the first it observes the
* previous iteration's stores, so the header must already carry them.
* Descends into nested functions on purpose — a closure created in the
* body can run on any iteration.
*
* One walk serves every loop under `node` as well: each loop open in
* the walk collects the assignments beneath it, and the sets are kept
* on the context by loop, so a nested loop's header finds its own
* without walking its body again. Nested loops used to cost depth
* times body size.
*/
function collectAssignedSymbolIds(ctx: CheckerContext, node: Node) {
if (let (true, collected) = ctx.loopAssignments.get(node.id as i32)) {
return collected;
}
// The loops open at the walk's position, `node`'s own set first.
let open = growable<LoopAssignments>([new LoopAssignments()]);
walk(node, (n) => {
if (n.id != node.id && isLoopStatement(n)) {
open.push(new LoopAssignments());
}
if (n is AssignmentExpression) {
if (n.left is Identifier) {
let info = ctx.model.resolve(n.left);
if (info != null) {
for (let loop in open) {
loop.add(info.id);
}
}
}
}
return true;
}, (n) => {
if (n.id != node.id && isLoopStatement(n)) {
let closed = open.pop();
ctx.loopAssignments[n.id as i32] = closed.ids;
}
});
let own = open.pop();
ctx.loopAssignments[node.id as i32] = own.ids;
return own.ids;
}
/**
* Record `node`'s assignments at the current position (a loop header)
* as unknown-type stores. See collectAssignedSymbolIds.
*/
export function recordLoopAssignments(ctx: CheckerContext, node: Node): void {
for (let assignedId in collectAssignedSymbolIds(ctx, node)) {
ctx.recordFlowAssignment(assignedId, null);
}
}
- 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 |
|
|