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.3 KiB
Raw
/**
* A memory census of what one compile retains, for issue #199.
*
* `ZENA_CENSUS=1` prints a table of object counts and the bytes they
* occupy in the wasm GC heap, so a change aimed at the collector's live
* set can be measured rather than guessed at.
*
* Bytes come from wasmtime's copying collector layout, which is the
* only one worth sizing for: a 16-byte object header, fields at their
* natural alignment in declaration order, and the total rounded up to
* a multiple of 16 (`wasmtime-environ`'s `common_struct_layout`, with
* `copying::HEADER_SIZE` and `ALIGN` both 16). Every AST node field is
* a reference, an i32 or a boolean, so each is 4 bytes and a node of
* `n` fields occupies `ceil16(16 + 4n)`.
*
* The 16-byte quantum is the thing to keep in mind reading the table:
* shaving one field off a 13-field node saves nothing, and shaving one
* off a 4-field node saves a quarter of it.
*
* The AST and side-table rows come from walking the program, so they
* are what the compile RETAINS. The rows under "minted over the
* process" are totals, which for interned types is nearly the same
* thing and for anything transient is an upper bound.
*/
import { walkEnter } from './visitor.zena';
import {
Node, Module, VariableDeclaration, UsingStatement, ShieldedStatement, FunctionDeclaration, ExpressionStatement, BlockStatement, IfStatement, WhileStatement, ForStatement, ForInStatement, LetPatternCondition, ReturnStatement, YieldStatement, BreakStatement, ContinueStatement, Identifier, BindingPattern, IdentifierPattern, NumberLiteral, StringLiteral, BooleanLiteral, NullLiteral, TemplateElement, TemplateLiteral, TaggedTemplateExpression, BinaryExpression, UnaryExpression, AssignmentExpression, AsExpression, IsExpression, RangeExpression, PipelineExpression, PipePlaceholder, FunctionExpression, Parameter, CallExpression, TypeParameter, MemberExpression, IndexExpression, ThisExpression, NewExpression, ArrayLiteral, RecordLiteral, TupleLiteral, PropertyAssignment, SpreadElement, MapLiteral, MapEntry, RecordPattern, TuplePattern, ArrayPattern, RestPattern, BindingProperty, AsPattern, ClassPattern, LogicalPattern, AssignmentPattern, AbsencePattern, LiteralPattern, MatchExpression, MatchCase, IfExpression, ThrowExpression, TryExpression, AwaitExpression, CatchClause, NamedTypeAnnotation, UnionTypeAnnotation, NullableTypeAnnotation, FunctionTypeAnnotation, LiteralTypeAnnotation, RecordTypeAnnotation, TupleTypeAnnotation, InlineTypeAnnotation, ThisTypeAnnotation, PropertySignature, TypeAliasDeclaration, CaseClassParam, SealedVariant, ClassDeclaration, FieldDefinition, MethodDefinition, AccessorDeclaration, SetterInfo, SuperExpression, FieldInitializer, SuperInitializer, InterfaceDeclaration, MixinDeclaration, MethodSignature, AccessorSignature, EnumDeclaration, EnumMember, ImportDeclaration, ImportSpecifier, ExportAllDeclaration, ExportFromDeclaration, Decorator, ContractClause, DeclareFunction, SymbolDeclaration, SymbolPropertyName,
} from './ast.zena';
import { Program } from './program.zena';
import {
typesCreated, classTypesCreated, functionTypesCreated,
interfaceTypesCreated, mixinTypesCreated, typeParameterTypesCreated,
typeKeysCached, typeKeyBytes, unionInternHits, unionInternMisses,
unionInternFresh, unionFreshByKind,
instantiationHits, instantiationMisses, substitutedNominals,
substitutionCacheHits, parametricSubstitutions, functionTypeHits,
typeMarks, codegenFunctionTypeSite,
codegenSubstCalls, codegenSubstUnchanged, codegenSubstDistinct,
distinctTypeKeys
} from './types.zena';
/**
* The wasm GC heap size of an object with `fields` 4-byte fields: the
* 16-byte header plus the fields, rounded up to the 16-byte quantum.
*/
export function objectBytes(fields: i32): i32 {
return (((16 + 4 * fields + 15) / 16) as i32) * 16;
}
/**
* What one entry in a `Map<K, V>` costs: a `MapEntry` (key, value,
* next) plus its share of the bucket array, which grows at a 0.75 load
* factor, so about 1.33 four-byte slots per live entry.
*/
function mapEntryBytes(entries: i32) {
return entries * (objectBytes(3) + 5);
}
/**
* The same for an ordered map, whose entry adds forward and backward
* links and a `removed` flag.
*/
function orderedEntryBytes(entries: i32) {
return entries * (objectBytes(6) + 5);
}
/**
* How many fields each AST node kind declares, counting the two it
* inherits from `Node` (`loc` and `id`). Generated from the
* declarations in ast.zena; a kind that gains a field and is not
* updated here is reported too small, which its row's name makes
* findable.
*/
function nodeFieldCount(node: Node): i32 {
return match (node) {
case AbsencePattern: 2
case AccessorDeclaration: 9
case AccessorSignature: 6
case ArrayLiteral: 3
case ArrayPattern: 3
case AsExpression: 4
case AsPattern: 4
case AssignmentExpression: 5
case AssignmentPattern: 4
case AwaitExpression: 3
case BinaryExpression: 5
case BindingPattern: 4
case BindingProperty: 4
case BlockStatement: 3
case BooleanLiteral: 3
case BreakStatement: 2
case CallExpression: 6
case CaseClassParam: 6
case CatchClause: 4
case ClassDeclaration: 17
case ClassPattern: 5
case ContinueStatement: 2
case ContractClause: 6
case DeclareFunction: 10
case Decorator: 5
case EnumDeclaration: 5
case EnumMember: 4
case ExportAllDeclaration: 3
case ExportFromDeclaration: 4
case ExpressionStatement: 3
case FieldDefinition: 13
case FieldInitializer: 4
case ForInStatement: 7
case ForStatement: 7
case FunctionDeclaration: 5
case FunctionExpression: 9
case FunctionTypeAnnotation: 5
case Identifier: 3
case IdentifierPattern: 3
case IfExpression: 5
case IfStatement: 5
case ImportDeclaration: 4
case ImportSpecifier: 4
case IndexExpression: 5
case InlineTypeAnnotation: 4
case InterfaceDeclaration: 7
case IsExpression: 4
case LetPatternCondition: 4
case LiteralPattern: 3
case LiteralTypeAnnotation: 3
case LogicalPattern: 5
case MapEntry: 4
case MapLiteral: 3
case MatchCase: 5
case MatchExpression: 4
case MemberExpression: 7
case MethodDefinition: 20
case MethodSignature: 7
case MixinDeclaration: 9
case Module: 6
case NamedTypeAnnotation: 5
case NewExpression: 6
case NullLiteral: 2
case NullableTypeAnnotation: 3
case NumberLiteral: 3
case Parameter: 8
case PipePlaceholder: 2
case PipelineExpression: 4
case PropertyAssignment: 4
case PropertySignature: 5
case RangeExpression: 4
case RecordLiteral: 3
case RecordPattern: 3
case RecordTypeAnnotation: 3
case RestPattern: 3
case ReturnStatement: 4
case SealedVariant: 4
case SetterInfo: 4
case ShieldedStatement: 3
case SpreadElement: 3
case StringLiteral: 3
case SuperExpression: 2
case SuperInitializer: 4
case SymbolDeclaration: 4
case SymbolPropertyName: 3
case TaggedTemplateExpression: 4
case TemplateElement: 5
case TemplateLiteral: 4
case ThisExpression: 2
case ThisTypeAnnotation: 2
case ThrowExpression: 3
case TryExpression: 6
case TupleLiteral: 3
case TuplePattern: 3
case TupleTypeAnnotation: 3
case TypeAliasDeclaration: 9
case TypeParameter: 6
case UnaryExpression: 5
case UnionTypeAnnotation: 3
case UsingStatement: 5
case VariableDeclaration: 7
case WhileStatement: 5
case YieldStatement: 3
};
}
/** The declaration name of a node kind, for the census row. */
function nodeKindName(node: Node) {
return match (node) {
case AbsencePattern: 'AbsencePattern'
case AccessorDeclaration: 'AccessorDeclaration'
case AccessorSignature: 'AccessorSignature'
case ArrayLiteral: 'ArrayLiteral'
case ArrayPattern: 'ArrayPattern'
case AsExpression: 'AsExpression'
case AsPattern: 'AsPattern'
case AssignmentExpression: 'AssignmentExpression'
case AssignmentPattern: 'AssignmentPattern'
case AwaitExpression: 'AwaitExpression'
case BinaryExpression: 'BinaryExpression'
case BindingPattern: 'BindingPattern'
case BindingProperty: 'BindingProperty'
case BlockStatement: 'BlockStatement'
case BooleanLiteral: 'BooleanLiteral'
case BreakStatement: 'BreakStatement'
case CallExpression: 'CallExpression'
case CaseClassParam: 'CaseClassParam'
case CatchClause: 'CatchClause'
case ClassDeclaration: 'ClassDeclaration'
case ClassPattern: 'ClassPattern'
case ContinueStatement: 'ContinueStatement'
case ContractClause: 'ContractClause'
case DeclareFunction: 'DeclareFunction'
case Decorator: 'Decorator'
case EnumDeclaration: 'EnumDeclaration'
case EnumMember: 'EnumMember'
case ExportAllDeclaration: 'ExportAllDeclaration'
case ExportFromDeclaration: 'ExportFromDeclaration'
case ExpressionStatement: 'ExpressionStatement'
case FieldDefinition: 'FieldDefinition'
case FieldInitializer: 'FieldInitializer'
case ForInStatement: 'ForInStatement'
case ForStatement: 'ForStatement'
case FunctionDeclaration: 'FunctionDeclaration'
case FunctionExpression: 'FunctionExpression'
case FunctionTypeAnnotation: 'FunctionTypeAnnotation'
case Identifier: 'Identifier'
case IdentifierPattern: 'IdentifierPattern'
case IfExpression: 'IfExpression'
case IfStatement: 'IfStatement'
case ImportDeclaration: 'ImportDeclaration'
case ImportSpecifier: 'ImportSpecifier'
case IndexExpression: 'IndexExpression'
case InlineTypeAnnotation: 'InlineTypeAnnotation'
case InterfaceDeclaration: 'InterfaceDeclaration'
case IsExpression: 'IsExpression'
case LetPatternCondition: 'LetPatternCondition'
case LiteralPattern: 'LiteralPattern'
case LiteralTypeAnnotation: 'LiteralTypeAnnotation'
case LogicalPattern: 'LogicalPattern'
case MapEntry: 'MapEntry'
case MapLiteral: 'MapLiteral'
case MatchCase: 'MatchCase'
case MatchExpression: 'MatchExpression'
case MemberExpression: 'MemberExpression'
case MethodDefinition: 'MethodDefinition'
case MethodSignature: 'MethodSignature'
case MixinDeclaration: 'MixinDeclaration'
case Module: 'Module'
case NamedTypeAnnotation: 'NamedTypeAnnotation'
case NewExpression: 'NewExpression'
case NullLiteral: 'NullLiteral'
case NullableTypeAnnotation: 'NullableTypeAnnotation'
case NumberLiteral: 'NumberLiteral'
case Parameter: 'Parameter'
case PipePlaceholder: 'PipePlaceholder'
case PipelineExpression: 'PipelineExpression'
case PropertyAssignment: 'PropertyAssignment'
case PropertySignature: 'PropertySignature'
case RangeExpression: 'RangeExpression'
case RecordLiteral: 'RecordLiteral'
case RecordPattern: 'RecordPattern'
case RecordTypeAnnotation: 'RecordTypeAnnotation'
case RestPattern: 'RestPattern'
case ReturnStatement: 'ReturnStatement'
case SealedVariant: 'SealedVariant'
case SetterInfo: 'SetterInfo'
case ShieldedStatement: 'ShieldedStatement'
case SpreadElement: 'SpreadElement'
case StringLiteral: 'StringLiteral'
case SuperExpression: 'SuperExpression'
case SuperInitializer: 'SuperInitializer'
case SymbolDeclaration: 'SymbolDeclaration'
case SymbolPropertyName: 'SymbolPropertyName'
case TaggedTemplateExpression: 'TaggedTemplateExpression'
case TemplateElement: 'TemplateElement'
case TemplateLiteral: 'TemplateLiteral'
case ThisExpression: 'ThisExpression'
case ThisTypeAnnotation: 'ThisTypeAnnotation'
case ThrowExpression: 'ThrowExpression'
case TryExpression: 'TryExpression'
case TupleLiteral: 'TupleLiteral'
case TuplePattern: 'TuplePattern'
case TupleTypeAnnotation: 'TupleTypeAnnotation'
case TypeAliasDeclaration: 'TypeAliasDeclaration'
case TypeParameter: 'TypeParameter'
case UnaryExpression: 'UnaryExpression'
case UnionTypeAnnotation: 'UnionTypeAnnotation'
case UsingStatement: 'UsingStatement'
case VariableDeclaration: 'VariableDeclaration'
case WhileStatement: 'WhileStatement'
case YieldStatement: 'YieldStatement'
};
}
/** One row of the census: a kind, how many there are, and their bytes. */
final class Row {
name: String;
var count: i32 = 0;
var bytes: i32 = 0;
new(this.name);
}
/** Rows accumulated by name, reported by descending bytes. */
final class Table {
#rows = new Map<String, Row>();
#order = new GrowableArray<Row>();
add(name: String, count: i32, bytes: i32): void {
if (count == 0) { return; }
let row = if (let (true, existing) = this.#rows.get(name)) {
existing
} else {
let created = new Row(name);
this.#rows[name] = created;
this.#order.push(created);
created
};
row.count = row.count + count;
row.bytes = row.bytes + bytes;
}
rowsByBytes(): GrowableArray<Row> {
let out = new GrowableArray<Row>();
for (let row in this.#order) {
out.push(row);
}
var i = 1;
while (i < out.length) {
let current = out[i];
var j = i - 1;
while (j >= 0 && out[j].bytes < current.bytes) {
out[j + 1] = out[j];
j -= 1;
}
out[j + 1] = current;
i += 1;
}
return out;
}
totalBytes(): i32 {
var total = 0;
for (let row in this.#order) {
total = total + row.bytes;
}
return total;
}
totalCount(): i32 {
var total = 0;
for (let row in this.#order) {
total = total + row.count;
}
return total;
}
}
function padRight(s: String, width: i32) {
var out = s;
while (out.length < width) { out = out + " "; }
return out;
}
function padLeft(s: String, width: i32) {
var out = s;
while (out.length < width) { out = " " + out; }
return out;
}
/** A byte count as MiB to one decimal, for a table a human reads. */
function mib(bytes: i32) {
let tenths = (((bytes as f64) / 1048576.0) * 10.0) as i32;
let whole = (tenths / 10) as i32;
return `${i32ToString(whole)}.${i32ToString(tenths - whole * 10)}`;
}
function printTable(title: String, table: Table, limit: i32) {
console.log("");
console.log(`-- ${title}: ${i32ToString(table.totalCount())} objects, ${mib(table.totalBytes())} MiB`);
var shown = 0;
for (let row in table.rowsByBytes()) {
if (shown >= limit) { break; }
console.log(` ${padRight(row.name, 32)}${padLeft(i32ToString(row.count), 11)}${padLeft(mib(row.bytes), 10)}`);
shown += 1;
}
}
function line(label: String, value: i32) {
console.log(` ${padRight(label, 32)}${padLeft(i32ToString(value), 11)}`);
}
/**
* Prints the census for a compile's `Program`.
*
* Walks every unit's AST once, which is a second traversal of the whole
* program — hence the flag.
*/
export function reportCensus(program: Program): void {
let ast = new Table();
let side = new Table();
let other = new Table();
var nodeCount = 0;
var withLocation = 0;
var sourceBytes = 0;
var commentCount = 0;
for (let unit in program.units) {
walkEnter(unit.ast, (n) => {
nodeCount += 1;
ast.add(nodeKindName(n), 1, objectBytes(nodeFieldCount(n)));
if (n.loc != null) { withLocation += 1; }
});
sourceBytes = sourceBytes + unit.ast.source.length;
commentCount = commentCount + unit.ast.comments.length;
let m = unit.model;
// The dense tables cost one 4-byte slot per id in the module's
// range, present or not, plus the array header; entries for nodes
// minted after parsing are map entries as before.
let range = (m.lastNodeId as i32) - (m.firstNodeId as i32) + 1;
let denseBytes = (if (range > 0) range * 4 + 32 else 0);
side.add("nodeTypes (dense)", m.nodeTypes.size, denseBytes);
side.add("parents (dense)", m.parents.size, denseBytes);
side.add("memberKeys", m.memberKeys.size, mapEntryBytes(m.memberKeys.size));
side.add("bindingTypes", m.bindingTypes.size, mapEntryBytes(m.bindingTypes.size));
side.add("staticAccesses", m.staticAccesses.size, mapEntryBytes(m.staticAccesses.size));
side.add("recordAdaptations", m.recordAdaptations.size,
mapEntryBytes(m.recordAdaptations.size));
side.add("interfaceAdaptations", m.interfaceAdaptations.size,
mapEntryBytes(m.interfaceAdaptations.size));
side.add("functionAdaptations", m.functionAdaptations.size,
mapEntryBytes(m.functionAdaptations.size));
side.add("unionCallCalleeTypes", m.unionCallCalleeTypes.size,
mapEntryBytes(m.unionCallCalleeTypes.size));
side.add("originalArgCounts", m.originalArgCounts.size,
mapEntryBytes(m.originalArgCounts.size));
side.add("defaultArgsOwners", m.defaultArgsOwners.size,
mapEntryBytes(m.defaultArgsOwners.size));
side.add("defaultArgParamNames", m.defaultArgParamNames.size,
mapEntryBytes(m.defaultArgParamNames.size));
side.add("scopeExitDrops", m.scopeExitDrops.size,
mapEntryBytes(m.scopeExitDrops.size));
side.add("ownDropIntervals", m.ownDropIntervals.size,
mapEntryBytes(m.ownDropIntervals.size));
side.add("assignmentReleases", m.assignmentReleases.size,
mapEntryBytes(m.assignmentReleases.size));
side.add("fieldTakes", m.fieldTakes.size,
mapEntryBytes(m.fieldTakes.size));
side.add("scopedFieldStores", m.scopedFieldStores.size,
mapEntryBytes(m.scopedFieldStores.size));
side.add("revivingStores", m.revivingStores.size,
mapEntryBytes(m.revivingStores.size));
side.add("edgeDrops", m.edgeDrops.size, mapEntryBytes(m.edgeDrops.size));
side.add("exitDrops", m.exitDrops.size, mapEntryBytes(m.exitDrops.size));
side.add("movedOutFields", m.movedOutFields.size,
mapEntryBytes(m.movedOutFields.size));
side.add("symbolDependencies", m.symbolDependencies.size,
mapEntryBytes(m.symbolDependencies.size));
side.add("nodeDependencies", m.nodeDependencies.size,
mapEntryBytes(m.nodeDependencies.size));
side.add("symbolNames", m.symbolNames.size, mapEntryBytes(m.symbolNames.size));
side.add("classDeclarations", m.classDeclarations.size,
mapEntryBytes(m.classDeclarations.size));
side.add("interfaceDeclarations", m.interfaceDeclarations.size,
mapEntryBytes(m.interfaceDeclarations.size));
side.add("mixinDeclarations", m.mixinDeclarations.size,
mapEntryBytes(m.mixinDeclarations.size));
side.add("enumDeclarations", m.enumDeclarations.size,
mapEntryBytes(m.enumDeclarations.size));
side.add("globalDeclarations", m.globalDeclarations.size,
orderedEntryBytes(m.globalDeclarations.size));
}
let index = program.modelIndex;
// Parsed nodes are indexed by module range (a ModelRange of three
// fields per module); only nodes minted after parsing get an entry.
side.add("index.ranges", index.rangeCount, index.rangeCount * objectBytes(3));
side.add("index.nodeToModel (overflow)", index.overflowCount,
mapEntryBytes(index.overflowCount));
side.add("index.symbolToModel", index.symbolToModel.size,
mapEntryBytes(index.symbolToModel.size));
// One SourceLocation per node that has one: start, end, path. The
// parser mints a fresh one per node, never shared.
other.add("SourceLocation", withLocation, withLocation * objectBytes(3));
// Comment: value, isBlock, start, end, line, column — plus the
// String view over the module source that `value` is.
other.add("Comment", commentCount, commentCount * objectBytes(6));
other.add("Comment value (String)", commentCount, commentCount * objectBytes(5));
// Module.source holds the whole file; every String sliced out of it
// keeps the same ByteArray alive, so this is counted once per unit.
other.add("Module source (ByteArray)", program.units.length,
sourceBytes + 16 * program.units.length);
console.log("");
console.log("=== memory census ===");
printTable("AST nodes", ast, 25);
printTable("semantic model side tables", side, 20);
printTable("other retained", other, 10);
console.log("");
console.log("-- totals");
line("units", program.units.length);
line("AST nodes", nodeCount);
line("nodes with a location", withLocation);
line("source bytes", sourceBytes);
line("comments", commentCount);
console.log("");
console.log("-- minted over the process (not all live)");
line("Types, all kinds", typesCreated());
line(" ClassType", classTypesCreated());
line(" FunctionType", functionTypesCreated());
line(" InterfaceType", interfaceTypesCreated());
line(" MixinType", mixinTypesCreated());
line(" TypeParameterType", typeParameterTypesCreated());
line("unions interned (distinct)", unionInternMisses());
line("unions served from the table", unionInternHits());
line("unions built fresh (uninternable member)", unionInternFresh());
line(" first such member: class instance", unionFreshByKind(0));
line(" interface instance", unionFreshByKind(1));
line(" function", unionFreshByKind(2));
line(" array", unionFreshByKind(3));
line(" tuple", unionFreshByKind(4));
line(" record", unionFreshByKind(5));
line(" alias", unionFreshByKind(6));
line(" union", unionFreshByKind(7));
line(" other", unionFreshByKind(8));
line("type key strings cached", typeKeysCached());
line(" distinct keys (structurally distinct)", distinctTypeKeys());
line("type key string bytes", typeKeyBytes());
line("instantiation cache hits", instantiationHits());
line("instantiation cache misses", instantiationMisses());
line("nominal substitutions built", substitutedNominals());
line("nominal substitutions cached", substitutionCacheHits());
line("function types shared", functionTypeHits());
line(" of built, parametric (uncacheable)", parametricSubstitutions());
console.log("");
console.log("-- types minted per phase (total / class / function / interface)");
var prevTotal = 0;
var prevClasses = 0;
var prevFunctions = 0;
var prevInterfaces = 0;
for (let mark in typeMarks()) {
console.log(` ${padRight(mark.label, 32)}${padLeft(i32ToString(mark.total - prevTotal), 11)}${padLeft(i32ToString(mark.classes - prevClasses), 9)}${padLeft(i32ToString(mark.functions - prevFunctions), 9)}${padLeft(i32ToString(mark.interfaces - prevInterfaces), 9)}`);
prevTotal = mark.total;
prevClasses = mark.classes;
prevFunctions = mark.functions;
prevInterfaces = mark.interfaces;
}
console.log("");
console.log("-- FunctionTypes by substitution site");
line("checker substituteInType", codegenFunctionTypeSite(5));
line("checker instantiateFunctionType", codegenFunctionTypeSite(6));
line("codegen substituteTypeParams", codegenFunctionTypeSite(0));
line("codegen class ctor copy", codegenFunctionTypeSite(1));
line("codegen substituteThisType", codegenFunctionTypeSite(2));
line("codegen erase ctor copy", codegenFunctionTypeSite(3));
line("codegen eraseTypeParameters", codegenFunctionTypeSite(4));
line("codegen mapMixinThisInType", codegenFunctionTypeSite(7));
line("codegen mapMixinThis ctor copy", codegenFunctionTypeSite(8));
line("codegen-utils substituteTypeParams", codegenFunctionTypeSite(10));
console.log("");
console.log("-- codegen substitution (outermost calls)");
line("calls", codegenSubstCalls());
line(" returning the input unchanged", codegenSubstUnchanged());
line(" distinct (input, arguments)", codegenSubstDistinct());
console.log("");
console.log("-- retained, by group (MiB)");
console.log(` ${padRight("AST nodes", 32)}${padLeft(mib(ast.totalBytes()), 11)}`);
console.log(` ${padRight("side tables", 32)}${padLeft(mib(side.totalBytes()), 11)}`);
console.log(` ${padRight("locations, comments, source", 32)}${padLeft(mib(other.totalBytes()), 11)}`);
console.log(` ${padRight("type key strings", 32)}${padLeft(mib(typeKeyBytes()), 11)}`);
}
- 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 |
|
|