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
23.1 KiB
Raw
import { Set } from 'zena:collections';
import { growable } from 'zena:core';
import { BooleanLiteral, Expression, NumberLiteral, SourceLocation } from '../ast.zena';
import {
BoolLiteralType, BooleanType, ClassType, ErrorType, F64Type, HoleType,
I32Type, InlineRecordType, InlineTupleType as InlineTupleT, InterfaceType, NeverType,
NullType, NumLiteralType, StringLiteralType, TupleType as TupleT, Type,
TypeAliasType, TypeParameterType, UnionType as UnionT, UnknownType, V128Type, VoidType, baseType,
integerLiteralMagnitude, isBigIntLiteralRaw, isIntegerType, isNumericType, isOwnershipWrapper,
ownershipHandleInner, typeToString, unwrapAliases
} from '../types.zena';
import { DiagnosticCode } from '../diagnostics.zena';
import { WellKnown } from '../well-known.zena';
import { CheckerContext } from './context.zena';
import { isAssignableTo, representationOf, typesEqual, unconstrainedTypeParamOf } from './relations.zena';
/**
* Check if an array of types already contains a type equal to target.
*/
function containsType(types: Array<Type>, target: Type): boolean {
for (let member in types) {
if (typesEqual(member, target)) { return true; }
}
return false;
}
/**
* Combines the arm types of a `match` or `try` into the type of the
* whole expression.
*
* `never` arms drop out — they never complete, so they contribute no
* value (createUnionType does this). A `void` arm instead ABSORBS: it
* completes, and completes with nothing, so no value survives every
* path and the expression as a whole has none. `T | void` is not a
* type any binding can hold and has no wasm representation, so
* producing it here only defers the failure to codegen.
*
* This is what makes a statement-position `try`/`match` whose arms end
* in an assignment (`{ … x = v; }`, an expression statement with a
* value) come out `void` rather than `T | void`.
*/
export function combineArmTypes(types: Array<Type>, ctx: CheckerContext | null = null, loc: SourceLocation | null = null): Type {
for (let t in types) {
if (t is VoidType) {
return new VoidType();
}
}
return createUnionType(types, ctx, loc);
}
/**
* Create a union type, flattening nested unions and deduplicating.
*/
/**
* Same-handle members of a union merge: `Own<A> | Own<B>` is
* `Own<A | B>`. The handles are erased, so the two spellings denote
* the same values carrying the same obligation, and one canonical form
* keeps every downstream consumer — release, drop candidacy,
* assignability — single-path. Other members (null above all) ride
* alongside, and handles of different names never merge: their arms
* carry different obligations.
*/
function mergeHandleMembers(
members: GrowableArray<Type>,
ctx: CheckerContext | null,
loc: SourceLocation | null
) {
var mergeable = 0;
for (let m in members) {
if (isOwnershipWrapper(m) && ownershipHandleInner(m) != null) {
mergeable += 1;
}
}
if (mergeable < 2) {
let out = new Array<Type>();
for (let m in members) {
out.push(m);
}
return out;
}
// Group the handle members' inner types by handle name.
let names = new Array<String>();
let inners = new Array<GrowableArray<Type>>();
for (let m in members) {
if (isOwnershipWrapper(m) && ownershipHandleInner(m) != null) {
let alias = m as TypeAliasType;
var idx = -1;
for (var i = 0; i < names.length; i += 1) {
if (names[i] == alias.name) { idx = i; }
}
if (idx == -1) {
names.push(alias.name);
inners.push(new Array<Type>());
idx = names.length - 1;
}
inners[idx].push(ownershipHandleInner(m) as Type);
}
}
// Rebuild in member order: each handle name appears once, at its
// first position, wrapping the union of its inners.
let emitted = new Set<String>();
let result = new Array<Type>();
for (let m in members) {
if (isOwnershipWrapper(m) && ownershipHandleInner(m) != null) {
let alias = m as TypeAliasType;
if (emitted.has(alias.name)) { continue; }
emitted.add(alias.name);
var idx = 0;
for (var i = 0; i < names.length; i += 1) {
if (names[i] == alias.name) { idx = i; }
}
if (inners[idx].length == 1) {
result.push(m);
} else {
let mergedInner = createUnionType(inners[idx], ctx, loc);
let mergedArgs = growable<Type>([mergedInner]);
result.push(new TypeAliasType(
alias.name, alias.typeParameters, mergedInner, true, mergedArgs,
alias.isOpaque, alias.declaringModule));
}
} else {
result.push(m);
}
}
return result;
}
/**
* A class member of a union is absorbed by a superclass or interface
* member it is assignable to: `Circle | Shape` is `Shape`, and
* `HashMap<K, V> | Map<K, V>` is `Map<K, V>`. The arm that produced a
* class absorbed into an interface is adapted where the join is typed
* (`adaptJoinedArm` / `adaptToExpected`).
*/
function foldClassesIntoSupertypes(members: GrowableArray<Type>, ctx: CheckerContext | null) {
if (ctx == null || members.length < 2) { return members; }
var hasClass = false;
var hasSuperCandidate = false;
var classCount = 0;
for (let m in members) {
let u = unwrapAliases(m);
if (u is InterfaceType) { hasSuperCandidate = true; }
if (u is ClassType) {
hasClass = true;
classCount += 1;
}
}
if (!hasClass || (!hasSuperCandidate && classCount < 2)) { return members; }
let kept = new Array<Type>();
for (let m in members) {
var absorbed = false;
if (unwrapAliases(m) is ClassType) {
for (let other in members) {
let uOther = unwrapAliases(other);
if ((uOther is InterfaceType || uOther is ClassType) &&
!typesEqual(m, other) && isAssignableTo(ctx, m, other)) {
absorbed = true;
}
}
}
if (!absorbed) { kept.push(m); }
}
return kept;
}
export function createUnionType(types: Array<Type>, ctx: CheckerContext | null = null, loc: SourceLocation | null = null): Type {
var deduped = new Array<Type>();
var hasBoolean = false;
// Flatten nested unions and collect types
for (let type in types) {
match (type) {
case UnionT {types as inner}: {
for (let innerType in inner) {
if (innerType is BooleanType) { hasBoolean = true; }
if (!containsType(deduped, innerType)) { deduped.push(innerType); }
}
}
case NeverType: {}
case BooleanType: {
hasBoolean = true;
if (!containsType(deduped, type)) { deduped.push(type); }
}
case _: {
if (!containsType(deduped, type)) { deduped.push(type); }
}
}
}
// If the union contains boolean, remove BoolLiteralTypes.
if (hasBoolean) {
let withoutLits = new Array<Type>();
for (let t in deduped) {
if (!(t is BoolLiteralType)) {
withoutLits.push(t);
}
}
deduped = withoutLits;
}
// Compact NumberLiteralTypes if NumberType exists
let hasNum = false;
for (let t in deduped) {
if (isNumericType(t)) {
// Wait, we don't have a single NumberType, but many numeric types like f64.
// However, we mainly care about boolean for this bug.
}
}
deduped = mergeHandleMembers(deduped, ctx, loc);
deduped = foldClassesIntoSupertypes(deduped, ctx);
if (deduped.length == 0) { return new NeverType(); }
if (deduped.length == 1) { return deduped[0]; }
if (ctx != null) {
var hasPrimitive = false;
var hasReference = false;
var hasInlineTuple = false;
var hasErrorMember = false;
var represented = 0;
let primitiveBases = new Array<String>();
let unconstrained = new Array<String>();
// A type parameter not constrained to references may be bound to a
// primitive, so no other member is guaranteed to share its
// representation (types.md §"Unbounded Type Parameters in Unions").
for (let t in deduped) {
if (t is ErrorType) {
hasErrorMember = true;
}
if (!(t is VoidType || t is NeverType || t is ErrorType || t is UnknownType || t is HoleType)) {
represented += 1;
}
let param = unconstrainedTypeParamOf(t);
if (param != null && !unconstrained.contains(param.name)) {
unconstrained.push(param.name);
}
}
for (let t in deduped) {
if (t is InlineTupleT) {
hasInlineTuple = true;
}
// An enum or a distinct alias is carried as the type it wraps, so an
// integer enum is numeric here while a string enum is a reference.
let repr = representationOf(t);
let baseName: String | null = if (isNumericType(repr)) {
typeToString(baseType(repr))
} else if (repr is BooleanType || repr is BoolLiteralType) {
"boolean"
} else if (repr is V128Type) {
"v128"
} else {
null
};
if (baseName != null) {
hasPrimitive = true;
var found = false;
for (let primitiveBase in primitiveBases) {
if (primitiveBase == baseName) {
found = true;
break;
}
}
if (!found) {
primitiveBases.push(baseName);
}
} else if (t is VoidType || t is NeverType || t is ErrorType || t is UnknownType || t is HoleType || t is InlineTupleT) {
// Neither primitive nor reference.
} else {
hasReference = true;
}
}
if (unconstrained.length > 0 && represented > 1) {
if (!hasErrorMember) {
var names = "";
for (let n in unconstrained) {
names = if (names.length == 0) `'${n}'` else `${names}, '${n}'`;
}
let first = unconstrained[0];
let which = if (unconstrained.length == 1) `Type parameter ${names} is` else `Type parameters ${names} are`;
ctx.errorOnceAt(
`${which} not constrained to references, so ${if (unconstrained.length == 1) "it" else "they"} may be ` +
"bound to a primitive, which cannot be in a union with other types. " +
`Constrain it ('${first} extends anyref'), or keep a slot that may be empty as ` +
`'WithDefault<${first}>'.`,
DiagnosticCode.TypeMismatch,
loc
);
}
} else if (hasInlineTuple && (hasPrimitive || hasReference)) {
ctx.errorOnceAt("cannot mix inline tuple types with other representations", DiagnosticCode.TypeMismatch, loc);
} else if (hasPrimitive && hasReference) {
ctx.errorOnceAt("Union types cannot mix primitive types with reference types", DiagnosticCode.TypeMismatch, loc);
} else if (primitiveBases.length > 1) {
ctx.errorOnceAt("Union types cannot mix primitives of different base types", DiagnosticCode.TypeMismatch, loc);
} else {
checkTupleUnionMembers(ctx, deduped, loc);
}
}
return if (ctx != null) ctx.interner.union(deduped) else new UnionT(deduped);
}
/**
* Report a union whose tuple members a reader cannot tell apart.
*
* Zena's primitives carry no runtime type: enums, `boolean`, literal
* types and generic arguments erase, so `(Color, i32)` and `(Size, i32)`
* are the same struct, and an inline tuple has no type identity at all.
* A reader finds the member from a literal the author wrote instead:
* every tuple in the union starts with one, a different value in each,
* all of the same type. `(true, i32) | (false, String)` and
* `(0, _) | (1, T)` qualify. The literals must share a type because
* `true` and `1` are the same value at run time. The tuples have the
* same length because pattern typing merges them position by position.
* Other members, such as classes and `null`, are told apart from the
* tuples by their own runtime types. See #371.
*/
function checkTupleUnionMembers(ctx: CheckerContext, members: Array<Type>,
loc: SourceLocation | null): void {
let tuples = new Array<Array<Type>>();
var anyRow = false;
for (let member in members) {
if (let InlineTupleT {elementTypes} = member) {
tuples.push(elementTypes);
} else if (let TupleT {elementTypes, row} = member) {
tuples.push(elementTypes);
if (row != null) {
anyRow = true;
}
}
}
if (tuples.length < 2) {
return;
}
let arity = tuples[0].length;
if (!anyRow) {
for (let tuple in tuples) {
if (tuple.length != arity) {
ctx.error(
"The tuples in a union must have the same length.",
DiagnosticCode.TypeMismatch,
loc,
);
return;
}
}
}
var tagType: String | null = null;
let seen = new Set<String>();
for (let tuple in tuples) {
let head = if (tuple.length > 0) tuple[0] else new ErrorType() as Type;
let tag = discriminantTag(head);
let ok = if (tag == null) {
false
} else if (tagType != null && tagType != tag.type) {
false
} else {
!seen.has(tag.value)
};
if (!ok) {
ctx.error(
"Each tuple in a union must start with a literal of the same type, a different one in each, as in '(true, T) | (false, E)'.",
DiagnosticCode.TypeMismatch,
loc,
);
return;
}
if (tag != null) {
tagType = tag.type;
seen.add(tag.value);
}
}
}
/**
* Report `x is T` or `x as T` with a tuple type `T`, where `x` is a union
* holding tuples, unless `T` is one of them. The test reads the
* member's literal and checks its struct, which answers exactly whether
* `x` is that member. A tuple type that is not a member, such as
* `(true, Animal)` against a `(true, Dog)` member, would need its
* elements tested too, and tuples have no wasm subtyping for that.
*/
export function checkTupleUnionTest(ctx: CheckerContext, source: Type, target: Type,
loc: SourceLocation | null): void {
let resolvedTarget = baseType(target);
if (!(resolvedTarget is TupleT)) {
return;
}
let resolvedSource = unwrapAliases(source);
if (!(resolvedSource is UnionT)) {
return;
}
var hasTuple = false;
for (let member in resolvedSource.types) {
if (member is TupleT) {
hasTuple = true;
if (typesEqual(member, resolvedTarget)) {
return;
}
}
}
if (hasTuple) {
ctx.error(
`'${typeToString(target)}' is not one of the tuples in '${typeToString(source)}'. Test against one of them, or match on its literal.`,
DiagnosticCode.TypeMismatch,
loc,
);
}
}
/**
* The type and value of a literal that can tell union members apart: a
* boolean literal, or an integer literal (by its parsed value, so `0x1`
* and `1` are the same tag). Null for anything else.
*/
function discriminantTag(t: Type): {type: String, value: String} | null {
if (let BoolLiteralType {value} = t) {
return {type: 'boolean', value: if (value) 'true' else 'false'};
}
if (let NumLiteralType {raw} = t) {
let base = baseType(t);
if (!isIntegerType(base)) {
return null;
}
let negative = raw.length > 0 && raw.getByteAt(0) == 45;
let digits = if (negative) raw.sliceBytes(1, raw.length) else raw;
if (let (true, magnitude) = integerLiteralMagnitude(digits)) {
let sign = if (negative) '-' else '';
return {type: typeToString(base), value: `${sign}${magnitude}`};
}
}
return null;
}
/**
* Infer a type argument by matching a parameter type against an argument type.
* paramType: the expected param type (may be TypeParameterType)
* argType: the actual argument type
* inferred: map to store inferred type params
*/
/**
* The boxed tuple member of `expected`, a union, that a tuple literal
* starting with a boolean or integer literal is: the one with the same
* length that starts with the same value. Null when there is none, or
* `expected` is not a union.
*/
export function tupleMemberForLiteral(expected: Type, elements: GrowableArray<Expression>): TupleT | null {
if (elements.length == 0) {
return null;
}
let resolved = unwrapAliases(expected);
if (!(resolved is UnionT)) {
return null;
}
let head: Type | null = match (elements[0]) {
case BooleanLiteral {value}: new BoolLiteralType(value) as Type
case NumberLiteral {raw}: if (isBigIntLiteralRaw(raw)) null else new NumLiteralType(raw) as Type
case _: null
};
if (head == null) {
return null;
}
let tag = discriminantTag(head);
if (tag == null) {
return null;
}
for (let member in resolved.types) {
if (let TupleT {elementTypes, row} = member) {
if (row != null || elementTypes.length != elements.length) {
continue;
}
let memberTag = discriminantTag(elementTypes[0]);
if (memberTag != null && memberTag.value == tag.value) {
return member as TupleT;
}
}
}
return null;
}
/**
* Inline counterpart of `tupleMemberForLiteral`: the `InlineTupleType`
* member of `expected` whose arity and leading literal tag match `elements`.
*/
export function inlineTupleMemberForLiteral(expected: Type, elements: GrowableArray<Expression>): InlineTupleT | null {
if (elements.length == 0) {
return null;
}
let resolved = unwrapAliases(expected);
if (!(resolved is UnionT)) {
return null;
}
let head: Type | null = match (elements[0]) {
case BooleanLiteral {value}: new BoolLiteralType(value) as Type
case NumberLiteral {raw}: if (isBigIntLiteralRaw(raw)) null else new NumLiteralType(raw) as Type
case _: null
};
if (head == null) {
return null;
}
let tag = discriminantTag(head);
if (tag == null) {
return null;
}
for (let member in resolved.types) {
if (let InlineTupleT {elementTypes} = member) {
if (elementTypes.length != elements.length) {
continue;
}
let memberTag = discriminantTag(elementTypes[0]);
if (memberTag != null && memberTag.value == tag.value) {
return member as InlineTupleT;
}
}
}
return null;
}
/**
* The tuple among `members` that starts with the same literal as the
* tuple `t`, boxed or inline, or null when `t` is not such a tuple.
*/
export function tupleWithSameTag(members: Array<Type>, t: Type): Type | null {
let tag = tupleTagOf(t);
if (tag == null) {
return null;
}
for (let member in members) {
let memberTag = tupleTagOf(member);
if (memberTag != null && memberTag.type == tag.type &&
memberTag.value == tag.value) {
return member;
}
}
return null;
}
/** The discriminant literal a boxed or inline tuple starts with. */
function tupleTagOf(t: Type): {type: String, value: String} | null {
let elements = match (t) {
case TupleT {elementTypes}: elementTypes
case InlineTupleT {elementTypes}: elementTypes
case _: null
};
if (elements == null || elements.length == 0) {
return null;
}
return discriminantTag(elements[0]);
}
/**
* `t` with each of its members passed through `narrow`, which answers
* what the member can still be: itself, something narrower, or `never`
* to drop it. A union (through aliases) is rebuilt from what is left —
* `never` when nothing is, the one member when one is; anything else
* is one member and takes `narrow`'s answer for itself. Every
* subtraction a narrowing or a match arm performs is one of these.
*
* A rule is a named function the callback calls, not a block: a
* closure that returns `never` on one path and its member on another
* is typed by its first return alone (elematic/zena#794).
*/
export function narrowUnion(t: Type, narrow: (member: Type) => Type): Type {
if (let UnionT {types} = unwrapAliases(t)) {
let remaining = new Array<Type>();
for (let member in types) {
let kept = narrow(member);
if (!(kept is NeverType)) {
remaining.push(kept);
}
}
if (remaining.length == 0) { return new NeverType(); }
if (remaining.length == 1) { return remaining[0]; }
return new UnionT(remaining);
}
return narrow(t);
}
/** `t` without `null`: `never` for `null` itself. */
export function subtractNullFromType(t: Type): Type {
return narrowUnion(t, (member) => dropNull(member));
}
/** `member`, or `never` when it is `null`. */
function dropNull(member: Type): Type {
if (unwrapAliases(member) is NullType) { return new NeverType(); }
return member;
}
/**
* `original` without the member equal to `toRemove`:
* `subtractTypeFromUnion(Cat | Fish, Cat)` is `Fish`, and a non-union
* equal to `toRemove` is `never`.
*/
export function subtractTypeFromUnion(original: Type, toRemove: Type): Type {
return narrowUnion(original, (member) => dropEqual(member, toRemove));
}
/** `member`, or `never` when it equals `toRemove`. */
function dropEqual(member: Type, toRemove: Type): Type {
if (typesEqual(member, toRemove)) { return new NeverType(); }
return member;
}
export function unwrapNullableForMemberLookup(t: Type): Type | null {
match (t) {
case NullType: {
return null;
}
case UnionT as u: {
let remaining = new Array<Type>();
let members = u.types;
for (let member in members) {
if (!(member is NullType)) {
remaining.push(member);
}
}
if (remaining.length == 0) {
return null;
}
if (remaining.length == 1) {
return remaining[0];
}
return new UnionT(remaining);
}
case _: {
return t;
}
}
}
/**
* `t` without its null member, and whether it had one: the receiver a
* member read, index or call on a maybe-null value resolves against.
* Several non-null members stay a union; bare `null` has no receiver
* and comes back as itself, flagged.
*/
export function stripNull(ctx: CheckerContext, t: Type): inline (Type, boolean) {
let u = unwrapAliases(t);
if (u is TypeParameterType) {
let bound = u.constraint;
if (bound != null) {
let (strippedBound, boundNullable) = stripNull(ctx, bound);
if (boundNullable) {
return (strippedBound, true);
}
}
return (t, false);
}
if (u is NullType) {
return (u, true);
}
if (let UnionT {types} = u) {
var hasNull = false;
let nonNull = new Array<Type>();
for (let member in types) {
if (unwrapAliases(member) is NullType) {
hasNull = true;
} else {
nonNull.push(member);
}
}
if (nonNull.length == 1) {
return (nonNull[0], hasNull);
}
if (nonNull.length > 1 && hasNull) {
return (ctx.interner.union(nonNull), true);
}
return (t, hasNull);
}
return (t, false);
}
/**
* The type of a value that is either an `a` or a `b`: the wider of the
* two when one is assignable to the other, else their union.
*/
export function eitherType(ctx: CheckerContext, a: Type, b: Type): Type {
if (isAssignableTo(ctx, a, b)) {
return b;
}
if (isAssignableTo(ctx, b, a)) {
return a;
}
let both = growable<Type>([a, b]);
return createUnionType(both, ctx);
}
/**
* Widen a literal type to its base type.
* Used for `var` bindings: `var x = true` → x: boolean (not x: true).
*/
export function widenType(ctx: CheckerContext, t: Type): Type {
return match (t) {
case BoolLiteralType {}: new BooleanType()
case StringLiteralType {}: {
let stringType = ctx.tryResolveWellKnownType(WellKnown.StringClass);
stringType ?? t
}
case NumLiteralType {raw}: {
var isFloat = false;
var i = 0;
while (i < raw.length) {
if (raw.getByteAt(i) == 46) { // '.'
isFloat = true;
break;
}
i += 1;
}
if (isFloat) {
let expected = new F64Type();
expected as Type
} else {
let expected = new I32Type();
expected as Type
}
}
case _: t
};
}
- 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 |
|
|