/** * WIT-typed modules, synthesized: the source text behind an * `import {now} from 'wasi:clocks/monotonic-clock'`. * * A WIT-backed package (`{"wit": "./path"}` in the manifest) resolves * its modules to `wit:#:` canonical * paths, and the compiler host answers `readFile` for those by calling * `synthesizeWitModule` here: read the root's WIT back through the * host, parse it, find the interface, and render its declarations as * Zena typed *from the WIT* — the checker then sees the interface's * real signatures rather than whatever an author transcribed. * * This module is imported by the drivers (the CLI's host, the test * hosts), never by compiler-lib code — the same edge as * `wit-imports.zena`, and for the same reason: it keeps the WIT parser * out of the module graphs of hosts that do not serve WIT-backed * packages, like the language service. * * The rendered surface, per Part 5's mapping * (docs/design/component-model.md): * * - Named types are declared: `enum` → Zena enum with explicit * ordinals, `flags` → distinct u32 with per-label constants, * `record` → case class, `variant` → sealed case-class hierarchy * (case classes prefixed with the variant's name, because two * variants in one interface may declare same-named cases). * - A flat-scalar function is one `@external` declaration. Staged * parameters (`string`, `list`) and lifted results ride a * wrapper over `zena:wasi`, as before. * - A result that flattens past one core value spills: the raw call * takes a return-area address, the canonical ABI writes the value * there with our `realloc`, and generated lift code reads it out at * the canonical offsets — records, variants, options, tuples and * lists of all of these, recursively, freeing every host-written * buffer as it goes. A top-level `result` lifts into the * inline `Result`; a nested one waits. * - Parameters spill the other way: past sixteen core values on a * synchronous call, or four on an asynchronous one (a method's * `self` handle counts), the wrapper stages one buffer laid out * like a record, stores each parameter at its aligned offset, and * the raw call takes that address as its one argument. The buffer * is freed with the wrapper's other staging, after the call — or, * for an async lowering, after the subtask has returned. * * - `stream` in any position is `zena:stream`'s `Stream`: one * end-handle on the wire, connected by `zena:wasi`'s * pumps (`lowerByteStream` going in, `liftByteStream` coming out). * - `future` in any position is a `Future`: one end-handle on the * wire, moved by generated per-payload-type helpers over the * `future.*` canon builtins (each declared at the payload's own * component type, `future:#`). A `result` * payload is a stored `Result`, and a bare result arm — `result<_, E>` * anywhere — is a `void` lane filled by `witUnit()`. * * A function whose signature needs more — non-u8 stream elements, * bare futures, variant payloads joining across core types — is * listed in the synthesized module's header comment with its reason, * and importing it reports a missing export. */ import { StringBuilder, growable } from 'zena:core'; import { parse, parseSyntax } from 'zena-lang:wit-parser'; import { findInterface, findInterfaceOrNull, FoundInterface } from 'zena-lang:wit-parser/document'; import { expandedWorldItems } from 'zena-lang:wit-parser/component-encoder'; import { InterfaceItem, InterfaceItemTag, NamedFunc, Type, TypeTag, TypeDef, TypeDefTag, Id, EnumCaseDef, FlagDef, Field, Case, ResourceFunc, ResourceFuncTag, Ast, PackageName, Use, UsePath, IdUsePath, PackageUsePath, UsePathTag, AstItemTag, WorldDef, WorldItemTag, Export, ExternKindTag, Func } from 'zena-lang:wit-parser/parser'; import { Module } from './ast.zena'; import { CompilerHost } from './library-loader.zena'; import { readWitSource } from './wit-source.zena'; import { withWasiPackages } from './codegen/wit-imports.zena'; import { ComponentEntryWrapper, componentEntryPathFor, componentEntrySpecifierFor, componentExportSuffix, resourceWrapperBase, mainWrapperResultOf, mainWrapperAbiImports, hasAsyncMain, renderMainWrapper, renderWrapperHeader, exportedFunctionIsAsync, classHasStatic, componentSyncExportSuffix } from './component-entry.zena'; import { zena, emit, ZenaTemplate } from './code-template.zena'; /** Whether `path` is a synthesized WIT module's canonical path. */ export function isWitModulePath(path: String): boolean { return path.startsWith("wit:"); } /** * The WIT source the module being synthesized was parsed from. A * future's canon type spelling carries its payload's source text, * and classification — which sees only nodes — slices it out by span. */ var currentWitSource = ""; /** * The parsed document and the package whose interface classification * is currently reading — a `use` hop switches the package (a bare * `use foo` resolves against the interface's own package, and a * nested package's is not the document's main one). */ var currentAst: Ast | null = null; /** The entry module's syntax, for what implements each export. */ var currentEntryAst: Module | null = null; /** * The document last parsed, by its text: every synthesized module of * a program reads the same spliced corpus, and parsing it is most of * a synthesis. The AST is only read, so one serves every module. */ var memoSource = ""; var memoAst: Ast | null = null; function parsedWit(source: String) { let cached = memoAst; if (cached != null && memoSource == source) { return cached; } let ast = parse(source); memoSource = source; memoAst = ast; return ast; } var currentPackage: PackageName | null = null; /** * Which synthesized module declares the types classification meets: * the unversioned `ns:pkg/iface` specifier. `selfSpecifier` is the * module being synthesized; `currentSpecifier` tracks `use` hops, and * a named type minted under a foreign specifier owes an import line * from that sibling module rather than a local declaration. */ var selfSpecifier = ""; var currentSpecifier = ""; /** * The interfaces whose resources render as `resource class` — an * `own` is `Own`, released at scope exit unless moved, a `borrow` * is `Borrow`, and a use after a move is a compile error — rather * than as a `Disposable` class with a runtime moved flag that the * program must `using` or dispose by hand. Every interface should be * here; the list exists because the switch changes every signature a * consumer sees, so it moves one interface at a time, as its * consumers in the standard library and the packages migrate * (docs/design/component-model.md, Part 6). An interface whose * consumer the checked-in bootstrap compiles (`wasi:filesystem`, through * `zena:fs` in the compiler's own closure) can only join after a * reseed carries this rendering. Keyed by the specifier without its * version, the form `currentSpecifier` carries. */ let ownedResourceSpecifiers = [ 'zena:host/process', 'zena:host/wasm', 'wasi:filesystem/types', 'wasi:http/types', 'zena:host/http-server', 'zena:host/terminal' ]; function rendersAsResourceClass(specifier: String): boolean { for (let s in ownedResourceSpecifiers) { if (s == specifier) { return true; } } return false; } /** The `zena:core` import line for the handle spellings a module used, * or "" when it used none. */ function handleImports(uses: SynthUses) { let names = new Array(); if (uses.ownHandle) { names.push("Own"); } if (uses.borrowHandle) { names.push("Borrow"); } if (uses.unmanagedHandle) { names.push("Unmanaged"); } if (uses.disown) { names.push("disown"); } if (names.length == 0) { return ""; } var list = names[0]; for (var i = 1; i < names.length; i += 1) { list = `${list}, ${names[i]}`; } return `import { ${list} } from 'zena:core';\n`; } /** One imported type name owed to a sibling synthesized module. */ final class UsedTypeImport { specifier: String; name: String; new(this.specifier, this.name); } var usedTypeImports = new Array(); /** * An interface the export wrapper being written provides, by the * specifier its types classify under and the qualified name the canon * builtins spell. A resource declared in one is the program's own * class, exported through the wrapper, rather than a handle class of * a synthesized module. */ final class ExportedInterface { specifier: String; qualified: String; new(this.specifier, this.qualified); } var exportedInterfaces = new Array(); /** The qualified name of the exported interface at `specifier`, or * "" when the wrapper does not export it. */ function exportedQualifiedOf(specifier: String) { for (let e in exportedInterfaces) { if (e.specifier == specifier) { return e.qualified; } } return ""; } /** * A resource the program provides: its class (imported from the * entry), the WIT name (the table helpers are named after it), and * the interface declaring it (the canon `resource.new` names its * type). */ final class ProgramResource { className: String; witName: String; qualified: String; new(this.className, this.witName, this.qualified); } var programResources = new Array(); function noteProgramResource(className: String, witName: String, qualified: String) { for (let existing in programResources) { if (existing.className == className) { return; } } programResources.push(new ProgramResource(className, witName, qualified)); } function noteUsedImport(specifier: String, name: String) { for (let existing in usedTypeImports) { if (existing.specifier == specifier && existing.name == name) { return; } } usedTypeImports.push(new UsedTypeImport(specifier, name)); } /** A span's source text with whitespace runs collapsed to one space, * so it can ride inside a generated string literal. */ function spanText(start: i32, end: i32) { var out = ""; var pendingSpace = false; for (var i = start; i < end; i += 1) { let c = currentWitSource.getByteAt(i); if (c == 32 || c == 9 || c == 10 || c == 13) { pendingSpace = out != ""; continue; } if (pendingSpace) { out = out + " "; pendingSpace = false; } out = out + currentWitSource.sliceBytes(i, i + 1); } return out; } /** How a WIT type crosses the boundary in the rendered slice. */ enum TyKind { /** One core value, passed through: the Zena spelling is `scalar`. */ Scalar, /** `string`: `(ptr, len)` on the wire. */ Str, /** `list`: the same wire shape as a string. */ BytesList, /** `list` for any other liftable `T`. */ ListT, /** A WIT `enum`: one discriminant on the wire, a Zena enum here. */ Enumeration, /** A WIT `flags`: one bitset word on the wire, a distinct u32 here. */ Flags, /** A WIT `record`: a case class. */ RecordT, /** A WIT `variant`: a sealed case-class hierarchy. */ VariantT, /** `option`: `Option`. */ OptionT, /** `result`: `inline Result` at top level. */ ResultT, /** `tuple<...>`: an inline tuple. */ TupleT, /** A resource handle (`own`, `borrow`, or a bare resource name): * one i32 index on the wire, a Disposable wrapper class here. */ ResourceH, /** `stream`: one end-handle i32 on the wire, `zena:stream`'s * `Stream` here, pumped by `zena:wasi`. */ StreamH, /** `future`: one end-handle i32 on the wire, a `Future` here, * read and written by generated per-payload-type helpers. */ FutureH, /** Waits on the interop stages; `reason` says which. */ Unsupported } /** * A classified WIT type with its canonical layout: `size`/`align` are * the canonical ABI's, `flats` the count of core values the type * flattens to. Children: a record's or tuple's members, a list's * element, an option's inner, a result's ok/err, a variant's payloads * — with the void sentinel standing in for an absent payload. */ final class Ty { kind: TyKind; /** The Zena spelling of a Scalar; "" otherwise. */ scalar: String; /** The synthesized Zena type name of a named type. */ typeName: String; reason: String; /** Enum/variant case count, or flags label count. */ var caseCount = 0; children = new Array(); /** Record field names (camelCase) or variant case names (Pascal, * already prefixed with the variant's own name). */ childNames = new Array(); var size = 0; var align = 1; var flats = 0; /** ResourceH only: whether this position borrows rather than owns. * Everywhere else a resource in value position is an implicit * `own`, which consumes — the wrapper is marked moved when lowered. */ var isBorrow = false; /** ResourceH only: whether the resource is the program's own — one * an exported interface declares, implemented by the program's class * — rather than a handle class of a synthesized module. Its wire * form is the representation, an index into the wrapper's table. */ var isProgram = false; /** ResourceH only: the resource's WIT name, which the wrapper's * table helpers are named after. */ var resourceName = ""; /** ResourceH only: whether the handle class is a `resource class`, * so that this position spells a handle — `Own` for an own in a * bare position or a tuple member there, `Borrow` for a borrow, * `Unmanaged` for an own inside a list, record or variant * payload, which cannot hold an owner. See `rendersAsResourceClass`. */ var ownedClass = false; /** Whether this type sits inside a list, record or variant payload, * directly or through tuples, options and results (`markInAggregate`): * an aggregate's member cannot carry an affine type, so an own handle * there is `Unmanaged`, for the program to `adopt`. */ var inAggregate = false; /** FutureH only: the payload's WIT source text, whitespace * collapsed — the canon type spelling the generated builtins name. */ var witText = ""; new(this.kind, this.scalar = "", this.typeName = "", this.reason = ""); } function unsupported(reason: String) { return new Ty(TyKind.Unsupported, "", "", reason); } /** * Mark `ty` as a list element, record field or variant payload, along * with the members of a tuple, option or result it is, which sit in * the same aggregate. A tuple is not an aggregate itself: a tuple in a * bare position, such as a stream element or a function's result, * carries owners (`(Own, Own)`). */ function markInAggregate(ty: Ty): void { ty.inAggregate = true; if (ty.kind == TyKind.TupleT || ty.kind == TyKind.OptionT || ty.kind == TyKind.ResultT) { for (let child in ty.children) { markInAggregate(child); } } } /** * A named type just classified: when it belongs to another interface * (the classification is inside a `use` hop), its Zena declarations * live in that interface's synthesized module, so the current module * imports them — the sealed base and every case, for a variant. */ function noteNamedType(ty: Ty) { if (currentSpecifier == selfSpecifier || ty.typeName == "") { return; } noteUsedImport(currentSpecifier, ty.typeName); if (ty.kind == TyKind.VariantT) { for (let caseName in ty.childNames) { noteUsedImport(currentSpecifier, caseName); } } } /** The stand-in for an absent variant payload or result arm. */ function voidTy() { let ty = new Ty(TyKind.Scalar, "void"); ty.size = 0; ty.align = 1; ty.flats = 0; return ty; } function isVoid(ty: Ty) { return ty.kind == TyKind.Scalar && ty.scalar == "void"; } /** `x` rounded up to a power-of-two alignment `a`. */ function alignTo(x: i32, a: i32) { if (a <= 1) { return x; } let r = x & (a - 1); return if (r == 0) x else x + a - r; } /** The canonical discriminant size for `count` cases. */ function discSize(count: i32): i32 { if (count <= 256) { return 1; } if (count <= 65536) { return 2; } return 4; } function scalarTy(spelling: String, size: i32) { let ty = new Ty(TyKind.Scalar, spelling); ty.size = size; ty.align = size; ty.flats = 1; return ty; } function pairTy(kind: TyKind) { let ty = new Ty(kind); ty.size = 8; ty.align = 4; ty.flats = 2; return ty; } /** Lay out a variant-shaped type: a discriminant then the aligned * payload area, sized for the largest case. */ function layoutVariant(ty: Ty, count: i32) { let disc = discSize(count); var payloadAlign = 1; var payloadSize = 0; var maxFlats = 0; for (let child in ty.children) { if (child.align > payloadAlign) { payloadAlign = child.align; } if (child.size > payloadSize) { payloadSize = child.size; } if (child.flats > maxFlats) { maxFlats = child.flats; } } ty.align = if (disc > payloadAlign) disc else payloadAlign; ty.size = alignTo(alignTo(disc, payloadAlign) + payloadSize, ty.align); ty.flats = 1 + maxFlats; ty.caseCount = count; } /** A variant-shaped type's payload offset. */ function payloadOffset(ty: Ty) { var payloadAlign = 1; for (let child in ty.children) { if (child.align > payloadAlign) { payloadAlign = child.align; } } return alignTo(discSize(ty.caseCount), payloadAlign); } /** Lay out a record-shaped type: fields at their aligned offsets. */ function layoutRecord(ty: Ty) { var offset = 0; var maxAlign = 1; var flats = 0; for (let child in ty.children) { if (child.align > maxAlign) { maxAlign = child.align; } offset = alignTo(offset, child.align) + child.size; flats += child.flats; } ty.align = maxAlign; ty.size = alignTo(offset, maxAlign); ty.flats = flats; } /** A record-shaped type's field offsets, in declaration order. */ function fieldOffsets(ty: Ty) { let offsets = new Array(); var offset = 0; for (let child in ty.children) { offset = alignTo(offset, child.align); offsets.push(offset); offset += child.size; } return offsets; } /** * Classify a WIT type for rendering, with its canonical layout. A * named type resolves through the interface's own declarations — * aliases transparently, enums/flags/records/variants to their * synthesized Zena types. */ function classifyType(t: Type, ifaceItems: GrowableArray): Ty { match (t.tag) { case TypeTag.Bool: { return scalarTy("boolean", 1); } case TypeTag.U8: { return scalarTy("u8", 1); } case TypeTag.U16: { return scalarTy("u16", 2); } case TypeTag.U32: { return scalarTy("u32", 4); } case TypeTag.U64: { return scalarTy("u64", 8); } case TypeTag.S8: { return scalarTy("i8", 1); } case TypeTag.S16: { return scalarTy("i16", 2); } case TypeTag.S32: { return scalarTy("i32", 4); } case TypeTag.S64: { return scalarTy("i64", 8); } case TypeTag.F32: { return scalarTy("f32", 4); } case TypeTag.F64: { return scalarTy("f64", 8); } case _: {} } if (t.tag == TypeTag.String) { return pairTy(TyKind.Str); } if (t.tag == TypeTag.List) { if (t.fixedLength >= 0) { return unsupported("fixed-length lists wait on the interop stages"); } let element = classifyType(t.inner as Type, ifaceItems); if (element.kind == TyKind.Unsupported) { return element; } if (element.kind == TyKind.Scalar && element.scalar == "u8") { return pairTy(TyKind.BytesList); } let ty = pairTy(TyKind.ListT); markInAggregate(element); ty.children.push(element); return ty; } if (t.tag == TypeTag.Option) { let inner = classifyType(t.inner as Type, ifaceItems); if (inner.kind == TyKind.Unsupported) { return inner; } let ty = new Ty(TyKind.OptionT); ty.children.push(inner); layoutVariant(ty, 2); return ty; } if (t.tag == TypeTag.Result) { let ok = t.okType; let err = t.errType; let okTy = if (ok == null) voidTy() else classifyType(ok as Type, ifaceItems); let errTy = if (err == null) voidTy() else classifyType(err as Type, ifaceItems); if (okTy.kind == TyKind.Unsupported) { return okTy; } if (errTy.kind == TyKind.Unsupported) { return errTy; } let ty = new Ty(TyKind.ResultT); ty.children.push(okTy); ty.children.push(errTy); layoutVariant(ty, 2); return ty; } if (t.tag == TypeTag.Tuple) { let ty = new Ty(TyKind.TupleT); for (let member in t.types as GrowableArray) { let child = classifyType(member, ifaceItems); if (child.kind == TyKind.Unsupported) { return child; } ty.children.push(child); } layoutRecord(ty); return ty; } if (t.tag == TypeTag.Stream) { let element = t.inner; if (element == null) { return unsupported("a bare stream waits on the interop stages"); } let elementType = element as Type; let el = classifyType(elementType, ifaceItems); if (el.kind == TyKind.Unsupported) { return el; } let ty = new Ty(TyKind.StreamH); ty.size = 4; ty.align = 4; ty.flats = 1; if (el.kind == TyKind.Scalar && el.scalar == "u8") { // Bytes: `zena:wasi`'s pumps, with no element marshaling. return ty; } // Any other element rides a generated pair of pumps that lift and // lower each element through memory, so the element must move // both ways. let unliftable = liftBlocker(el, true); if (unliftable != "") { return unsupported(unliftable); } let unlowerable = lowerBlocker(el); if (unlowerable != "") { return unsupported(unlowerable); } ty.children.push(el); ty.witText = spanText(elementType.span.start, elementType.span.end); return ty; } if (t.tag == TypeTag.Future) { let inner = t.inner; if (inner == null) { return unsupported("a bare future waits on the interop stages"); } let payloadType = inner as Type; let payload = classifyType(payloadType, ifaceItems); if (payload.kind == TyKind.Unsupported) { return payload; } let ty = new Ty(TyKind.FutureH); ty.children.push(payload); ty.size = 4; ty.align = 4; ty.flats = 1; ty.witText = spanText(payloadType.span.start, payloadType.span.end); return ty; } if (t.tag == TypeTag.Own || t.tag == TypeTag.Borrow) { let inner = t.inner as Type; if (inner.tag != TypeTag.Name) { return unsupported("own/borrow of an unnamed type"); } let resolved = classifyNamed((inner.name as Id).name, ifaceItems); if (resolved.kind != TyKind.ResourceH && resolved.kind != TyKind.Unsupported) { return unsupported("own/borrow of a non-resource type"); } if (resolved.kind == TyKind.ResourceH) { resolved.isBorrow = t.tag == TypeTag.Borrow; } return resolved; } if (t.tag == TypeTag.Name) { return classifyNamed((t.name as Id).name, ifaceItems); } return unsupported("this type waits on the interop stages"); } /** Classify a type by its declared name in the interface. */ function classifyNamed(name: String, ifaceItems: GrowableArray): Ty { for (let item in ifaceItems) { if (item.tag != InterfaceItemTag.TypeDef) { continue; } let td = item.typeDef as TypeDef; if (td.name.name != name) { continue; } if (td.tag == TypeDefTag.Alias) { return classifyType(td.aliasType as Type, ifaceItems); } if (td.tag == TypeDefTag.Resource) { let ty = new Ty(TyKind.ResourceH, "", pascalName(name)); ty.size = 4; ty.align = 4; ty.flats = 1; ty.resourceName = name; let qualified = exportedQualifiedOf(currentSpecifier); if (qualified != "") { // The program's own: its class comes from the entry, not // from a synthesized module. ty.isProgram = true; noteProgramResource(ty.typeName, name, qualified); return ty; } ty.ownedClass = rendersAsResourceClass(currentSpecifier); noteNamedType(ty); return ty; } if (td.tag == TypeDefTag.Enum) { let cases = td.enumCases as GrowableArray; let ty = new Ty(TyKind.Enumeration, "", pascalName(name)); ty.caseCount = cases.length; ty.size = discSize(cases.length); ty.align = ty.size; ty.flats = 1; noteNamedType(ty); return ty; } if (td.tag == TypeDefTag.Flags) { let flags = td.flags as GrowableArray; let ty = new Ty(TyKind.Flags, "", pascalName(name)); ty.caseCount = flags.length; ty.size = if (flags.length <= 8) 1 else if (flags.length <= 16) 2 else 4; ty.align = ty.size; ty.flats = 1; noteNamedType(ty); return ty; } if (td.tag == TypeDefTag.Record) { let ty = new Ty(TyKind.RecordT, "", pascalName(name)); for (let f in td.fields as GrowableArray) { let child = classifyType(f.type, ifaceItems); if (child.kind == TyKind.Unsupported) { return child; } markInAggregate(child); ty.children.push(child); ty.childNames.push(camelName(f.name.name)); } layoutRecord(ty); noteNamedType(ty); return ty; } if (td.tag == TypeDefTag.Variant) { let ty = new Ty(TyKind.VariantT, "", pascalName(name)); let cases = td.cases as GrowableArray; for (let c in cases) { let payload = c.type; let child = if (payload == null) voidTy() else classifyType(payload as Type, ifaceItems); if (child.kind == TyKind.Unsupported) { return child; } markInAggregate(child); ty.children.push(child); // Prefixed with the variant's name: two variants in one // interface may declare same-named cases, and sealed cases // are module-level classes. ty.childNames.push(pascalName(name) + pascalName(c.name.name)); } layoutVariant(ty, cases.length); noteNamedType(ty); return ty; } break; } // Not declared here: a `use` may bring the name in from another // interface, whose synthesized module then owns the declarations. for (let item in ifaceItems) { if (item.tag != InterfaceItemTag.Use) { continue; } let use = item.use as Use; for (let n in use.names) { let asName = n.asName; if (asName != null) { if ((asName as Id).name == name) { return unsupported( "a renaming `use` waits on the interop stages"); } continue; } if (n.name.name != name) { continue; } return classifyUsed(use, name); } } return unsupported(`the named type '${name}' waits on the interop stages`); } /** * Classify a `use`d name in its source interface's context: the * package switches for the hop (a bare `use foo` resolves against * the interface's own package), and the specifier switches so named * types minted inside record their sibling-module imports. */ function classifyUsed(use: Use, name: String): Ty { let ast = currentAst; let pkg = currentPackage; if (ast == null || pkg == null) { return unsupported("`use` resolution has no document context"); } let from = use.from; var ns = (pkg as PackageName).namespace.name; var path = ""; if (from is IdUsePath) { path = (pkg as PackageName).name.name + "/" + ((from as IdUsePath).id as Id).name; } else { let p = (from as PackageUsePath).packageId as PackageName; ns = p.namespace.name; path = `${p.name.name}/${((from as PackageUsePath).name as Id).name}`; } let target = findInterfaceOrNull(ast as Ast, ns, path); if (target == null) { return unsupported("`use` names '" + ns + ":" + path + "', which this package's WIT does not declare"); } let found = target as FoundInterface; let savedPackage = currentPackage; let savedSpecifier = currentSpecifier; currentPackage = found.packageName; currentSpecifier = `${ns}:${path}`; let ty = classifyNamed(name, found.def.items); currentPackage = savedPackage; currentSpecifier = savedSpecifier; return ty; } /** * `wait-for` → `waitFor`: a WIT name as a Zena identifier * (docs/design/component-model.md, Part 5's name mapping). * * TODO: consider moving this into a utilities package, and benchmark a * linear character copy against this slicing — the output can be * pre-allocated at `kebab.length`, since it only ever shrinks. */ function camelName(kebab: String): String { var out = ""; var upper = false; for (var i = 0; i < kebab.length; i += 1) { let c = kebab.getByteAt(i); if (c == 45) { // '-' upper = true; continue; } var piece = kebab.sliceBytes(i, i + 1); if (upper) { piece = piece.asciiUpperCase(); upper = false; } out = out + piece; } return out; } /** `error-code` → `ErrorCode`: a WIT type name as a Zena type name. */ function pascalName(kebab: String): String { let camel = camelName(kebab); if (camel.length == 0) { return camel; } return camel.sliceBytes(0, 1).asciiUpperCase() + camel.sliceBytes(1, camel.length); } /** One memory-lift helper owed to the module: `name(ptr) -> ty`. */ final class LiftEntry { key: String; name: String; ty: Ty; new(this.key, this.name, this.ty); } /** One future payload type the module moves: owed its per-type canon * builtin declares and its lift/lower helpers. */ final class FutureEntry { /** The payload's WIT text — the dedup key and the canon spelling. */ key: String; /** This entry's suffix in generated names (`liftFuture0`). */ index: i32; /** The FutureH that registered it. */ ty: Ty; new(this.key, this.index, this.ty); } /** What one module's rendering pulled in, for its import lines. */ final class SynthUses { var hasAsync = false; /** Whether a plugin kind's `create` was written — pulls in `claimPlugin`. */ var plugin = false; var fixedArray = false; var array = false; var error = false; var option = false; var result = false; /** Whether a `stream` position rendered — pulls in `Stream`. */ var stream = false; /** The `zena:wasi` names used, in first-use order. */ abi = new Array(); /** The `zena:wasi` names used, in first-use order. */ componentStream = new Array(); /** Enums lifted from discriminants, each owed a range-checked lift. */ enumLifts = new Array(); /** Memory-lift helpers owed, discovered recursively; `emitted` * tracks how many have been rendered so far. */ lifts = new Array(); var emittedLifts = 0; /** Aggregate types lifted from flat core values — an export's * parameters — each owed a helper taking the slots. */ flatLifts = new GrowableArray(); var emittedFlatLifts = 0; /** Whether anything was staged through the arena — the wrapper then * ends its call with `releaseStaged()`. */ var stagedAny = false; /** Fresh-name counter for generated locals. */ var tmpCount = 0; /** Whether any resource class rendered — pulls in Disposable and * the module's handle symbol. */ var anyResource = false; /** The handle spellings a `resource class` position used, each * pulling in its `zena:core` name; `disown` is what hands an owned * handle to the host, or marks a lifted one that sits in an * aggregate as unmanaged. */ var ownHandle = false; var borrowHandle = false; var unmanagedHandle = false; var disown = false; /** Whether generated code parks on `awaitWaitable`. */ var awaitWaitable = false; /** Whether a bare result arm rendered — pulls in the `witUnit` * helper, the one spellable void value. */ var unit = false; /** Future payload types moved, each owed declares and helpers. */ futures = new Array(); /** Typed stream element types moved — anything but `u8`, whose * pumps live in `zena:wasi` — each owed declares and helpers. */ streams = new Array(); /** How many of `streams` have had their helpers emitted. */ var emittedStreams = 0; /** Whether a typed stream rendered — pulls in `StreamWriter`. */ var streamWriter = false; /** How many of `futures` have had their helpers emitted. */ var emittedFutures = 0; /** Whether a lifted future rendered — pulls in `DeferredFuture`, * since a lifted future's read starts on its first await. */ var deferred = false; nextTmp(): i32 { let n = this.tmpCount; this.tmpCount += 1; return n; } useAbi(name: String): void { for (let existing in this.abi) { if (existing == name) { return; } } this.abi.push(name); } useComponentStream(name: String): void { for (let existing in this.componentStream) { if (existing == name) { return; } } this.componentStream.push(name); } /** The generated-name suffix for `ty`'s stream element, * registering the entry on first sight. */ streamIndexOf(ty: Ty): i32 { for (let existing in this.streams) { if (existing.key == ty.witText) { return existing.index; } } let index = this.streams.length; this.streams.push(new FutureEntry(ty.witText, index, ty)); return index; } /** The generated-name suffix for `ty`'s future payload, * registering the entry on first sight. */ futureIndexOf(ty: Ty): i32 { for (let existing in this.futures) { if (existing.key == ty.witText) { return existing.index; } } let index = this.futures.length; this.futures.push(new FutureEntry(ty.witText, index, ty)); return index; } needEnumLift(ty: Ty): void { for (let existing in this.enumLifts) { if (existing.typeName == ty.typeName) { return; } } this.error = true; this.enumLifts.push(ty); } /** The helper name for lifting `ty` from flat slots, registering it. */ flatLiftNameOf(ty: Ty): String { let key = structuralKey(ty); for (let existing in this.flatLifts) { if (existing.key == key) { return existing.name; } } let name = if (ty.typeName != "") { "liftFlat" + ty.typeName } else { "liftFlatVal" + i32ToString(this.flatLifts.length) }; this.flatLifts.push(new LiftEntry(key, name, ty)); return name; } /** The helper name for lifting `ty` from memory, registering it. */ liftNameOf(ty: Ty): String { let key = structuralKey(ty); for (let existing in this.lifts) { if (existing.key == key) { return existing.name; } } let name = if (ty.typeName != "") { "lift" + ty.typeName } else { "liftVal" + i32ToString(this.lifts.length) }; this.lifts.push(new LiftEntry(key, name, ty)); return name; } } /** A structural key for lift-helper dedup. Named types key by name — * one interface, one namespace — and anonymous ones by shape. */ function structuralKey(ty: Ty): String { if (ty.typeName != "") { return ty.typeName; } if (ty.kind == TyKind.Scalar) { return ty.scalar; } if (ty.kind == TyKind.Str) { return "string"; } if (ty.kind == TyKind.BytesList) { return "bytes"; } if (ty.kind == TyKind.StreamH) { return if (isTypedStream(ty)) `stream(${ty.witText})` else "stream"; } if (ty.kind == TyKind.FutureH) { return `future(${ty.witText})`; } var key = if (ty.kind == TyKind.ListT) "list(" else if (ty.kind == TyKind.OptionT) "option(" else if (ty.kind == TyKind.ResultT) "result(" else "tuple("; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { key = key + ","; } key = key + structuralKey(ty.children[i]); } return key + ")"; } /** The Zena spelling of a lifted `ty`, for signatures and fields. */ function zenaTypeOf(ty: Ty, uses: SynthUses): String { if (ty.kind == TyKind.Scalar) { return ty.scalar; } if (ty.kind == TyKind.Str) { return "String"; } if (ty.kind == TyKind.BytesList) { uses.fixedArray = true; return "FixedArray"; } if (ty.kind == TyKind.ListT) { uses.array = true; return `Array<${zenaTypeOf(ty.children[0], uses)}>`; } if (ty.kind == TyKind.OptionT) { uses.option = true; return `Option<${zenaTypeOf(ty.children[0], uses)}>`; } if (ty.kind == TyKind.TupleT) { var out = "("; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { out = out + ", "; } out = out + zenaTypeOf(ty.children[i], uses); } return out + ")"; } if (ty.kind == TyKind.StreamH) { uses.stream = true; return `Stream<${streamElementZenaType(ty, uses)}>`; } if (ty.kind == TyKind.FutureH) { return `Future<${futurePayloadZenaType(ty.children[0], uses)}>`; } if (ty.kind == TyKind.ResourceH && ty.ownedClass) { if (ty.isBorrow) { uses.borrowHandle = true; return `Borrow<${ty.typeName}>`; } if (ty.inAggregate) { uses.unmanagedHandle = true; return `Unmanaged<${ty.typeName}>`; } uses.ownHandle = true; return `Own<${ty.typeName}>`; } // Enumeration, Flags, RecordT, VariantT — all named. ResultT never // reaches here: top-level results are handled in renderFunc, and // nested ones are refused before rendering. return ty.typeName; } /** * The Zena spelling of a future's payload. A `result` payload is a stored * result (`storedResultType`), with `void` standing in for a bare arm; * everything else spells as itself. */ function futurePayloadZenaType(payload: Ty, uses: SynthUses): String { if (payload.kind == TyKind.ResultT) { return storedResultType(payload, uses); } return zenaTypeOf(payload, uses); } /** A stored result's Zena type: `Result`. */ function storedResultType(ty: Ty, uses: SynthUses): String { uses.result = true; return `Result<${zenaTypeOf(ty.children[0], uses)}, ${zenaTypeOf(ty.children[1], uses)}>`; } /** The expression for a stored ok result holding `value`. */ function okResultExpr(value: String): String { return `(true, ${value})`; } /** The expression for a stored error result holding `value`. */ function errResultExpr(value: String): String { return `(false, ${value})`; } /** A result arm's payload as a match arm binds it: `let ok3` and the * name, or `_` and no name for a void arm. */ final class ArmBinding { pattern: String; name: String; new(this.pattern, this.name); } /** * The binding for one arm of a stored result being lowered. The match * moves the payload out once, so an owner inside it reaches the host * exactly once, where reading it through a cast on each use would be a * use after move. */ function resultArmBinding(arm: Ty, prefix: String, uses: SynthUses) { if (isVoid(arm)) { return new ArmBinding("_", ""); } let name = `${prefix}${uses.nextTmp()}`; return new ArmBinding(`let ${name}`, name); } /** Whether `ty` (or anything inside it) cannot be lifted yet. */ function liftBlocker(ty: Ty, nested: boolean): String { if (ty.kind == TyKind.Unsupported) { return ty.reason; } if (ty.kind == TyKind.ResultT && nested) { return "a nested result waits on the interop stages"; } if (ty.kind == TyKind.FutureH) { // The payload lifts inside the generated helper. A result payload // is allowed — it lifts into a stored Result there — so only its arms are // nested; the helper also *lowers* the payload when the future is // lowered, so both directions must work. let payload = ty.children[0]; if (payload.kind == TyKind.ResultT) { for (let arm in payload.children) { if (isVoid(arm)) { continue; } let blocked = liftBlocker(arm, true); if (blocked != "") { return blocked; } let unlowerable = lowerBlocker(arm); if (unlowerable != "") { return unlowerable; } } return ""; } let blocked = liftBlocker(payload, true); if (blocked != "") { return blocked; } return lowerBlocker(payload); } for (let child in ty.children) { if (isVoid(child)) { continue; } let blocked = liftBlocker(child, true); if (blocked != "") { return blocked; } } return ""; } /** The abi load call for a discriminant or flags word of `size`. */ function discLoad(size: i32, ptrExpr: String, uses: SynthUses) { if (size == 1) { uses.useAbi("loadU8"); return `loadU8(${ptrExpr})`; } if (size == 2) { uses.useAbi("loadU16"); return `loadU16(${ptrExpr})`; } uses.useAbi("loadI32"); return `loadI32(${ptrExpr})`; } /** * The expression lifting `ty` from memory at `ptrExpr`. Simple types * inline; aggregates call a helper this registers for emission. */ function liftExprOf(ty: Ty, ptrExpr: String, uses: SynthUses) { if (ty.kind == TyKind.Scalar) { let s = ty.scalar; if (s == "boolean") { uses.useAbi("loadU8"); return `(loadU8(${ptrExpr}) != 0)`; } if (s == "u8") { uses.useAbi("loadU8"); return `(loadU8(${ptrExpr}) as u8)`; } if (s == "i8") { uses.useAbi("loadS8"); return `(loadS8(${ptrExpr}) as i8)`; } if (s == "u16") { uses.useAbi("loadU16"); return `(loadU16(${ptrExpr}) as u16)`; } if (s == "i16") { uses.useAbi("loadS16"); return `(loadS16(${ptrExpr}) as i16)`; } if (s == "i32") { uses.useAbi("loadI32"); return `loadI32(${ptrExpr})`; } if (s == "u32") { uses.useAbi("loadI32"); return `(loadI32(${ptrExpr}) as u32)`; } if (s == "i64") { uses.useAbi("loadI64"); return `loadI64(${ptrExpr})`; } if (s == "u64") { uses.useAbi("loadI64"); return `(loadI64(${ptrExpr}) as u64)`; } if (s == "f32") { uses.useAbi("loadF32"); return `loadF32(${ptrExpr})`; } uses.useAbi("loadF64"); return `loadF64(${ptrExpr})`; } if (ty.kind == TyKind.Str) { uses.useAbi("liftStringAt"); return `liftStringAt(${ptrExpr})`; } if (ty.kind == TyKind.BytesList) { uses.useAbi("liftBytesAt"); return `liftBytesAt(${ptrExpr})`; } if (ty.kind == TyKind.Enumeration) { uses.needEnumLift(ty); let loaded = discLoad(ty.size, ptrExpr, uses); return `lift${ty.typeName}(${loaded})`; } if (ty.kind == TyKind.Flags) { let loaded = discLoad(ty.size, ptrExpr, uses); return `((${loaded} as u32) as ${ty.typeName})`; } if (ty.kind == TyKind.ResourceH) { uses.useAbi("loadI32"); if (ty.isProgram) { let helper = if (ty.isBorrow) "At" else "Take"; return `${camelName(ty.resourceName)}${helper}(loadI32(${ptrExpr}))`; } return liftedHandle(ty, `loadI32(${ptrExpr})`, uses); } if (ty.kind == TyKind.StreamH) { uses.useAbi("loadI32"); return streamLiftCall(ty, `loadI32(${ptrExpr})`, uses); } if (ty.kind == TyKind.FutureH) { uses.useAbi("loadI32"); let fid = `${uses.futureIndexOf(ty)}`; return `liftFuture${fid}(loadI32(${ptrExpr}))`; } // RecordT, VariantT, OptionT, TupleT, ListT: a generated helper. return `${uses.liftNameOf(ty)}(${ptrExpr})`; } /** `ptr` displaced by a field offset, elided when zero. */ function atOffset(offset: i32) { return if (offset == 0) "ptr" else `ptr + ${offset}`; } // ============================================================================ // The lowering half: parameters into flat slots and staged memory // ============================================================================ /** The core value type one scalar spelling flattens to. */ function coreOf(scalar: String) { if (scalar == "u64" || scalar == "i64") { return "i64"; } if (scalar == "f32") { return "f32"; } if (scalar == "f64") { return "f64"; } return "i32"; } /** `value` cast to its core flat type, as source text. */ function castToCore(scalar: String, value: String) { if (scalar == "boolean") { return `(if (${value}) 1 else 0)`; } if (scalar == "i32" || scalar == "i64" || scalar == "f32" || scalar == "f64") { return value; } if (scalar == "u64") { return `(${value} as i64)`; } return `(${value} as i32)`; } /** * The core value types `ty` flattens to, or null when a variant's * payloads would join across core types — a joined slot then needs * bit-casts the generated source cannot spell yet. Only the flat form * cares: the same variant inside a list lowers through memory, where * every case writes its own layout. */ function flatCoreSlots(ty: Ty): GrowableArray | null { let out = new Array(); if (ty.kind == TyKind.Scalar) { out.push(coreOf(ty.scalar)); return out; } if (ty.kind == TyKind.Enumeration || ty.kind == TyKind.Flags || ty.kind == TyKind.ResourceH || ty.kind == TyKind.StreamH || ty.kind == TyKind.FutureH) { out.push("i32"); return out; } if (ty.kind == TyKind.Str || ty.kind == TyKind.BytesList || ty.kind == TyKind.ListT) { out.push("i32"); out.push("i32"); return out; } if (ty.kind == TyKind.RecordT || ty.kind == TyKind.TupleT) { for (let child in ty.children) { let inner = flatCoreSlots(child); if (inner == null) { return null; } for (let slot in inner as GrowableArray) { out.push(slot); } } return out; } // OptionT, ResultT, VariantT: a discriminant, then the slotwise // join of the arms. out.push("i32"); let joined = new Array(); for (let child in ty.children) { if (isVoid(child)) { continue; } let inner = flatCoreSlots(child); if (inner == null) { return null; } let arm = inner as GrowableArray; for (var i = 0; i < arm.length; i += 1) { if (i < joined.length) { joined[i] = joinCore(joined[i], arm[i]); } else { joined.push(arm[i]); } } } for (let slot in joined) { out.push(slot); } return out; } /** * The canonical ABI's join of two arms' slot types: the same type is * itself, an f32 beside an i32 is an i32 (the float travels as its * bits), and anything else is an i64 — an i32 widened, an f64 as its * bits, an f32 as its bits widened. `writeSlot` lowers into the join * and `liftFlatExpr` reads back out of it, through the `zena:math` * reinterpret intrinsics when a float is involved. */ function joinCore(a: String, b: String): String { if (a == b) { return a; } if ((a == "i32" && b == "f32") || (a == "f32" && b == "i32")) { return "i32"; } return "i64"; } /** Whether any generated lowering or lift reinterpreted float bits, * which pulls the `zena:math` intrinsics into the module. Reset per * rendered module. */ var reinterpretUsed = false; /** The `zena:math` import a module that reinterpreted bits needs. */ let reinterpretImport = "import { i32_reinterpret_f32, i64_reinterpret_f64, " + "f32_reinterpret_i32, f64_reinterpret_i64 } from 'zena:math';\n"; /** Whether `ty` (or anything inside it) cannot be lowered yet. */ /** * A lifted handle as the program holds it: the handle class around the * wire index. For a `resource class` that is an `Own` fresh from its * constructor, except inside an aggregate, where it is disowned: a list * element or record field cannot carry an owner, and the program adopts * the ones it keeps. */ function liftedHandle(ty: Ty, handleExpr: String, uses: SynthUses): String { let fresh = `new ${ty.typeName}(${handleExpr})`; if (ty.ownedClass && ty.inAggregate) { uses.disown = true; return `disown(${fresh})`; } return fresh; } /** * The wire index of a handle being lowered. For a `resource class`, an * own in a bare position is disowned first: the index transfers to the * callee, the move ends the caller's binding, and a disowned wrapper is * never implicitly released. A borrow, or an unmanaged handle out of an * aggregate, is read as it is. */ function loweredHandle(ty: Ty, value: String, uses: SynthUses) { uses.useAbi("rawHandle"); if (ty.ownedClass && !ty.isBorrow && !ty.inAggregate) { uses.disown = true; return `disown(${value}).[rawHandle]()`; } return `${value}.[rawHandle]()`; } function lowerBlocker(ty: Ty): String { if (ty.kind == TyKind.Unsupported) { return ty.reason; } if (ty.kind == TyKind.ResourceH && ty.isProgram && ty.isBorrow) { return "a borrow of the program's own resource cannot be lowered " + "yet: it would need a handle minted for the call and dropped " + "after it"; } if (ty.kind == TyKind.ResultT) { return "a result parameter waits on the interop stages (the " + "inline Result is return-position-only)"; } if (ty.kind == TyKind.FutureH) { // The generated helper moves the payload both ways; the lift // blocker's future case checks both directions. return liftBlocker(ty, true); } for (let child in ty.children) { if (isVoid(child)) { continue; } let blocked = lowerBlocker(child); if (blocked != "") { return blocked; } } return ""; } /** Whether lowering `ty` may stage arena buffers. */ function mayStage(ty: Ty): boolean { if (ty.kind == TyKind.Str || ty.kind == TyKind.BytesList || ty.kind == TyKind.ListT) { return true; } if (ty.kind == TyKind.FutureH) { // The payload stages inside the generated pump's own arena range, // not the wrapper's frame. return false; } for (let child in ty.children) { if (mayStage(child)) { return true; } } return false; } /** The abi store call for a value of `size` bytes at `ptrExpr`. */ function storeCall(size: i32, isFloat: boolean, ptrExpr: String, value: String, uses: SynthUses) { let name = if (isFloat) { if (size == 4) "storeF32" else "storeF64" } else if (size == 1) { "storeU8" } else if (size == 2) { "storeU16" } else if (size == 8) { "storeI64" } else { "storeI32" }; uses.useAbi(name); return `${name}(${ptrExpr}, ${value})`; } /** `ptrExpr` displaced by `offset`, elided when zero. */ function displaced(ptrExpr: String, offset: i32) { return if (offset == 0) ptrExpr else `(${ptrExpr}) + ${offset}`; } /** * Emit statements writing `value` (of type `ty`) into memory at * `ptrExpr`, per the canonical layout — the element form a staged * list buffer is filled with. Buffers staged along the way register * with the arena; `releaseStaged()` after the call frees them all. */ function lowerMemStmts(ty: Ty, value: String, ptrExpr: String, uses: SynthUses): ZenaTemplate { if (ty.kind == TyKind.Scalar) { let isFloat = ty.scalar == "f32" || ty.scalar == "f64"; let call = storeCall(ty.size, isFloat, ptrExpr, castToCore(ty.scalar, value), uses); return zena` ${call}; `; } if (ty.kind == TyKind.Enumeration) { let call = storeCall(ty.size, false, ptrExpr, `(${value} as i32)`, uses); return zena` ${call}; `; } if (ty.kind == TyKind.Flags) { let call = storeCall(ty.size, false, ptrExpr, `((${value} as u32) as i32)`, uses); return zena` ${call}; `; } if (ty.kind == TyKind.ResourceH && ty.isProgram) { uses.useAbi("storeI32"); let prefix = camelName(ty.resourceName); return zena` storeI32(${ptrExpr}, ${prefix}New_raw(${prefix}Register(${value}))); `; } if (ty.kind == TyKind.ResourceH) { uses.useAbi("storeI32"); if (ty.ownedClass) { let handle = loweredHandle(ty, value, uses); return zena` storeI32(${ptrExpr}, ${handle}); `; } uses.useAbi("rawHandle"); if (!ty.isBorrow) { uses.useAbi("markMoved"); return zena` storeI32(${ptrExpr}, ${value}.[rawHandle]()); ${value}.[markMoved](); `; } return zena` storeI32(${ptrExpr}, ${value}.[rawHandle]()); `; } if (ty.kind == TyKind.StreamH) { uses.useAbi("storeI32"); let streamCall = streamLowerCall(ty, value, uses); return zena` storeI32(${ptrExpr}, ${streamCall}); `; } if (ty.kind == TyKind.FutureH) { uses.useAbi("storeI32"); let fid = `${uses.futureIndexOf(ty)}`; return zena` storeI32(${ptrExpr}, lowerFuture${fid}(${value})); `; } if (ty.kind == TyKind.ResultT) { // Only reachable as a future payload: the value is a stored result, // and it lowers as the canonical two-case variant. storedResultType(ty, uses); let payoff = payloadOffset(ty); uses.useAbi("storeU8"); let okBinding = resultArmBinding(ty.children[0], "ok", uses); let errBinding = resultArmBinding(ty.children[1], "err", uses); let okStmts = growable([zena`storeU8(${ptrExpr}, 0);`]); if (!isVoid(ty.children[0])) { okStmts.push(lowerMemStmts(ty.children[0], okBinding.name, displaced(ptrExpr, payoff), uses)); } let errStmts = growable([zena`storeU8(${ptrExpr}, 1);`]); if (!isVoid(ty.children[1])) { errStmts.push(lowerMemStmts(ty.children[1], errBinding.name, displaced(ptrExpr, payoff), uses)); } let okPattern = okBinding.pattern; let errPattern = errBinding.pattern; return zena` match (${value}) { case (true, ${okPattern}): { ${okStmts} } case (false, ${errPattern}): { ${errStmts} } } `; } if (ty.kind == TyKind.Str || ty.kind == TyKind.BytesList) { let stage = if (ty.kind == TyKind.Str) "stageString" else "stageByteList"; uses.useAbi(stage); uses.stagedAny = true; let ptr = `ptr${uses.nextTmp()}`; let len = `len${uses.nextTmp()}`; let displacedPtr = displaced(ptrExpr, 4); uses.useAbi("storeI32"); return zena` let (${ptr}, ${len}) = ${stage}(${value}); storeI32(${ptrExpr}, ${ptr}); storeI32(${displacedPtr}, ${len}); `; } if (ty.kind == TyKind.ListT) { let element = ty.children[0]; uses.useAbi("stageBuffer"); uses.stagedAny = true; uses.useAbi("storeI32"); let buffer = `buffer${uses.nextTmp()}`; let length = `length${uses.nextTmp()}`; let index = `index${uses.nextTmp()}`; let elemSize = `${element.size}`; let elemStmt = lowerMemStmts(element, `${value}[${index}]`, `${buffer} + ${index} * ${elemSize}`, uses); let displacedPtr = displaced(ptrExpr, 4); return zena` var ${buffer} = 0; let ${length} = ${value}.length; if (${length} > 0) { ${buffer} = stageBuffer(${length} * ${elemSize}); for (var ${index} = 0; ${index} < ${length}; ${index} += 1) { ${elemStmt} } } storeI32(${ptrExpr}, ${buffer}); storeI32(${displacedPtr}, ${length}); `; } if (ty.kind == TyKind.RecordT) { let offsets = fieldOffsets(ty); let stmts = new Array(); for (var i = 0; i < ty.children.length; i += 1) { stmts.push(lowerMemStmts(ty.children[i], `${value}.${ty.childNames[i]}`, displaced(ptrExpr, offsets[i]), uses)); } return zena` ${stmts} `; } if (ty.kind == TyKind.TupleT) { let offsets = fieldOffsets(ty); let t = `t${uses.nextTmp()}`; var tupleVars = ""; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { tupleVars = `${tupleVars}, `; } tupleVars = `${tupleVars}${t}v${i}`; } let stmts = new Array(); for (var i = 0; i < ty.children.length; i += 1) { stmts.push(lowerMemStmts(ty.children[i], `${t}v${i}`, displaced(ptrExpr, offsets[i]), uses)); } return zena` let (${tupleVars}) = ${value}; ${stmts} `; } if (ty.kind == TyKind.OptionT) { uses.option = true; uses.useAbi("storeU8"); let payoff = payloadOffset(ty); let bound = `o${uses.nextTmp()}`; let innerStmt = lowerMemStmts(ty.children[0], bound, displaced(ptrExpr, payoff), uses); return zena` if (let Some {value as ${bound}} = ${value}) { storeU8(${ptrExpr}, 1); ${innerStmt} } else { storeU8(${ptrExpr}, 0); } `; } // VariantT: an if chain over the sealed cases, each storing the // discriminant and its own payload layout. let payoff = payloadOffset(ty); let chainSb = new StringBuilder(); for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { chainSb.append("} else "); } chainSb.append(`if (${value} is ${ty.childNames[i]}) {\n`); let call = storeCall( discSize(ty.caseCount), false, ptrExpr, `${i}`, uses); chainSb.append(` ${call};\n`); if (!isVoid(ty.children[i])) { let armStmt = lowerMemStmts(ty.children[i], `(${value} as ${ty.childNames[i]}).value`, displaced(ptrExpr, payoff), uses); emit(chainSb, " ", armStmt); chainSb.append("\n"); } } chainSb.append("}"); let chain = chainSb.toString(); return zena` ${chain} `; } /** * Stage a list value's element buffer: allocates `length * stride` * arena bytes, fills each element through `lowerMemStmts`, and hands * the buffer and count to `finish`. An empty list stages nothing and * passes `(0, 0)` — the canonical empty form, and `stageBuffer(0)` * would return an unowned sentinel. */ function emitListStaging(sb: StringBuilder, ty: Ty, value: String, indent: String, uses: SynthUses, finish: (buf: String, count: String) => void) { let element = ty.children[0]; uses.useAbi("stageBuffer"); uses.stagedAny = true; let buffer = `buffer${uses.nextTmp()}`; let length = `length${uses.nextTmp()}`; let index = `index${uses.nextTmp()}`; let elemSize = `${element.size}`; let body = lowerMemStmts(element, `${value}[${index}]`, `${buffer} + ${index} * ${elemSize}`, uses); emit(sb, indent, zena` var ${buffer} = 0; let ${length} = ${value}.length; if (${length} > 0) { ${buffer} = stageBuffer(${length} * ${elemSize}); for (var ${index} = 0; ${index} < ${length}; ${index} += 1) { ${body} } } `); sb.append("\n"); finish(buffer, length); } /** * Emit statements assigning `value`'s flattened form into the slot * variables `slots[base..]`; returns the number of slots consumed. * Unwritten slots keep their zero initializers, which is what an * absent option payload or a shorter variant arm leaves behind. */ /** * The core types of the slots `lowerFlatStmts` is filling, parallel to * the slot names: a variant's arms share slots, and a slot two arms * disagree on is the canonical join of their types (an i32 beside an * i64 is an i64), so an arm's narrower value widens on the way in. * Set by the caller that declared the slots. */ var currentSlotTypes = new Array(); /** * `slot = expr;`, widening an i32 `expr` when the slot is an i64 — * the one join this file lowers (the canonical ABI also joins floats * with integers, through reinterpretation, which waits on a need). */ function writeSlot(sb: StringBuilder, indent: String, slot: String, slotIndex: i32, expr: String, haveCore: String) { var rhs = expr; if (slotIndex < currentSlotTypes.length) { let want = currentSlotTypes[slotIndex]; if (want != haveCore) { // Into a joined slot: an integer widens, a float goes as its // bits (widened too, for an f32 in an i64). if (want == "i64" && haveCore == "i32") { rhs = `((${expr}) as i64)`; } else if (want == "i32" && haveCore == "f32") { reinterpretUsed = true; rhs = `i32_reinterpret_f32(${expr})`; } else if (want == "i64" && haveCore == "f32") { reinterpretUsed = true; rhs = `(i32_reinterpret_f32(${expr}) as i64)`; } else if (want == "i64" && haveCore == "f64") { reinterpretUsed = true; rhs = `i64_reinterpret_f64(${expr})`; } } } sb.append(indent).append(`${slot} = ${rhs};\n`); } function lowerFlatStmts(sb: StringBuilder, ty: Ty, value: String, slots: GrowableArray, base: i32, indent: String, uses: SynthUses): i32 { if (ty.kind == TyKind.Scalar) { writeSlot(sb, indent, slots[base], base, castToCore(ty.scalar, value), coreOf(ty.scalar)); return 1; } if (ty.kind == TyKind.Enumeration) { writeSlot(sb, indent, slots[base], base, `(${value} as i32)`, "i32"); return 1; } if (ty.kind == TyKind.Flags) { writeSlot(sb, indent, slots[base], base, `((${value} as u32) as i32)`, "i32"); return 1; } if (ty.kind == TyKind.ResourceH && ty.isProgram) { // An own of the program's resource leaves as a fresh handle over // the instance's representation. let prefix = camelName(ty.resourceName); writeSlot(sb, indent, slots[base], base, `${prefix}New_raw(${prefix}Register(${value}))`, "i32"); return 1; } if (ty.kind == TyKind.ResourceH) { if (ty.ownedClass) { writeSlot(sb, indent, slots[base], base, loweredHandle(ty, value, uses), "i32"); return 1; } uses.useAbi("rawHandle"); writeSlot(sb, indent, slots[base], base, `${value}.[rawHandle]()`, "i32"); if (!ty.isBorrow) { // An owned handle transfers to the callee: the wrapper's later // dispose must not drop an index it no longer owns. uses.useAbi("markMoved"); sb.append(indent).append(`${value}.[markMoved]();\n`); } return 1; } if (ty.kind == TyKind.StreamH) { writeSlot(sb, indent, slots[base], base, streamLowerCall(ty, value, uses), "i32"); return 1; } if (ty.kind == TyKind.FutureH) { writeSlot(sb, indent, slots[base], base, `lowerFuture${uses.futureIndexOf(ty)}(${value})`, "i32"); return 1; } if (ty.kind == TyKind.Str || ty.kind == TyKind.BytesList) { let stage = if (ty.kind == TyKind.Str) "stageString" else "stageByteList"; uses.useAbi(stage); uses.stagedAny = true; let ptr = `ptr${uses.nextTmp()}`; let len = `len${uses.nextTmp()}`; sb.append(indent).append(`let (${ptr}, ${len}) = ${stage}(${value});\n`); writeSlot(sb, indent, slots[base], base, ptr, "i32"); writeSlot(sb, indent, slots[base + 1], base + 1, len, "i32"); return 2; } if (ty.kind == TyKind.ListT) { emitListStaging(sb, ty, value, indent, uses, (buffer, length) => { writeSlot(sb, indent, slots[base], base, buffer, "i32"); writeSlot(sb, indent, slots[base + 1], base + 1, length, "i32"); }); return 2; } if (ty.kind == TyKind.RecordT) { var consumed = 0; for (var i = 0; i < ty.children.length; i += 1) { consumed += lowerFlatStmts(sb, ty.children[i], `${value}.${ty.childNames[i]}`, slots, base + consumed, indent, uses); } return consumed; } if (ty.kind == TyKind.TupleT) { let t = `t${uses.nextTmp()}`; sb.append(indent).append("let ("); for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(`${t}v${i}`); } sb.append(") = ").append(value).append(";\n"); var consumed = 0; for (var i = 0; i < ty.children.length; i += 1) { consumed += lowerFlatStmts(sb, ty.children[i], `${t}v${i}`, slots, base + consumed, indent, uses); } return consumed; } if (ty.kind == TyKind.OptionT) { uses.option = true; let bound = `o${uses.nextTmp()}`; sb.append(indent).append(`if (let Some {value as ${bound}} = ${value}) {\n`); writeSlot(sb, indent + " ", slots[base], base, "1", "i32"); lowerFlatStmts(sb, ty.children[0], bound, slots, base + 1, indent + " ", uses); sb.append(indent).append("}\n"); let total = flatCoreSlots(ty); return (total as GrowableArray).length; } if (ty.kind == TyKind.ResultT) { // Only reachable as an async export's result: the value is a // stored result, lowered as the canonical two-case variant. storedResultType(ty, uses); let okBinding = resultArmBinding(ty.children[0], "ok", uses); let errBinding = resultArmBinding(ty.children[1], "err", uses); let armIndent = indent + " "; sb.append(indent).append(`match (${value}) {\n`); sb.append(indent).append(` case (true, ${okBinding.pattern}): {\n`); writeSlot(sb, armIndent, slots[base], base, "0", "i32"); if (!isVoid(ty.children[0])) { lowerFlatStmts(sb, ty.children[0], okBinding.name, slots, base + 1, armIndent, uses); } sb.append(indent).append(" }\n"); sb.append(indent).append(` case (false, ${errBinding.pattern}): {\n`); writeSlot(sb, armIndent, slots[base], base, "1", "i32"); if (!isVoid(ty.children[1])) { lowerFlatStmts(sb, ty.children[1], errBinding.name, slots, base + 1, armIndent, uses); } sb.append(indent).append(" }\n"); sb.append(indent).append("}\n"); let total = flatCoreSlots(ty); return (total as GrowableArray).length; } // VariantT: an if chain; every arm writes the discriminant and its // own prefix of the shared payload slots. for (var i = 0; i < ty.children.length; i += 1) { sb.append(indent); if (i > 0) { sb.append("} else "); } sb.append(`if (${value} is ${ty.childNames[i]}) {\n`); writeSlot(sb, indent + " ", slots[base], base, `${i}`, "i32"); if (!isVoid(ty.children[i])) { lowerFlatStmts(sb, ty.children[i], `(${value} as ${ty.childNames[i]}).value`, slots, base + 1, indent + " ", uses); } } sb.append(indent).append("}\n"); let total = flatCoreSlots(ty); return (total as GrowableArray).length; } /** Emit the body of one registered lift helper. */ function emitLiftHelper(entry: LiftEntry, uses: SynthUses) { let ty = entry.ty; let retType = zenaTypeOf(ty, uses); if (ty.kind == TyKind.RecordT) { let offsets = fieldOffsets(ty); var args = ""; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { args = `${args},\n`; } args = `${args}${liftExprOf(ty.children[i], atOffset(offsets[i]), uses)}`; } return zena` function ${entry.name}(ptr: i32): ${retType} { return new ${ty.typeName}( ${args}); } `; } if (ty.kind == TyKind.TupleT) { let offsets = fieldOffsets(ty); var args = ""; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { args = `${args},\n`; } args = `${args}${liftExprOf(ty.children[i], atOffset(offsets[i]), uses)}`; } return zena` function ${entry.name}(ptr: i32): ${retType} { return ( ${args}); } `; } if (ty.kind == TyKind.OptionT) { uses.option = true; let payoff = payloadOffset(ty); let disc = discLoad(1, "ptr", uses); let inner = liftExprOf(ty.children[0], `ptr + ${payoff}`, uses); return zena` function ${entry.name}(ptr: i32): ${retType} { if (${disc} == 0) { return none; } return some(${inner}); } `; } if (ty.kind == TyKind.VariantT) { uses.error = true; let payoff = payloadOffset(ty); let disc = discLoad(discSize(ty.caseCount), "ptr", uses); let casesSb = new StringBuilder(); for (var i = 0; i < ty.children.length; i += 1) { casesSb.append(`if (disc == ${i}) {\n`); if (isVoid(ty.children[i])) { casesSb.append(` return new ${ty.childNames[i]}();\n}\n`); } else { let childExpr = liftExprOf(ty.children[i], `ptr + ${payoff}`, uses); casesSb.append(` return new ${ty.childNames[i]}(${childExpr});\n}\n`); } } let cases = casesSb.toString(); return zena` function ${entry.name}(ptr: i32): ${retType} { let disc = ${disc}; ${cases} throw new Error('invalid ${ty.typeName} discriminant'); } `; } // ListT: let element = ty.children[0]; let elemType = zenaTypeOf(element, uses); let elemSize = `${element.size}`; let elemExpr = liftExprOf(element, `base + i * ${elemSize}`, uses); uses.useAbi("loadI32"); uses.useAbi("freeLifted"); uses.array = true; return zena` function ${entry.name}(ptr: i32): ${retType} { return ${entry.name}Elems(loadI32(ptr), loadI32(ptr + 4)); } function ${entry.name}Elems(base: i32, count: i32): ${retType} { let out = new GrowableArray<${elemType}>(); for (var i = 0; i < count; i += 1) { out.push(${elemExpr}); } if (count > 0) { freeLifted(base); } return out; } `; } // ============================================================================ // The flat lifting half: an export's parameters out of core values // ============================================================================ /** A core value cast to its scalar spelling, as source text. */ function castFromCore(scalar: String, expr: String) { if (scalar == "boolean") { return `(${expr} != 0)`; } if (scalar == "i32" || scalar == "i64" || scalar == "f32" || scalar == "f64") { return expr; } return `(${expr} as ${scalar})`; } /** * The value of `ty` lifted from the flat core values `slots[base..]`, * as one expression — the mirror of `lowerFlatStmts`. A slot whose * core type is the join of several arms' (an i64 beside an i32) is * narrowed back for the arm that wants the narrower one. Aggregates * lift through a generated helper taking their slots. */ function liftFlatExpr(ty: Ty, slotTypes: GrowableArray, slots: GrowableArray, base: i32, uses: SynthUses) { let slot = (i: i32, want: String) => { let have = slotTypes[i]; if (have == want) { return slots[i]; } // Out of a joined slot: an i64 wraps to an i32, and a float comes // back from its bits. if (have == "i64" && want == "i32") { return `(${slots[i]} as i32)`; } if (have == "i32" && want == "f32") { reinterpretUsed = true; return `f32_reinterpret_i32(${slots[i]})`; } if (have == "i64" && want == "f32") { reinterpretUsed = true; return `f32_reinterpret_i32((${slots[i]} as i32))`; } if (have == "i64" && want == "f64") { reinterpretUsed = true; return `f64_reinterpret_i64(${slots[i]})`; } return slots[i]; }; if (ty.kind == TyKind.Scalar) { return castFromCore(ty.scalar, slot(base, coreOf(ty.scalar))); } if (ty.kind == TyKind.Enumeration) { uses.needEnumLift(ty); return `lift${ty.typeName}(${slot(base, "i32")})`; } if (ty.kind == TyKind.Flags) { return `((${slot(base, "i32")} as u32) as ${ty.typeName})`; } if (ty.kind == TyKind.ResourceH) { if (ty.isProgram) { // A borrow of the program's own resource arrives as its // representation — the canonical ABI passes a borrow into the // implementing component as the rep — so it is a table lookup. // An own arrives as a handle the caller gave up: the instance // is taken back out of the table. let helper = if (ty.isBorrow) "At" else "Take"; return `${camelName(ty.resourceName)}${helper}(${slot(base, "i32")})`; } // An owned handle: the wrapper's class around it, which the // program then owns and disposes. A borrow is refused before this. return liftedHandle(ty, slot(base, "i32"), uses); } if (ty.kind == TyKind.StreamH) { return streamLiftCall(ty, slot(base, "i32"), uses); } if (ty.kind == TyKind.FutureH) { let fid = `${uses.futureIndexOf(ty)}`; return `liftFuture${fid}(${slot(base, "i32")})`; } if (ty.kind == TyKind.Str) { uses.useAbi("takeStringArgument"); return `takeStringArgument(${slot(base, "i32")}, ${slot(base + 1, "i32")})`; } if (ty.kind == TyKind.BytesList) { uses.useAbi("takeBytesArgument"); return `takeBytesArgument(${slot(base, "i32")}, ${slot(base + 1, "i32")})`; } if (ty.kind == TyKind.ListT) { return `${uses.liftNameOf(ty)}Elems(${slot(base, "i32")}, ${slot(base + 1, "i32")})`; } // RecordT, TupleT, OptionT, ResultT, VariantT: a generated helper // taking the slots — at the aggregate's own slot types, which may // be narrower than the joined ones it sits in. let own = flatCoreSlots(ty) as GrowableArray; var args = ""; for (var i = 0; i < own.length; i += 1) { if (i > 0) { args = `${args}, `; } args = `${args}${slot(base + i, own[i])}`; } return `${uses.flatLiftNameOf(ty)}(${args})`; } /** Emit the body of one registered flat lift helper: the aggregate * built from its flat core values, `s0..sN`. */ function emitFlatLiftHelper(entry: LiftEntry, uses: SynthUses) { let ty = entry.ty; let slotTypes = flatCoreSlots(ty) as GrowableArray; let slots = new GrowableArray(); var params = ""; for (var i = 0; i < slotTypes.length; i += 1) { let name = `s${i}`; slots.push(name); if (i > 0) { params = `${params}, `; } params = `${params}${name}: ${slotTypes[i]}`; } let retType = futurePayloadZenaType(ty, uses); if (ty.kind == TyKind.RecordT) { var args = ""; var at = 0; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { args = `${args},\n`; } args = `${args}${liftFlatExpr(ty.children[i], slotTypes, slots, at, uses)}`; at += (flatCoreSlots(ty.children[i]) as GrowableArray).length; } return zena` function ${entry.name}(${params}): ${retType} { return new ${ty.typeName}( ${args}); } `; } if (ty.kind == TyKind.TupleT) { var args = ""; var at = 0; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { args = `${args},\n`; } args = `${args}${liftFlatExpr(ty.children[i], slotTypes, slots, at, uses)}`; at += (flatCoreSlots(ty.children[i]) as GrowableArray).length; } return zena` function ${entry.name}(${params}): ${retType} { return ( ${args}); } `; } if (ty.kind == TyKind.OptionT) { uses.option = true; let inner = liftFlatExpr(ty.children[0], slotTypes, slots, 1, uses); return zena` function ${entry.name}(${params}): ${retType} { if (s0 == 0) { return none; } return some(${inner}); } `; } if (ty.kind == TyKind.ResultT) { storedResultType(ty, uses); let okZ = futurePayloadZenaType(ty.children[0], uses); let errZ = futurePayloadZenaType(ty.children[1], uses); let arm = (child: Ty) => { if (isVoid(child)) { uses.unit = true; return "witUnit()"; } return liftFlatExpr(child, slotTypes, slots, 1, uses); }; let okArm = arm(ty.children[0]); let errArm = arm(ty.children[1]); return zena` function ${entry.name}(${params}): ${retType} { if (s0 == 0) { return ${okResultExpr(okArm)}; } return ${errResultExpr(errArm)}; } `; } // VariantT: the discriminant picks the case, each reading its own // prefix of the shared payload slots. uses.error = true; let casesSb = new StringBuilder(); for (var i = 0; i < ty.children.length; i += 1) { casesSb.append(`if (s0 == ${i}) {\n`); if (isVoid(ty.children[i])) { casesSb.append(` return new ${ty.childNames[i]}();\n}\n`); } else { let childExpr = liftFlatExpr(ty.children[i], slotTypes, slots, 1, uses); casesSb.append(` return new ${ty.childNames[i]}(${childExpr});\n}\n`); } } let cases = casesSb.toString(); return zena` function ${entry.name}(${params}): ${retType} { ${cases} throw new Error('invalid ${ty.typeName} discriminant'); } `; } /** The `zena:stream` import a module that rendered streams needs. */ function streamImport(uses: SynthUses) { return if (uses.streamWriter) "import { Stream, StreamWriter } from 'zena:stream';\n" else "import { Stream } from 'zena:stream';\n"; } /** Whether `ty` is or contains a stream or future end. */ function carriesEnd(ty: Ty): boolean { if (ty.kind == TyKind.StreamH || ty.kind == TyKind.FutureH) { return true; } for (let child in ty.children) { if (carriesEnd(child)) { return true; } } return false; } /** * Whether a value of `ty` holds an owner: an owned handle of a * `resource class` in a bare position, or a tuple, option, result, * future or stream holding one. Such a value is affine, so a container * of it is a restricted instantiation (owner-futures.md): one element * at a time through a stream, and nothing in a `GrowableArray`. */ function holdsOwner(ty: Ty): boolean { if (ty.kind == TyKind.ResourceH) { return ty.ownedClass && !ty.isBorrow && !ty.inAggregate; } for (let child in ty.children) { if (holdsOwner(child)) { return true; } } return false; } /** Whether a stream position carries an element other than `u8`, * moved by generated pumps rather than `zena:wasi`'s byte pumps. */ function isTypedStream(ty: Ty): boolean { return ty.children.length > 0; } /** The Zena spelling of a stream's element. */ function streamElementZenaType(ty: Ty, uses: SynthUses): String { return if (isTypedStream(ty)) zenaTypeOf(ty.children[0], uses) else "u8"; } /** The expression lifting a stream handle into a `Stream`. */ function streamLiftCall(ty: Ty, handle: String, uses: SynthUses): String { if (isTypedStream(ty)) { let sid = `${uses.streamIndexOf(ty)}`; return `liftStream${sid}(${handle})`; } uses.useComponentStream("liftByteStream"); return `liftByteStream(${handle})`; } /** The expression lowering a `Stream` into a stream handle. */ function streamLowerCall(ty: Ty, value: String, uses: SynthUses): String { if (isTypedStream(ty)) { let sid = `${uses.streamIndexOf(ty)}`; return `lowerStream${sid}(${value})`; } uses.useComponentStream("lowerByteStream"); return `lowerByteStream(${value})`; } /** Elements a typed inbound pump reads per canonical copy. */ let STREAM_CHUNK = 64; /** * One typed stream element's generated surface: the five per-type * canon builtin declares (`#k`-disambiguated like a future's, the * canon type spelled `stream:#`), the lift helper * that reads a received end into a `Stream` through a * `StreamWriter`, and the lower helper that makes a fresh pair, hands * over the readable end and pumps the guest stream's elements into * the writable one. Each element crosses through memory at its * canonical layout — the read pump lifts a chunk of them out of a * return area, the write pump lowers one at a time into a staged * buffer — so a string or list inside an element is fine. Bytes keep * `zena:wasi`'s chunked pumps, which never marshal. */ function emitStreamHelpers(sb: StringBuilder, entry: FutureEntry, interfaceName: String, uses: SynthUses) { let k = `${entry.index}`; let element = entry.ty.children[0]; let canonType = `stream:${interfaceName}#${entry.ty.witText}`; let z = zenaTypeOf(element, uses); uses.awaitWaitable = true; uses.error = true; uses.option = true; uses.stream = true; uses.streamWriter = true; uses.fixedArray = true; uses.useAbi("resultArea"); uses.useAbi("freeLifted"); uses.useAbi("stagedMark"); uses.useAbi("releaseStagedFrom"); uses.useAbi("stageBuffer"); let declare = (builtin: String, options: String, name: String, sig: String) => { sb.append(`@external("canon", "${builtin}#${interfaceName}.${k}", "${canonType}${options}")\n`); sb.append(`declare function ${name}${k}_raw${sig};\n`); }; declare("stream.new", "", "streamNew", "(): u64"); declare("stream.read", ",async", "streamRead", "(end: i32, ptr: i32, count: i32): i32"); declare("stream.write", ",async", "streamWrite", "(end: i32, ptr: i32, count: i32): i32"); declare("stream.drop-readable", "", "streamDropReadable", "(end: i32): void"); declare("stream.drop-writable", "", "streamDropWritable", "(end: i32): void"); let size = `${element.size}`; let chunkSize = `${STREAM_CHUNK}`; let elemExpr = liftExprOf(element, `buf + i * ${size}`, uses); let lowerElemStmt = lowerMemStmts(element, "v", "buf", uses); // A write the reader refused took nothing, and lowering the element // already moved its handles out of their classes into the buffer, // where they are still this component's: lift them back, and the // binding releases them where it ends (#833). let reclaim = if (holdsOwner(element)) zena` if ((packed >> 4) == 0) { let refused = ${liftExprOf(element, "buf", uses)}; } ` else ""; // A chunk of plain elements goes to the reader in one bulk write. A // stream of owners is one element at a time (only a first-class // stream has the bulk path), and every element read is the // program's from then on: the one a stopped reader hands back, and // the rest of the chunk after it, are released here. let deliver = if (holdsOwner(element)) zena` for (var i = 0; i < n; i += 1) { let item = ${elemExpr}; if (open) { if (let (false, refused) = await writer.write(item)) { open = false; } } } ` else zena` let items = new GrowableArray<${z}>(n); for (var i = 0; i < n; i += 1) { items.push(${elemExpr}); } let delivered = await writer.writeAll(FixedArray.from(items), n); if (!delivered) { open = false; } `; emit(sb, "", zena` function liftStream${k}(end: i32): Stream<${z}> { let (writer, stream) = StreamWriter.create<${z}>(); pumpStreamIn${k}(end, writer); return stream; } async function pumpStreamIn${k}(end: i32, writer: StreamWriter<${z}>): Future { let buf = resultArea(${chunkSize} * ${size}); var open = true; while (open) { var packed = streamRead${k}_raw(end, buf, ${chunkSize}); if (packed == -1) { packed = await awaitWaitable(end); } let n = packed >> 4; let completed = (packed & 15) == 0; if (n > 0) { ${deliver} } else if (completed) { freeLifted(buf); throw new Error('the stream read made no progress'); } if (!completed) { open = false; } } freeLifted(buf); writer.close(); streamDropReadable${k}_raw(end); } function lowerStream${k}(source: Stream<${z}>): i32 { let pair = streamNew${k}_raw(); pumpStreamOut${k}(source, (pair >> 32) as i32); return pair as i32; } async function pumpStreamOut${k}(source: Stream<${z}>, end: i32): Future { var open = true; while (open) { if (let Some {value as v} = await source.readOne()) { let m0 = stagedMark(); let buf = stageBuffer(${size}); ${lowerElemStmt} var packed = streamWrite${k}_raw(end, buf, 1); if (packed == -1) { packed = await awaitWaitable(end); } ${reclaim} releaseStagedFrom(m0); if ((packed & 15) != 0) { source.stop(); open = false; } } else { open = false; } } streamDropWritable${k}_raw(end); } `); sb.append("\n"); } /** * One future payload type's generated surface: the five per-type * canon builtin declares (each field disambiguated `#.`, * because the canon entry's type is part of which builtin it is, every * declaration is its own core import, and two interfaces' `k`s both * start at 0), the lift helper that reads a * received end into a `Future`, and the lower helper that makes a * fresh pair, hands over the readable end and pumps the guest future * into the writable one. A `result` payload is a stored `Result`, * with `witUnit()` filling a bare arm. */ function emitFutureHelpers(sb: StringBuilder, entry: FutureEntry, interfaceName: String, uses: SynthUses) { let k = `${entry.index}`; let payload = entry.ty.children[0]; let canonType = `future:${interfaceName}#${entry.ty.witText}`; let z = futurePayloadZenaType(payload, uses); uses.awaitWaitable = true; uses.error = true; uses.useAbi("resultArea"); uses.useAbi("freeLifted"); uses.useAbi("stagedMark"); uses.useAbi("releaseStagedFrom"); uses.useAbi("stageBuffer"); let declare = (builtin: String, options: String, name: String, sig: String) => { sb.append(`@external("canon", "${builtin}#${interfaceName}.${k}", "${canonType}${options}")\n`); sb.append(`declare function ${name}${k}_raw${sig};\n`); }; declare("future.new", "", "futureNew", "(): u64"); declare("future.read", ",async", "futureRead", "(end: i32, ptr: i32): i32"); declare("future.write", ",async", "futureWrite", "(end: i32, ptr: i32): i32"); declare("future.drop-readable", "", "futureDropReadable", "(end: i32): void"); declare("future.drop-writable", "", "futureDropWritable", "(end: i32): void"); // The lift: a `DeferredFuture`, whose read starts on the first // await. A read issued at lift time holds a waitable — and the task // that owns it — until the host writes the end, and a program need // not ever look: every `request.new` and `response.new` returns a // `transmitted` future beside the resource (#587). The read, once // started: one canonical read, parked on the driver when BLOCKED // (-1); the low CopyResult bits are 0 (COMPLETED) exactly when a // value arrived, and a peer that dropped its end without writing // fails the future with a throw. uses.deferred = true; let payloadSize = `${payload.size}`; var readPayload = zena``; if (payload.kind == TyKind.ResultT) { let okZ = zenaTypeOf(payload.children[0], uses); let errZ = zenaTypeOf(payload.children[1], uses); let payoff = `${payloadOffset(payload)}`; var okExpr = "ok"; var errExpr = "err"; if (isVoid(payload.children[0])) { uses.unit = true; okExpr = "witUnit()"; } if (isVoid(payload.children[1])) { uses.unit = true; errExpr = "witUnit()"; } let disc = discLoad(1, "ret", uses); storedResultType(payload, uses); let okValue = okResultExpr(okExpr); let errValue = errResultExpr(errExpr); var okArm = zena` freeLifted(ret); return ${okValue}; `; if (okExpr == "ok") { okArm = zena` let ok = ${liftExprOf(payload.children[0], `ret + ${payoff}`, uses)}; freeLifted(ret); return ${okValue}; `; } var errArm = zena` freeLifted(ret); return ${errValue}; `; if (errExpr == "err") { errArm = zena` let err = ${liftExprOf(payload.children[1], `ret + ${payoff}`, uses)}; freeLifted(ret); return ${errValue}; `; } readPayload = zena` if (${disc} == 0) { ${okArm} } ${errArm} `; } else { let out = liftExprOf(payload, "ret", uses); readPayload = zena` let out = ${out}; freeLifted(ret); return out; `; } let lowerPayloadStmt = lowerMemStmts(payload, "v", "buf", uses); emit(sb, "", zena` function liftFuture${k}(end: i32): Future<${z}> { return new DeferredFuture<${z}>((): Future<${z}> => readFuture${k}(end), (): void => { futureDropReadable${k}_raw(end); }); } async function readFuture${k}(end: i32): Future<${z}> { let ret = resultArea(${payloadSize}); var packed = futureRead${k}_raw(end, ret); if (packed == -1) { packed = await awaitWaitable(end); } futureDropReadable${k}_raw(end); if ((packed & 15) != 0) { freeLifted(ret); throw new Error('the future was dropped without a value'); } ${readPayload} } function lowerFuture${k}(value: Future<${z}>): i32 { let pair = futureNew${k}_raw(); pumpFuture${k}(value, (pair >> 32) as i32); return pair as i32; } async function pumpFuture${k}(value: Future<${z}>, end: i32): Future { let v = await value; let m0 = stagedMark(); let buf = stageBuffer(${payloadSize}); ${lowerPayloadStmt} var packed = futureWrite${k}_raw(end, buf); if (packed == -1) { packed = await awaitWaitable(end); } releaseStagedFrom(m0); futureDropWritable${k}_raw(end); } `); sb.append("\n"); } /** * A WIT `enum`, as a Zena enum: PascalCase members with explicit * ordinals, because the ordinal IS the wire discriminant and must not * drift from declaration order by accident. */ function renderEnum(sb: StringBuilder, td: TypeDef) { let cases = td.enumCases as GrowableArray; let name = td.name.name; let enumName = pascalName(name); let comment = `/** WIT \`enum ${name}\`. */`; let members = new GrowableArray(); for (var i = 0; i < cases.length; i += 1) { members.push(`${pascalName(cases[i].name.name)} = ${i},`); } emit(sb, "", zena` ${comment} export enum ${enumName} { ${members} } `); sb.append("\n"); } /** * A WIT `flags`, as a distinct u32 bitset with one constant per label * (`modes` with `read` → `modesRead`). Distinct rather than opaque: * combining flags is the caller's arithmetic, through `u32` casts. */ function renderFlags(sb: StringBuilder, td: TypeDef) { let flags = td.flags as GrowableArray; let typeName = pascalName(td.name.name); let prefix = camelName(td.name.name); let name = td.name.name; let comment = `/** WIT \`flags ${name}\`, as a bitset. */`; let members = new GrowableArray(); for (var i = 0; i < flags.length; i += 1) { let flagName = pascalName(flags[i].name.name); let val = `${1 << i}`; members.push(`export let ${prefix}${flagName} = (${val} as u32) as ${typeName};`); } emit(sb, "", zena` ${comment} export distinct type ${typeName} = u32; ${members} `); sb.append("\n"); } /** * A WIT `resource`, as a handle-wrapping class: the class owns the * imported handle, methods and statics ride the same marshaling * machinery as free functions (a method's raw call leads with the * handle), a WIT constructor becomes `static create`, and disposal is * the canonical `resource.drop`. For an interface in * `ownedResourceSpecifiers` the class is a `resource class`, released * by implicit drop and checked for use after a move; for the rest it * is a `Disposable` whose dispose is idempotent behind a flag, because * nothing prevents a double call there. Members that cannot render yet * are skipped * per member; the class itself always renders, so a handle received * from elsewhere is at least holdable and droppable. */ function renderResource( body: StringBuilder, skipped: StringBuilder, td: TypeDef, interfaceName: String, ifaceItems: GrowableArray, uses: SynthUses ) { uses.anyResource = true; // The symbol-keyed members: shared identities from the abi module, // so another synthesized module's marshaling reaches the same // members (a per-module symbol would not). A resource class has no // moved flag, so only the Disposable form declares `[markMoved]`. uses.useAbi("rawHandle"); let ownedClass = rendersAsResourceClass(selfSpecifier); if (!ownedClass) { uses.useAbi("markMoved"); } let resourceName = td.name.name; let typeName = pascalName(resourceName); let rawPrefix = camelName(resourceName); let members = new StringBuilder(); let raws = new StringBuilder(); let funcs = td.resourceFuncs; if (funcs != null) { for (let rf in funcs as GrowableArray) { var mode = new FnMode("", "", "", "", false); var label = ""; if (rf.tag == ResourceFuncTag.Constructor) { mode = new FnMode("[constructor]" + resourceName, "create", rawPrefix + "Create", "static ", false, resourceName); label = resourceName + " constructor"; } else if (rf.tag == ResourceFuncTag.Static) { let fnName = rf.func.name.name; mode = new FnMode(`[static]${resourceName}.${fnName}`, zenaMemberName(fnName), rawPrefix + pascalName(fnName), "static ", false); label = `${resourceName}.${fnName}`; } else { let fnName = rf.func.name.name; mode = new FnMode(`[method]${resourceName}.${fnName}`, zenaMemberName(fnName), rawPrefix + pascalName(fnName), "", true); label = `${resourceName}.${fnName}`; } let reason = renderFuncIn(members, raws, rf.func, interfaceName, ifaceItems, uses, mode); if (reason != "") { skipped.append("// ").append(label).append(": ") .append(reason).append("\n"); } } } let comment = `/** WIT \`resource ${resourceName}\`. */`; if (ownedClass) { // A `resource class`: the program holds it as `Own`, implicit // drop releases it at scope exit, a move ends the binding, and the // checker reports a use after the move. Dispose consumes the // receiver and drops the handle; there is no moved flag, because // lowering an own disowns the wrapper instead. Each declaration of // the drop is its own core import, named apart by the suffix, as // the stream and future families are. uses.ownHandle = true; let canonType = `resource:${interfaceName}#${resourceName}`; emit(body, "", zena` ${comment} export resource class ${typeName} { #handle: i32; new(handle: i32) : #handle = handle; /** The wire handle, module-internal. */ [rawHandle](): i32 { return this.#handle; } [Disposable.dispose](this: Own): void { ${rawPrefix}Drop_raw(this.#handle); } ${members.toString()} } @external("canon", "resource.drop#${interfaceName}#${resourceName}", "${canonType}") declare function ${rawPrefix}Drop_raw(handle: i32): void; ${raws.toString()} `); return; } body.append(comment).append("\n"); body.append("export final class ").append(typeName) .append(" implements Disposable {\n"); body.append(" #handle: i32;\n"); body.append(" var #dropped = false;\n"); body.append(" new(handle: i32) : #handle = handle;\n\n"); body.append(" /** The wire handle, module-internal. */\n"); body.append(" [rawHandle](): i32 {\n return this.#handle;\n"); body.append(" }\n\n"); body.append(" /** The handle transferred to the host (an own\n"); body.append(" * parameter consumed it): dispose becomes a no-op,\n"); body.append(" * because the callee owns the drop now. Until affine\n"); body.append(" * checking covers these wrappers, a *use* after the\n"); body.append(" * move is a runtime trap rather than a compile\n"); body.append(" * error. */\n"); body.append(" [markMoved](): void {\n"); body.append(" this.#dropped = true;\n }\n\n"); body.append(" [Disposable.dispose](): void {\n"); body.append(" if (!this.#dropped) {\n"); body.append(" this.#dropped = true;\n"); body.append(" ").append(rawPrefix).append("Drop_raw(this.#handle);\n"); body.append(" }\n }\n\n"); body.append(members.toString()); body.append("}\n"); // Per resource: each declaration is its own core import, named // apart by the suffix, as the stream and future families are. body.append("@external(\"canon\", \"resource.drop#") .append(interfaceName).append("#").append(resourceName) .append("\", \"resource:") .append(interfaceName).append("#").append(resourceName) .append("\")\n"); body.append("declare function ").append(rawPrefix) .append("Drop_raw(handle: i32): void;\n"); body.append(raws.toString()); } /** A WIT `record`, as a case class. */ function renderRecord(sb: StringBuilder, td: TypeDef, ifaceItems: GrowableArray, uses: SynthUses) { let ty = classifyNamed(td.name.name, ifaceItems); let blocked = liftBlocker(ty, false); if (blocked != "") { return blocked; } let comment = `/** WIT \`record ${td.name.name}\`. */`; var fields = ""; for (var i = 0; i < ty.children.length; i += 1) { if (i > 0) { fields = `${fields}, `; } fields = `${fields}${ty.childNames[i]}: ${zenaTypeOf(ty.children[i], uses)}`; } emit(sb, "", zena` ${comment} export class ${ty.typeName}(${fields}) `); sb.append("\n"); return ""; } /** A WIT `variant`, as a sealed case-class hierarchy. */ function renderVariant(sb: StringBuilder, td: TypeDef, ifaceItems: GrowableArray, uses: SynthUses) { let ty = classifyNamed(td.name.name, ifaceItems); let blocked = liftBlocker(ty, false); if (blocked != "") { return blocked; } let comment = `/** WIT \`variant ${td.name.name}\`. */`; let cases = new GrowableArray(); for (var i = 0; i < ty.children.length; i += 1) { let payload = if (!isVoid(ty.children[i])) { `(value: ${zenaTypeOf(ty.children[i], uses)})` } else { "" }; cases.push(`case ${ty.childNames[i]}${payload}`); } emit(sb, "", zena` ${comment} export sealed class ${ty.typeName} { ${cases} } `); sb.append("\n"); return ""; } /** * The namespaces the WIT document declares packages under — its own * and each nested `package ns:name { ... }` — each once. A program * compiled against a declared world imports the world's interfaces * by name, `ns:name/iface`, and the resolver maps a specifier's * namespace to a package; these are the namespaces the document * itself answers for. */ export function declaredPackageNamespaces(witSource: String): GrowableArray { // Syntax only: the world's `use` paths reach packages the compiler // splices in later, and the package names need no resolution. let ast = parseSyntax(witSource); let names = new Array(); let add = (pkg: PackageName | null) => { if (pkg == null) { return; } let ns = (pkg as PackageName).namespace.name; for (let known in names) { if (known == ns) { return; } } names.push(ns); }; add(ast.packageName); for (let nested in ast.nestedPackages) { add(nested.name); } return names; } /** Where the root ends in a `wit:#` canonical path: its `#`. */ function witRootEnd(canonicalPath: String) { var hash = -1; for (var i = 4; i < canonicalPath.length; i += 1) { if (canonicalPath.getByteAt(i) == 35) { // '#' hash = i; } } if (hash < 0) { throw new Error("Malformed WIT module path: " + canonicalPath); } return hash; } /** * The WIT root a `wit:#:` canonical path names: * the file or directory whose document its module is synthesized from. */ function witRootOf(canonicalPath: String) { return canonicalPath.sliceBytes(4, witRootEnd(canonicalPath)); } var memoWasiDir = ""; var memoWasiWit = ""; async function readWasiWit(host: CompilerHost, witDir: String): Future { if (memoWasiDir == witDir && memoWasiWit != "") { return memoWasiWit; } let source = await readWitSource(host, witDir); memoWasiDir = witDir; memoWasiWit = source; return source; } /** * The synthesized Zena source for a `wit:#:` * canonical path, its root's document read through `host`. * `packagesWit` is the program's WIT-backed packages' source, spliced * in where the root's document lacks it: a declared world's document * is a root too, and its worlds import `wasi:cli` by name, which the * parser resolves. */ export async function synthesizeWitModule(host: CompilerHost, canonicalPath: String, packagesWit: String = ""): Future { let spec = canonicalPath.sliceBytes(witRootEnd(canonicalPath) + 1, canonicalPath.length); var colon = -1; for (var i = 0; i < spec.length; i += 1) { if (spec.getByteAt(i) == 58) { // ':' colon = i; break; } } let namespace = spec.sliceBytes(0, colon); let interfacePath = spec.sliceBytes(colon + 1, spec.length); var allPackages = packagesWit; let root = witRootOf(canonicalPath); if (root == "host-wit" || root.endsWith("/host-wit")) { if (!allPackages.contains("wasi:http@0.3.0")) { let prefix = if (root == "host-wit") "" else root.sliceBytes(0, root.length - 8); let witDir = if (prefix == "") "wit" else prefix + "wit"; try { let wasiWit = await readWasiWit(host, witDir); allPackages = if (allPackages == "") wasiWit else `${allPackages}\n${wasiWit}`; } catch (e) { // Leave allPackages as is if wit directory cannot be read } } } // The splice appends, so the spans the type text is read from hold. // Every read is above this line: what follows writes the module-level // state the synthesis reads, and runs without suspending. let witSource = withWasiPackages( await readWitSource(host, root), allPackages); reinterpretUsed = false; currentWitSource = witSource; let ast = parsedWit(witSource); let iface = findInterface(ast, namespace, interfacePath); currentAst = ast; currentPackage = iface.packageName; selfSpecifier = `${namespace}:${interfacePath}`; currentSpecifier = selfSpecifier; usedTypeImports = new Array(); exportedInterfaces = new Array(); programResources = new Array(); let version = iface.packageName.version; var interfaceName = `${namespace}:${interfacePath}`; if (version != null) { interfaceName = `${interfaceName}@${version as String}`; } let sb = new StringBuilder(); sb.append("// Synthesized from WIT: ").append(interfaceName) .append(". Do not edit.\n"); let body = new StringBuilder(); let skipped = new StringBuilder(); let uses = new SynthUses(); for (let item in iface.def.items) { if (item.tag != InterfaceItemTag.Func) { if (item.tag == InterfaceItemTag.TypeDef) { let td = item.typeDef as TypeDef; var reason = ""; if (td.tag == TypeDefTag.Enum) { renderEnum(body, td); } else if (td.tag == TypeDefTag.Flags) { renderFlags(body, td); } else if (td.tag == TypeDefTag.Record) { reason = renderRecord(body, td, iface.def.items, uses); } else if (td.tag == TypeDefTag.Variant) { reason = renderVariant(body, td, iface.def.items, uses); } else if (td.tag == TypeDefTag.Resource) { renderResource(body, skipped, td, interfaceName, iface.def.items, uses); } else if (td.tag != TypeDefTag.Alias) { reason = "types wait on the interop stages"; } if (reason != "") { skipped.append("// ").append(td.name.name).append(": ") .append(reason).append("\n"); } } continue; } let nf = item.func as NamedFunc; let rendered = renderFunc(body, nf, interfaceName, iface.def.items, uses); if (rendered != "") { skipped.append("// ").append(nf.name.name).append(": ") .append(rendered).append("\n"); } } drainHelpers(body, uses, interfaceName); emitHelperTrailer(body, uses); if (uses.fixedArray) { sb.append("import { FixedArray } from 'zena:core';\n"); } if (uses.array) { sb.append("import { Array } from 'zena:core';\n"); } if (uses.option) { sb.append("import { Option, Some, some, none } from 'zena:core';\n"); } if (uses.result) { sb.append("import { Result } from 'zena:core';\n"); } if (uses.stream) { sb.append(streamImport(uses)); } if (uses.abi.length > 0) { sb.append("import { "); for (var i = 0; i < uses.abi.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(uses.abi[i]); } sb.append(" } from 'zena:wasi';\n"); } if (uses.componentStream.length > 0) { sb.append("import { "); for (var i = 0; i < uses.componentStream.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(uses.componentStream[i]); } sb.append(" } from 'zena:wasi';\n"); } // Sibling synthesized modules whose types this interface `use`s: // the declarations live there, so this module imports them. { let specifiers = new Array(); for (let u in usedTypeImports) { var known = false; for (let s in specifiers) { if (s == u.specifier) { known = true; } } if (!known) { specifiers.push(u.specifier); } } for (let spec in specifiers) { sb.append("import { "); var first = true; for (let u in usedTypeImports) { if (u.specifier != spec) { continue; } if (!first) { sb.append(", "); } first = false; sb.append(u.name); } sb.append(" } from '").append(spec).append("';\n"); } } if (uses.anyResource) { sb.append("import { Disposable } from 'zena:core';\n"); } sb.append(handleImports(uses)); if (uses.error) { sb.append("import { Error } from 'zena:core';\n"); } if (uses.deferred) { sb.append("import { DeferredFuture } from 'zena:async';\n"); } if (uses.hasAsync && uses.awaitWaitable) { sb.append("import { awaitPacked, awaitWaitable } " + "from 'zena:wasi';\n"); } else if (uses.hasAsync) { sb.append("import { awaitPacked } from 'zena:wasi';\n"); } else if (uses.awaitWaitable) { sb.append("import { awaitWaitable } from 'zena:wasi';\n"); } if (reinterpretUsed) { sb.append(reinterpretImport); } sb.append(body.toString()); let skippedText = skipped.toString(); if (skippedText != "") { sb.append("// Not yet importable from this interface ") .append("(docs/design/component-model.md):\n") .append(skippedText); } return sb.toString(); } /** * The lift and future helpers registered so far, into `body`. Lift * helpers registered while rendering may register more as they are * emitted (a record's field lifting a nested option), so this drains * a worklist rather than walking a snapshot. Future helpers join the * same drain: emitting one may register payload lift helpers, and a * payload may register further futures. A future's canon type is * named against `interfaceName` — the interface whose function moved * it, which is where its payload's named types resolve — so a module * that renders several interfaces' functions drains after each. */ function drainHelpers(body: StringBuilder, uses: SynthUses, interfaceName: String): void { while (uses.emittedLifts < uses.lifts.length || uses.emittedFlatLifts < uses.flatLifts.length || uses.emittedFutures < uses.futures.length || uses.emittedStreams < uses.streams.length) { while (uses.emittedLifts < uses.lifts.length) { let entry = uses.lifts[uses.emittedLifts]; uses.emittedLifts += 1; emit(body, "", emitLiftHelper(entry, uses)); body.append("\n"); } while (uses.emittedFlatLifts < uses.flatLifts.length) { let entry = uses.flatLifts[uses.emittedFlatLifts]; uses.emittedFlatLifts += 1; emit(body, "", emitFlatLiftHelper(entry, uses)); body.append("\n"); } if (uses.emittedFutures < uses.futures.length) { emitFutureHelpers(body, uses.futures[uses.emittedFutures], interfaceName, uses); uses.emittedFutures += 1; } if (uses.emittedStreams < uses.streams.length) { emitStreamHelpers(body, uses.streams[uses.emittedStreams], interfaceName, uses); uses.emittedStreams += 1; } } } /** * The table behind each resource the program provides: instances by * representation (the index a handle carries), the registration a * constructor or an own result goes through, the lookup a method's * `self` or a borrowed parameter goes through, the destructor the * host calls when the last handle over an instance is dropped, and * the canon `resource.new` that mints a handle over a representation. * The destructor frees the slot for reuse and disposes the instance: * the class behind a resource is a `Disposable`, the way the handle * class a consumer gets is, and its `dispose` is what the destructor * means. A class that is not one fails the wrapper's type check. An * own handle arriving as a parameter is the caller giving the instance * up: it is taken back out of the table and handed to the program as * the class, and the handle dropped — which reaches the destructor, * which finds the slot already cleared and disposes nothing. */ function emitProgramResourceTables(body: StringBuilder, uses: SynthUses) { for (let r in programResources) { uses.array = true; let prefix = camelName(r.witName); let table = `${prefix}Table`; body.append("\n"); emit(body, "", zena` /** The program's ${r.className} instances behind WIT resource * ${r.witName}, by representation, and the slots freed by the * destructor. */ let ${table} = new Array<${r.className} | null>(); let ${prefix}Free = new Array(); function ${prefix}Register(value: ${r.className}): i32 { if (${prefix}Free.length > 0) { let rep = ${prefix}Free.pop(); ${table}[rep] = value; return rep; } ${table}.push(value); return ${table}.length - 1; } function ${prefix}At(rep: i32): ${r.className} { return ${table}[rep] as ${r.className}; } /** An own handle arriving: the caller gave the instance up, so it * leaves the table and goes to the program as the class. The * handle is dropped, which reaches the destructor below with the * slot already cleared, so nothing is disposed. */ function ${prefix}Take(handle: i32): ${r.className} { let rep = ${prefix}Rep_raw(handle); let value = ${table}[rep] as ${r.className}; ${table}[rep] = null; ${prefix}Drop_raw(handle); ${prefix}Free.push(rep); return value; } /** The destructor: the host calls it when the last handle over * the instance at rep is dropped, from whichever component held * it. The class is a Disposable, and this is its dispose. */ export function ${prefix}__dtor(rep: i32): void { let value = ${table}[rep]; if (value == null) { return; } ${table}[rep] = null; ${prefix}Free.push(rep); (value as ${r.className}).[Disposable.dispose](); } @external("canon", "resource.new#${r.qualified}#${r.witName}", "resource:${r.qualified}#${r.witName}") declare function ${prefix}New_raw(rep: i32): i32; @external("canon", "resource.rep#${r.qualified}#${r.witName}", "resource:${r.qualified}#${r.witName}") declare function ${prefix}Rep_raw(handle: i32): i32; @external("canon", "resource.drop#${r.qualified}#${r.witName}", "resource:${r.qualified}#${r.witName}") declare function ${prefix}Drop_raw(handle: i32): void; `); body.append("\n"); } } /** The helpers a rendered module owes once, after every drain: the * bare-result stand-in and the enum discriminant checks. */ function emitHelperTrailer(body: StringBuilder, uses: SynthUses): void { if (uses.unit) { body.append("/** The one spellable void value: a bare result ") .append("arm's stand-in. */\n"); body.append("function witUnit(): void {}\n"); } for (let lifted in uses.enumLifts) { // The host is obligated to produce a valid discriminant, but a // range check is one compare, and an out-of-range value cast // silently into an enum would defeat exhaustive matching somewhere // far from here. body.append("function lift").append(lifted.typeName) .append("(disc: i32): ").append(lifted.typeName) .append(" {\n if (disc < 0 || disc >= ") .append(i32ToString(lifted.caseCount)) .append(") {\n throw new Error('invalid ") .append(lifted.typeName).append(" discriminant');\n }\n") .append(" return disc as ").append(lifted.typeName) .append(";\n}\n"); } } /** * Render one function — a plain `@external` declaration when * everything is a flat scalar, a raw declaration plus a marshaling or * future wrapper otherwise — or return the reason it cannot be * rendered yet. */ /** How one WIT function renders: as a free function, or as a member * of a synthesized resource class. */ final class FnMode { /** The `@external` field name: the WIT name, or a mangled * `[method]r.f` / `[static]r.f` / `[constructor]r`. */ externField: String; /** The Zena name of the wrapper. */ zenaName: String; /** The raw declaration's name (module-level, so resource-prefixed). */ rawName: String; /** The wrapper's declaration head: `"export function "` for a free * function, `""` for a method, `"static "` for a static or a WIT * constructor. */ declHead: String; /** Whether the raw call leads with `this.#handle`. */ selfHandle: boolean; /** A WIT constructor's implicit `own` result: the resource's WIT * name, or "" for everything else. */ ctorResource: String; new(this.externField, this.zenaName, this.rawName, this.declHead, this.selfHandle, this.ctorResource = ""); } /** Zena keywords a WIT name may collide with (`new: static func` is * real, in wasi:http); the member gets a trailing underscore, which no * other synthesized name contains. */ function zenaMemberName(witName: String): String { let camel = camelName(witName); if (camel == "new" || camel == "match" || camel == "let" || camel == "var" || camel == "function" || camel == "return" || camel == "this" || camel == "class" || camel == "enum" || camel == "type" || camel == "import" || camel == "export" || camel == "using" || camel == "true" || camel == "false" || camel == "null" || camel == "if" || camel == "else" || camel == "for" || camel == "while" || camel == "in" || camel == "is" || camel == "as" || camel == "case") { return camel + "_"; } return camel; } function renderFunc( sb: StringBuilder, nf: NamedFunc, interfaceName: String, ifaceItems: GrowableArray, uses: SynthUses ): String { let zenaName = camelName(nf.name.name); return renderFuncIn(sb, sb, nf, interfaceName, ifaceItems, uses, new FnMode(nf.name.name, zenaName, zenaName, "export function ", false)); } /** * The spilled parameters of one call: a staged buffer holding the * `self` handle (a method's first parameter) and then each parameter * at its aligned offset, lowered the way a record's fields are. The * buffer is arena-tracked, so the wrapper's release after the call * frees it with everything else it staged — after the subtask has * returned, for an async lowering, since the callee reads the * parameters out of the caller's memory when it starts. */ function emitSpilledParams(sb: StringBuilder, params: GrowableArray, paramNames: GrowableArray, selfHandle: boolean, uses: SynthUses) { var offset = 0; var maxAlign = 1; let offsets = new Array(); if (selfHandle) { offset = 4; maxAlign = 4; } for (let p in params) { if (p.align > maxAlign) { maxAlign = p.align; } offset = alignTo(offset, p.align); offsets.push(offset); offset += p.size; } let size = `${alignTo(offset, maxAlign)}`; uses.useAbi("stageBuffer"); uses.stagedAny = true; let stores = new Array(); if (selfHandle) { uses.useAbi("storeI32"); stores.push(zena`storeI32(args, this.#handle);`); } for (var i = 0; i < params.length; i += 1) { let at = if (offsets[i] == 0) "args" else `args + ${offsets[i]}`; stores.push(lowerMemStmts(params[i], paramNames[i], at, uses)); } emit(sb, " ", zena` let args = stageBuffer(${size}); ${stores} `); sb.append("\n"); } /** * Render one function into `wrapSink` (the wrapper) and `rawSink` * (the raw declaration — module level, which for a resource member is * a different sink than the class body). Returns the reason it cannot * be rendered yet, or "". */ function renderFuncIn( wrapSink: StringBuilder, rawSink: StringBuilder, nf: NamedFunc, interfaceName: String, ifaceItems: GrowableArray, uses: SynthUses, mode: FnMode ): String { let func = nf.func; let params = new Array(); let paramNames = new Array(); var anyRich = false; for (var i = 0; i < func.params.length; i += 1) { let wire = classifyType(func.params[i].type, ifaceItems); if (wire.kind == TyKind.Unsupported) { return `parameter '${func.params[i].name.name}': ${wire.reason}`; } let blocked = lowerBlocker(wire); if (blocked != "") { return `parameter '${func.params[i].name.name}': ${blocked}`; } if (flatCoreSlots(wire) == null) { return "parameter '" + func.params[i].name.name + "': its variant payloads join across core types, which " + "waits on the interop stages"; } if (wire.kind != TyKind.Scalar) { anyRich = true; } params.push(wire); // The same keyword mangling members get: wasi:http spells // `consume-body: static func(this: request, ...)`, and `this` is // not a parameter name Zena will take. paramNames.push(zenaMemberName(func.params[i].name.name)); } var paramFlats = 0; for (let p in params) { paramFlats += (flatCoreSlots(p) as GrowableArray).length; } // Past sixteen core values in a synchronous lowering, or four in an // asynchronous one, the parameters — a method's `self` handle among // them — travel as one address: the wrapper lays them out in memory // it owns, back to back at their aligned offsets, and the raw call // takes that address alone. The encoder counts the same way. let selfFlats = if (mode.selfHandle) 1 else 0; let paramsSpill = paramFlats + selfFlats > (if (func.isAsync) 4 else 16); var resultTy = voidTy(); var hasResult = false; if (mode.ctorResource != "") { // A WIT constructor returns `own` implicitly. hasResult = true; resultTy = classifyNamed(mode.ctorResource, ifaceItems); } let result = func.result; if (result != null) { hasResult = true; resultTy = classifyType(result as Type, ifaceItems); if (resultTy.kind == TyKind.Unsupported) { return "the result: " + resultTy.reason; } let blocked = liftBlocker(resultTy, false); if (blocked != "") { return "the result: " + blocked; } if (resultTy.kind != TyKind.Scalar) { anyRich = true; } // A bare `-> result` (both arms void) is one discriminant on the // wire, returned directly and rebuilt from `witUnit()` lanes. let bareResult = resultTy.kind == TyKind.ResultT && isVoid(resultTy.children[0]) && isVoid(resultTy.children[1]); if (resultTy.flats == 1 && !bareResult && resultTy.kind != TyKind.Enumeration && resultTy.kind != TyKind.Flags && resultTy.kind != TyKind.Scalar && resultTy.kind != TyKind.ResourceH && resultTy.kind != TyKind.StreamH && resultTy.kind != TyKind.FutureH) { return "a single-flat aggregate result waits on the interop stages"; } } let zenaName = mode.zenaName; let freeMode = mode.declHead == "export function " && !mode.selfHandle; if (func.isAsync) { if (!anyRich && !hasResult && freeMode && !paramsSpill) { // Flat scalars, no result: the thin form. The raw import's core // result is the packed `(subtask << 4) | state` the canonical // `async` lowering returns; `awaitPacked` turns it into the // future. The `_raw` suffix cannot collide with another // rendered function: WIT names are kebab-case, so no camelName // output contains an underscore. uses.hasAsync = true; let sig = new StringBuilder(); let args = new StringBuilder(); for (var i = 0; i < params.length; i += 1) { if (i > 0) { sig.append(", "); args.append(", "); } sig.append(paramNames[i]).append(": ").append(params[i].scalar); args.append(paramNames[i]); } rawSink.append("@external(\"").append(interfaceName) .append("\", \"").append(nf.name.name) .append("\", \"async\")\n"); rawSink.append("declare function ").append(zenaName) .append("_raw(").append(sig.toString()).append("): i32;\n"); rawSink.append("export function ").append(zenaName) .append("(").append(sig.toString()) .append("): Future {\n return awaitPacked(") .append(zenaName).append("_raw(").append(args.toString()) .append("));\n}\n"); return ""; } // Anything richer — and every resource function, whose `self` // handle the general path prefixes — takes the general path // below as an async wrapper: stage, call, await the subtask, then // lift the result the host wrote through the trailing return area // — an async lowering spills any result, whatever its flat count. } // The result spills — the raw call takes a return area address and // returns nothing — exactly when it flattens to more than one core // value. An async result always spills. let resultSpills = if (func.isAsync) hasResult else resultTy.flats > 1; if (!anyRich && freeMode && !paramsSpill && !func.isAsync) { // Every type is a flat scalar: one declaration, no wrapper. An // async function with a result never is: its result rides the // trailing return area, so it takes the wrapper below. let sig = new StringBuilder(); for (var i = 0; i < params.length; i += 1) { if (i > 0) { sig.append(", "); } sig.append(paramNames[i]).append(": ").append(params[i].scalar); } rawSink.append("@external(\"").append(interfaceName).append("\", \"") .append(nf.name.name).append("\")\n"); rawSink.append("export declare function ").append(zenaName) .append("(").append(sig.toString()).append("): ") .append(if (hasResult) resultTy.scalar else "void") .append(";\n"); return ""; } // The raw declaration: staged strings and lists are (ptr, len) // pairs, an aggregate is its flattened core slots, and a spilled // result appends the return area address. let aggregate = (kind: TyKind) => kind == TyKind.ListT || kind == TyKind.RecordT || kind == TyKind.VariantT || kind == TyKind.OptionT || kind == TyKind.TupleT; let rawSig = new StringBuilder(); var rawIndex = 0; if (paramsSpill) { rawSig.append("args: i32"); rawIndex += 1; } else if (mode.selfHandle) { rawSig.append("self: i32"); rawIndex += 1; } for (var i = 0; i < params.length && !paramsSpill; i += 1) { if (rawIndex > 0) { rawSig.append(", "); } if (params[i].kind == TyKind.Scalar) { rawSig.append("a").append(i32ToString(i)).append(": ") .append(params[i].scalar); rawIndex += 1; } else if (params[i].kind == TyKind.Enumeration) { rawSig.append("a").append(i32ToString(i)).append(": i32"); rawIndex += 1; } else if (params[i].kind == TyKind.Flags) { rawSig.append("a").append(i32ToString(i)).append(": u32"); rawIndex += 1; } else if (params[i].kind == TyKind.ResourceH || params[i].kind == TyKind.StreamH || params[i].kind == TyKind.FutureH) { rawSig.append("a").append(i32ToString(i)).append(": i32"); rawIndex += 1; } else if (aggregate(params[i].kind)) { let slots = flatCoreSlots(params[i]) as GrowableArray; for (var k = 0; k < slots.length; k += 1) { if (k > 0) { rawSig.append(", "); } rawSig.append("s").append(i32ToString(i)).append("_") .append(i32ToString(k)).append(": ").append(slots[k]); } rawIndex += slots.length; } else { rawSig.append("p").append(i32ToString(i)).append(": i32, l") .append(i32ToString(i)).append(": i32"); rawIndex += 2; } } if (resultSpills) { if (rawIndex > 0) { rawSig.append(", "); } rawSig.append("ret: i32"); } let rawResult = if (func.isAsync) { "i32" } else if (resultSpills || !hasResult) { "void" } else if (resultTy.kind == TyKind.Enumeration) { "i32" } else if (resultTy.kind == TyKind.Flags) { "u32" } else if (resultTy.kind == TyKind.ResourceH || resultTy.kind == TyKind.StreamH || resultTy.kind == TyKind.FutureH || resultTy.kind == TyKind.ResultT) { // A non-spilled result is the bare `-> result`: one discriminant. "i32" } else { resultTy.scalar }; rawSink.append("@external(\"").append(interfaceName).append("\", \"") .append(mode.externField); if (func.isAsync) { rawSink.append("\", \"async"); } rawSink.append("\")\n"); rawSink.append("declare function ").append(mode.rawName) .append("_raw(").append(rawSig.toString()).append("): ") .append(rawResult).append(";\n"); // The wrapper: the WIT signature in Zena spellings, staging in, // lifting out. Built into its own buffer so a member wrapper can be // reindented into the class body. let sb = new StringBuilder(); let wrapSig = new StringBuilder(); for (var i = 0; i < params.length; i += 1) { if (i > 0) { wrapSig.append(", "); } wrapSig.append(paramNames[i]).append(": ") .append(zenaTypeOf(params[i], uses)); } let bothArmsVoid = resultTy.kind == TyKind.ResultT && isVoid(resultTy.children[0]) && isVoid(resultTy.children[1]); var wrapResult = "void"; if (hasResult) { if (bothArmsVoid && !func.isAsync) { // A bare `-> result` has exactly two outcomes and no payloads: // a boolean, true for ok. The inline Result cannot carry two // zero-width lanes. wrapResult = "boolean"; } else if (resultTy.kind == TyKind.ResultT) { if (func.isAsync) { // A future's payload is stored, so the async form carries a // stored result. wrapResult = storedResultType(resultTy, uses); } else { uses.result = true; wrapResult = "inline Result<" + zenaTypeOf(resultTy.children[0], uses) + ", " + zenaTypeOf(resultTy.children[1], uses) + ">"; } } else { wrapResult = zenaTypeOf(resultTy, uses); } } var declHead = mode.declHead; if (func.isAsync) { uses.hasAsync = true; // A free function exports; a method, static or constructor keeps // its member head with `async` in front. declHead = if (freeMode) "export async function " else mode.declHead + "async "; wrapResult = `Future<${wrapResult}>`; } sb.append(declHead).append(zenaName).append("(") .append(wrapSig.toString()).append("): ").append(wrapResult) .append(" {\n"); // Release is by arena range: an async wrapper suspended on its // subtask still owns live staging (the callee may lift arguments // after the call returns), so each wrapper frees exactly what it // staged and nothing an interleaved wrapper still owes. var anyStaging = paramsSpill; for (let p in params) { if (mayStage(p)) { anyStaging = true; } } if (anyStaging) { uses.useAbi("stagedMark"); uses.useAbi("releaseStagedFrom"); sb.append(" let m0 = stagedMark();\n"); } let callArgs = new StringBuilder(); var argIndex = 0; if (paramsSpill) { emitSpilledParams(sb, params, paramNames, mode.selfHandle, uses); callArgs.append("args"); argIndex += 1; } for (var i = 0; i < params.length && !paramsSpill; i += 1) { if (argIndex > 0) { callArgs.append(", "); } if (params[i].kind == TyKind.Scalar) { callArgs.append(paramNames[i]); argIndex += 1; continue; } if (params[i].kind == TyKind.Enumeration) { callArgs.append(paramNames[i]).append(" as i32"); argIndex += 1; continue; } if (params[i].kind == TyKind.Flags) { callArgs.append(paramNames[i]).append(" as u32"); argIndex += 1; continue; } if (params[i].kind == TyKind.ResourceH) { let h = "h" + i32ToString(i); if (params[i].ownedClass) { sb.append(" let ").append(h).append(" = ") .append(loweredHandle(params[i], paramNames[i], uses)) .append(";\n"); callArgs.append(h); argIndex += 1; continue; } uses.useAbi("rawHandle"); sb.append(" let ").append(h).append(" = ").append(paramNames[i]) .append(".[rawHandle]();\n"); if (!params[i].isBorrow) { // An owned handle transfers to the callee: the wrapper's // later dispose must not drop an index it no longer owns. uses.useAbi("markMoved"); sb.append(" ").append(paramNames[i]) .append(".[markMoved]();\n"); } callArgs.append(h); argIndex += 1; continue; } if (params[i].kind == TyKind.StreamH) { callArgs.append(streamLowerCall(params[i], paramNames[i], uses)); argIndex += 1; continue; } if (params[i].kind == TyKind.FutureH) { callArgs.append("lowerFuture") .append(i32ToString(uses.futureIndexOf(params[i]))) .append("(").append(paramNames[i]).append(")"); argIndex += 1; continue; } if (aggregate(params[i].kind)) { // Zero-initialized slot variables, then the lowering statements: // an untaken option or a shorter variant arm leaves its slots at // zero, which the canonical ABI never reads. let slots = flatCoreSlots(params[i]) as GrowableArray; currentSlotTypes = slots; let slotNames = new Array(); for (var k = 0; k < slots.length; k += 1) { let slotName = `s${i32ToString(i)}_${i32ToString(k)}`; slotNames.push(slotName); let zero = if (slots[k] == "f32" || slots[k] == "f64") "0.0" else "0"; sb.append(" var ").append(slotName).append(": ") .append(slots[k]).append(" = ").append(zero).append(";\n"); } lowerFlatStmts(sb, params[i], paramNames[i], slotNames, 0, " ", uses); for (var k = 0; k < slotNames.length; k += 1) { if (k > 0) { callArgs.append(", "); } callArgs.append(slotNames[k]); } argIndex += slotNames.length; continue; } let stage = if (params[i].kind == TyKind.Str) { "stageString" } else { "stageByteList" }; uses.useAbi(stage); uses.stagedAny = true; sb.append(" let (p").append(i32ToString(i)).append(", l") .append(i32ToString(i)).append(") = ").append(stage) .append("(").append(paramNames[i]).append(");\n"); callArgs.append("p").append(i32ToString(i)).append(", l") .append(i32ToString(i)); argIndex += 2; } if (resultSpills) { uses.useAbi("resultArea"); sb.append(" let ret = resultArea(") .append(i32ToString(resultTy.size)).append(");\n"); if (argIndex > 0) { callArgs.append(", "); } callArgs.append("ret"); } let callPrefix = if (mode.selfHandle && !paramsSpill) { if (callArgs.toString() == "") "this.#handle" else "this.#handle, " } else { "" }; let call = `${mode.rawName}_raw(${callPrefix}${callArgs.toString()})`; if (func.isAsync) { // The call hands back the packed subtask; the await parks until // the host reports it returned — which is also when the trailing // return area holds the result and the staged arguments are // certainly consumed. sb.append(" let packed = ").append(call).append(";\n"); sb.append(" await awaitPacked(packed);\n"); } else if (resultSpills || rawResult == "void") { sb.append(" ").append(call).append(";\n"); } else { sb.append(" let got = ").append(call).append(";\n"); } // A synchronous lowering consumed the staged arguments during the // call; an asynchronous one has by the time the subtask returned. if (anyStaging) { sb.append(" releaseStagedFrom(m0);\n"); } if (resultSpills) { uses.useAbi("freeLifted"); if (resultTy.kind == TyKind.ResultT) { // A top-level result lifts into the inline Result, or, from an // async wrapper, into the stored Result a future carries. let payoff = payloadOffset(resultTy); let okZ = zenaTypeOf(resultTy.children[0], uses); let errZ = zenaTypeOf(resultTy.children[1], uses); // A bare arm has no bytes to lift and no local to bind — a // `void` local is not a thing — so its value is a `witUnit()` // call in argument position. var okExpr = "ok"; var errExpr = "err"; if (isVoid(resultTy.children[0])) { uses.unit = true; okExpr = "witUnit()"; } if (isVoid(resultTy.children[1])) { uses.unit = true; errExpr = "witUnit()"; } sb.append(" if (").append(discLoad(1, "ret", uses)) .append(" == 0) {\n"); if (okExpr == "ok") { sb.append(" let ok = ") .append(liftExprOf(resultTy.children[0], "ret + " + i32ToString(payoff), uses)) .append(";\n"); } sb.append(" freeLifted(ret);\n"); sb.append(" return ").append(okResultExpr(okExpr)) .append(";\n }\n"); if (errExpr == "err") { sb.append(" let err = ") .append(liftExprOf(resultTy.children[1], "ret + " + i32ToString(payoff), uses)) .append(";\n"); } sb.append(" freeLifted(ret);\n"); sb.append(" return ").append(errResultExpr(errExpr)) .append(";\n"); } else { sb.append(" let out = ") .append(liftExprOf(resultTy, "ret", uses)).append(";\n"); sb.append(" freeLifted(ret);\n"); sb.append(" return out;\n"); } } else if (resultTy.kind == TyKind.Enumeration) { uses.needEnumLift(resultTy); sb.append(" return lift").append(resultTy.typeName) .append("(got);\n"); } else if (resultTy.kind == TyKind.Flags) { sb.append(" return got as ").append(resultTy.typeName) .append(";\n"); } else if (resultTy.kind == TyKind.ResourceH) { sb.append(" return ").append(liftedHandle(resultTy, "got", uses)) .append(";\n"); } else if (resultTy.kind == TyKind.StreamH) { sb.append(" return ").append(streamLiftCall(resultTy, "got", uses)) .append(";\n"); } else if (resultTy.kind == TyKind.FutureH) { sb.append(" return liftFuture") .append(i32ToString(uses.futureIndexOf(resultTy))) .append("(got);\n"); } else if (resultTy.kind == TyKind.ResultT) { // The bare `-> result`: the wire value is the discriminant, and // the Zena shape is a boolean, true for ok. sb.append(" return got == 0;\n"); } else if (!func.isAsync && rawResult != "void") { sb.append(" return got;\n"); } sb.append("}\n"); if (freeMode) { wrapSink.append(sb.toString()); } else { // A member: two spaces onto every non-empty line. for (let line in sb.toString().split("\n")) { if (line != "") { wrapSink.append(" ").append(line); } wrapSink.append("\n"); } } return ""; } /** * One async function export of a declared world: at world level, or * of an exported interface, whose entry in the interfaces list, * qualified name (the `return:` scope) and module specifier it then * carries. */ final class AsyncWorldExport { name: String; func: Func; var interfaceIndex = -1; var qualifiedInterface = ""; var specifier = ""; /** For a resource's function: the resource's WIT name, the kind * ("constructor", "method", "static") and the member's WIT name. */ var resourceName = ""; var kind = ""; var member = ""; new(this.name, this.func); /** The wrapper's target: the class for a resource's function, the * function itself otherwise. */ target(): ExportTarget { if (this.resourceName == "") { return new ExportTarget(this.name, camelName(this.name)); } let prefix = camelName(this.resourceName); let memberZena = if (this.kind == "constructor") "" else zenaMemberName(this.member); return new ExportTarget(this.name, resourceWrapperBase(prefix, this.kind, camelName(this.member)), pascalName(this.resourceName), this.resourceName, this.kind, memberZena); } } /** * The entry wrapper for a program compiled against a declared world * (`--wit`/`--world`): one `_export` function per async * function export of the world, each declaring `task.return` at the * export's result type, plus `main`'s own wrapper when it returns a * scalar (component-entry.zena). Null when the program needs neither. * * A wrapper takes the export's flattened core parameters as the * canonical ABI hands them to the lift — a string as its pointer and * length in linear memory — lifts them, calls the program's function, * and hands the driver its future together with the typed return, * which lowers the future's value to the return's flat parameters * through the same staging the import wrappers use. Parameters may be * flat scalars and strings; a result may be anything the import path * lowers, a `result` carried as a stored `Result`. Named types are not * resolvable at world level yet (they need world-level `use`), and * anything refused fails the compile with the reason: the world * declares the export async, and nothing else could implement it. */ export function synthesizeExportWrapper( witSource: String, worldName: String, entryPath: String, entryAst: Module, packagesWit: String = "" ): ComponentEntryWrapper | null { // With the compiler's WASI WIT and the program's WIT-backed packages // riding along, as the declared-world encoder parses it. let source = withWasiPackages(witSource, packagesWit); let ast = parsedWit(source); var world: WorldDef | null = null; for (let item in ast.items) { if (item.tag == AstItemTag.World) { let def = item.worldDef as WorldDef; if (world == null && (worldName == "" || def.name.name == worldName)) { world = def; } } } // World-level async function exports, and the async functions of // each exported interface, which land in an instance of the // interface's name and resolve their named types through its // `use`s. let exports = new Array(); let interfaces = new Array(); let interfaceExports = new Array(); let noItemsForWorld = new Array(); if (world != null) { for (let wi in expandedWorldItems(ast, world)) { if (wi.tag != WorldItemTag.Export) { continue; } let kind = (wi.exportItem as Export).kind; if (kind.tag == ExternKindTag.Func) { let func = kind.funcDef as Func; if (!func.isAsync && !needsSyncWrapper(func, noItemsForWorld)) { continue; } let name = (kind.name as Id).name; // The world's async `main` is the entry: the component lifts // the program's async main on its own, with its typed return // declared by the entry wrapper (lib/component-entry.zena), and // a second wrapper here would export the name twice. if (name == "main" && hasAsyncMain(entryAst)) { continue; } exports.push(new AsyncWorldExport(name, func)); } else if (kind.tag == ExternKindTag.Path) { let path = kind.path as UsePath; var namespace = ""; var interfacePath = ""; if (path.tag == UsePathTag.Id) { let main = ast.packageName as PackageName; namespace = main.namespace.name; interfacePath = `${main.name.name}/${(path.id as Id).name}`; } else { let pkg = path.packageId as PackageName; namespace = pkg.namespace.name; interfacePath = `${pkg.name.name}/${(path.name as Id).name}`; } let found = findInterfaceOrNull(ast, namespace, interfacePath); if (found == null) { throw new Error("The declared world exports '" + namespace + ":" + interfacePath + "', which the document does not declare."); } let iface = found as FoundInterface; var qualified = `${namespace}:${interfacePath}`; let version = iface.packageName.version; if (version != null) { qualified = `${qualified}@${version as String}`; } for (let item in iface.def.items) { if (item.tag == InterfaceItemTag.TypeDef) { // A resource the program provides: every function of it // goes through a wrapper — a method's first parameter is // the representation to look the instance up by. let td = item.typeDef as TypeDef; if (td.tag != TypeDefTag.Resource) { continue; } for (let rf in td.resourceFuncs as GrowableArray) { var kind = "method"; var member = rf.func.name.name; var name = `[method]${td.name.name}.${member}`; if (rf.tag == ResourceFuncTag.Constructor) { kind = "constructor"; member = ""; name = "[constructor]" + td.name.name; } else if (rf.tag == ResourceFuncTag.Static) { kind = "static"; name = `[static]${td.name.name}.${member}`; } let e = new AsyncWorldExport(name, rf.func.func); e.interfaceIndex = interfaces.length; e.qualifiedInterface = qualified; e.specifier = `${namespace}:${interfacePath}`; e.resourceName = td.name.name; e.kind = kind; e.member = member; interfaceExports.push(e); } continue; } if (item.tag != InterfaceItemTag.Func) { continue; } let nf = item.func as NamedFunc; if (!nf.func.isAsync && !needsSyncWrapper(nf.func, iface.def.items)) { continue; } let e = new AsyncWorldExport(nf.name.name, nf.func); e.interfaceIndex = interfaces.length; e.qualifiedInterface = qualified; e.specifier = `${namespace}:${interfacePath}`; interfaceExports.push(e); } exportedInterfaces.push(new ExportedInterface( `${namespace}:${interfacePath}`, qualified)); interfaces.push(iface); } } } let mainResult = mainWrapperResultOf(entryAst); let mainIsAsync = hasAsyncMain(entryAst); if (exports.length == 0 && interfaceExports.length == 0 && mainResult == "") { return null; } currentWitSource = source; currentAst = ast; currentEntryAst = entryAst; currentPackage = ast.packageName; selfSpecifier = ""; currentSpecifier = ""; reinterpretUsed = false; usedTypeImports = new Array(); programResources = new Array(); let noItems = new Array(); let uses = new SynthUses(); let body = new StringBuilder(); let imported = new Array(); let importFromEntry = (name: String) => { for (let existing in imported) { if (existing == name) { return; } } imported.push(name); }; if (mainResult != "") { imported.push("main"); for (let name in mainWrapperAbiImports(mainResult, mainIsAsync)) { // Every wrapper imports `finishTask` already. if (name != "finishTask") { uses.useAbi(name); } } renderMainWrapper(body, mainResult, mainIsAsync); } for (let e in exports) { let target = e.target(); importFromEntry(target.base); body.append("\n"); if (e.func.isAsync) { renderExportWrapper(body, target, e.func, noItems, uses, ""); } else { renderSyncExportWrapper(body, target, e.func, noItems, uses); } // A world-level export's future is structural: its canon type // names no interface. drainHelpers(body, uses, ""); } for (let e in interfaceExports) { let iface = interfaces[e.interfaceIndex]; // Types classify in the interface's own context: a `use`d type // hops to its source module, which the wrapper then imports — and // so does a type the interface declares itself, from the // interface's own synthesized module, since the wrapper is not // that module. Hence no `selfSpecifier`: nothing is local here. currentPackage = iface.packageName; selfSpecifier = ""; currentSpecifier = e.specifier; let target = e.target(); if (target.resourceName != "") { // The class comes from the entry; classifying the resource // registers it for the table helpers below, and a constructor's // result is an own of it. importFromEntry(target.className); let resourceTy = classifyNamed(target.resourceName, iface.def.items); if (target.kind == "constructor") { target.implicitResult = resourceTy; } if (isPluginKindCreate(target, e.func) && !classHasStatic(entryAst, target.className, target.member)) { // A plugin kind's `create`: the wrapper writes it, returning // the object the program registered under the token when it // loaded the extension (zena:extensions, `claimPlugin`). uses.plugin = true; uses.error = true; let fn = `${target.className}__create`; target.calleeOverride = fn; body.append("\n"); body.append("/** The plugin kind's create: the object the program registered under\n"); body.append(" * `token` when it loaded the extension, which must be a ") .append(target.className).append(". */\n"); body.append("function ").append(fn).append("(token: u32): ") .append(target.className).append(" {\n"); body.append(" let object = claimPlugin(token);\n"); body.append(" if (object is ").append(target.className).append(") {\n"); body.append(" return object;\n"); body.append(" }\n"); body.append(" throw new Error(if (object == null) ") .append("`no plugin object was registered under token ${token}`") .append(" else `the plugin object registered under token ${token} is not a ") .append(target.className).append("`);\n"); body.append("}\n"); } } else { importFromEntry(target.base); } body.append("\n"); if (e.func.isAsync) { renderExportWrapper(body, target, e.func, iface.def.items, uses, e.qualifiedInterface); } else { renderSyncExportWrapper(body, target, e.func, iface.def.items, uses); } // A future this export moves — a `future` result the program's // `Future` lowers into — gets its helpers here, typed against // the exporting interface. drainHelpers(body, uses, e.qualifiedInterface); } emitHelperTrailer(body, uses); emitProgramResourceTables(body, uses); exportedInterfaces = new Array(); let specifier = componentEntrySpecifierFor(entryPath); let sb = new StringBuilder(); renderWrapperHeader(sb); sb.append("import { "); for (var i = 0; i < imported.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(imported[i]); } sb.append(" } from '").append(specifier).append("';\n"); sb.append("import { finishTask, finishVoidTask } from 'zena:wasi';\n"); if (uses.plugin) { sb.append("import { claimPlugin } from 'zena:extensions';\n"); } if (uses.option) { sb.append("import { Option, Some, some, none } from 'zena:core';\n"); } if (uses.array) { sb.append("import { Array } from 'zena:core';\n"); } if (uses.fixedArray) { sb.append("import { FixedArray } from 'zena:core';\n"); } if (uses.error) { sb.append("import { Error } from 'zena:core';\n"); } if (programResources.length > 0) { sb.append("import { Disposable } from 'zena:core';\n"); } sb.append(handleImports(uses)); if (uses.result) { sb.append("import { Result } from 'zena:core';\n"); } if (uses.stream) { sb.append(streamImport(uses)); } if (uses.abi.length > 0) { sb.append("import { "); for (var i = 0; i < uses.abi.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(uses.abi[i]); } sb.append(" } from 'zena:wasi';\n"); } if (uses.componentStream.length > 0) { sb.append("import { "); for (var i = 0; i < uses.componentStream.length; i += 1) { if (i > 0) { sb.append(", "); } sb.append(uses.componentStream[i]); } sb.append(" } from 'zena:wasi';\n"); } if (uses.deferred) { sb.append("import { DeferredFuture } from 'zena:async';\n"); } if (uses.awaitWaitable) { sb.append("import { awaitWaitable } from 'zena:wasi';\n"); } if (reinterpretUsed) { sb.append(reinterpretImport); } // The synthesized modules whose types the wrappers name: a resource // parameter lifts into its class, a result lowers out of one. { let specifiers = new Array(); for (let u in usedTypeImports) { var known = false; for (let s in specifiers) { if (s == u.specifier) { known = true; } } if (!known) { specifiers.push(u.specifier); } } for (let spec in specifiers) { sb.append("import { "); var first = true; for (let u in usedTypeImports) { if (u.specifier != spec) { continue; } if (!first) { sb.append(", "); } first = false; sb.append(u.name); } sb.append(" } from '").append(spec).append("';\n"); } } sb.append("\n").append(body.toString()); return new ComponentEntryWrapper(componentEntryPathFor(entryPath), sb.toString(), specifier, entryPath); } /** * Whether a declared synchronous export needs a wrapper: a parameter * or result that is not a flat scalar or a string. Those two a * program export lifts on its own (component-adapters wraps the * string); anything richer is marshaled here, typed from the WIT. */ function needsSyncWrapper(func: Func, items: GrowableArray): boolean { let plain = (ty: Ty) => ty.kind == TyKind.Scalar || ty.kind == TyKind.Str; // Past sixteen core values the host spills the parameters into // memory and the lift takes one address, which only the wrapper // knows to read. var flats = 0; for (let p in func.params) { let ty = classifyType(p.type, items); if (!plain(ty)) { return true; } flats += if (ty.kind == TyKind.Str) 2 else 1; } if (flats > 16) { return true; } let result = func.result; return result != null && !plain(classifyType(result as Type, items)); } /** * What an export wrapper reaches in the program: a free function by * name, or a resource's constructor, method or static through the * program's class. `witName` is the component export name * (`describe`, `[method]surface.on-frame`); `base` the wrapper's * identifier base (`describe`, `surface__method__onFrame`), which * `componentExportNameOf` reads the export name back from. */ /** * Whether `target` is a plugin kind's `create`: a static `create` of * a resource taking one `u32` and returning an own of that resource. */ function isPluginKindCreate(target: ExportTarget, func: Func): boolean { if (target.kind != "static" || target.member != "create") { return false; } if (func.params.length != 1 || func.params[0].type.tag != TypeTag.U32) { return false; } let result = func.result; if (result == null || (result as Type).tag != TypeTag.Own) { return false; } let inner = (result as Type).inner; return inner != null && (inner as Type).tag == TypeTag.Name && ((inner as Type).name as Id).name == target.resourceName; } final class ExportTarget { witName: String; base: String; /** The class behind a resource's function; "" for a free function. */ className: String; /** The resource's WIT name; "" for a free function. */ resourceName: String; /** "constructor", "method" or "static"; "" for a free function. */ kind: String; /** The member's Zena name on the class, for a method or static. */ member: String; /** A constructor's implicit result: an own of the resource. */ var implicitResult: Ty | null = null; /** A function the wrapper calls in place of the class's member, when * the wrapper writes the member itself: a plugin kind's `create`. */ var calleeOverride = ""; new(this.witName, this.base, this.className = "", this.resourceName = "", this.kind = "", this.member = ""); /** The expression the wrapper calls, before its argument list. */ callee(): String { if (this.calleeOverride != "") { return this.calleeOverride; } if (this.kind == "constructor") { return "new " + this.className; } if (this.kind == "method") { return "self0." + this.member; } if (this.kind == "static") { return `${this.className}.${this.member}`; } return this.base; } /** Whether the wrapper takes the resource's representation first. */ hasSelf(): boolean { return this.kind == "method"; } } /** * The parameters of an export wrapper, async or sync: the core-shaped * signature the lift calls with, the statements lifting each into its * Zena value, and the arguments to call the program's function with. * A method's `self` leads: the resource's representation, looked up * in the wrapper's table as `self0`. Throws with the reason on a * parameter this cannot marshal. */ final class WrapperParams { rawSig = new StringBuilder(); liftStmts = new StringBuilder(); callArgs = new StringBuilder(); } function renderWrapperParams(target: ExportTarget, func: Func, items: GrowableArray, uses: SynthUses) { let witName = target.witName; let refuse = (what: String, why: String) => new Error(`The declared world's export '${witName}', ${what}: ${why}`); let out = new WrapperParams(); let {rawSig, liftStmts, callArgs} = out; let selfPrefix = camelName(target.resourceName); // Every parameter classified and flattened first: past sixteen core // values in all — a method's `self` among them — the canonical ABI // spills them into memory and the lift takes one address. let tys = new GrowableArray(); let slotLists = new GrowableArray>(); var totalFlats = if (target.hasSelf()) 1 else 0; for (let p in func.params) { let ty = classifyType(p.type, items); if (ty.kind == TyKind.Unsupported) { throw refuse(`parameter '${p.name.name}'`, ty.reason); } if (ty.kind == TyKind.ResourceH && ty.isBorrow && !ty.isProgram) { throw refuse(`parameter '${p.name.name}'`, "a borrowed handle is the caller's for the call only, and a " + "wrapper cannot hand it to the program without disposing it " + "yet"); } var blocked = liftBlocker(ty, false); if (blocked == "") { blocked = paramLiftBlocker(ty); } if (blocked != "") { throw refuse(`parameter '${p.name.name}'`, blocked); } let slots = flatCoreSlots(ty); if (slots == null) { throw refuse(`parameter '${p.name.name}'`, "its variant payloads join across core types, which waits " + "on the interop stages"); } tys.push(ty); slotLists.push(slots as GrowableArray); totalFlats += (slots as GrowableArray).length; } for (var i = 0; i < func.params.length; i += 1) { if (i > 0) { callArgs.append(", "); } // A flat scalar is passed as it arrived, unless spilled. if (tys[i].kind == TyKind.Scalar && totalFlats <= 16) { callArgs.append("a").append(i32ToString(i)); } else { callArgs.append("v").append(i32ToString(i)); } } if (totalFlats > 16) { // Spilled: the parameters in memory, back to back at their aligned // offsets, in a buffer the host allocated through the lift's // realloc and the guest frees once everything is lifted. uses.useAbi("freeLifted"); rawSig.append("args: i32"); var offset = 0; if (target.hasSelf()) { uses.useAbi("loadI32"); liftStmts.append(` let self0 = ${selfPrefix}At(loadI32(args));\n`); offset = 4; } for (var i = 0; i < tys.length; i += 1) { let ty = tys[i]; offset = alignTo(offset, ty.align); let at = if (offset == 0) "args" else "args + " + i32ToString(offset); liftStmts.append(" let v").append(i32ToString(i)).append(" = ") .append(liftExprOf(ty, at, uses)).append(";\n"); offset += ty.size; } liftStmts.append(" freeLifted(args);\n"); return out; } if (target.hasSelf()) { rawSig.append("self: i32"); liftStmts.append(` let self0 = ${selfPrefix}At(self);\n`); } for (var i = 0; i < tys.length; i += 1) { let ty = tys[i]; let k = i32ToString(i); let slotTypes = slotLists[i]; if (i > 0 || target.hasSelf()) { rawSig.append(", "); } if (ty.kind == TyKind.Str) { // The host lowered the string into linear memory through the // lift's realloc; the guest owns that buffer and frees it once // the value is copied out. uses.useAbi("stringFromMemory"); uses.useAbi("releaseStringArgument"); rawSig.append("p").append(k).append(": i32, l").append(k) .append(": i32"); liftStmts.append(" let v").append(k).append(" = stringFromMemory(p") .append(k).append(", l").append(k).append(");\n"); liftStmts.append(" releaseStringArgument(p").append(k) .append(", l").append(k).append(");\n"); continue; } if (ty.kind == TyKind.Scalar) { // Declared at its own spelling: a scalar's core type is its own. rawSig.append("a").append(k).append(": ").append(ty.scalar); continue; } // One core value keeps the plain `aK` name; several are `aK_j`. let names = new GrowableArray(); for (var j = 0; j < slotTypes.length; j += 1) { let name = if (slotTypes.length == 1) "a" + k else `a${k}_${i32ToString(j)}`; names.push(name); if (j > 0) { rawSig.append(", "); } rawSig.append(name).append(": ").append(slotTypes[j]); } liftStmts.append(" let v").append(k).append(" = ") .append(liftFlatExpr(ty, slotTypes, names, 0, uses)).append(";\n"); } return out; } /** What `liftBlocker` does not ask: whether an export's parameter * holds a borrowed handle, which a wrapper cannot hand to the program * without also owning its disposal. The reason, or the empty string. */ function paramLiftBlocker(ty: Ty): String { if (ty.kind == TyKind.ResourceH && ty.isBorrow && !ty.isProgram) { return "a borrowed handle inside an aggregate cannot be lifted yet"; } for (let child in ty.children) { let inner = paramLiftBlocker(child); if (inner != "") { return inner; } } return ""; } /** * One synchronous export's `_export_sync` wrapper: the lift * calls it with the WIT's flattened parameters, it calls the program's * function, and it returns the result the way a synchronous lift * takes one — the one core value a result flattens to, or, past one, * the address of a return area holding the result in its canonical * layout, staged until the host has read it and `post-return` runs. * Throws with the reason on a parameter or result this cannot marshal. */ function renderSyncExportWrapper(sb: StringBuilder, target: ExportTarget, func: Func, items: GrowableArray, uses: SynthUses): void { let witName = target.witName; let base = target.base; let callee = target.callee(); let refuse = (what: String, why: String) => new Error(`The declared world's export '${witName}', ${what}: ${why}`); // A stream or future is pumped from the task that owns it, by the // host's callback re-entries — after the value has been returned, // for a result. A synchronous export has no task and is never // re-entered, so its pump would park forever on the first copy. let pumped = "a stream or future is pumped by callback re-entries, " + "which a synchronous export never gets; declare the export " + "`async func`"; for (let p in func.params) { if (carriesEnd(classifyType(p.type, items))) { throw refuse(`parameter '${p.name.name}'`, pumped); } } if (func.result != null && carriesEnd(classifyType(func.result as Type, items))) { throw refuse("the result", pumped); } let params = renderWrapperParams(target, func, items, uses); let result = func.result; // A constructor's result is implicit: an own of the resource. var resultTyOpt = target.implicitResult; if (resultTyOpt == null && result != null) { resultTyOpt = classifyType(result as Type, items); } if (resultTyOpt == null) { sb.append("export function ").append(base) .append(componentSyncExportSuffix).append("(") .append(params.rawSig.toString()).append("): void {\n"); sb.append(params.liftStmts.toString()); sb.append(" ").append(callee).append("(") .append(params.callArgs.toString()).append(");\n}\n"); return; } let resultTy = resultTyOpt as Ty; if (resultTy.kind == TyKind.Unsupported) { throw refuse("the result", resultTy.reason); } if (resultTy.kind == TyKind.ResultT) { for (let child in resultTy.children) { if (isVoid(child)) { continue; } let blocked = lowerBlocker(child); if (blocked != "") { throw refuse("the result", blocked); } } } else { let blocked = lowerBlocker(resultTy); if (blocked != "") { throw refuse("the result", blocked); } } let slotTypes = flatCoreSlots(resultTy) as GrowableArray; let zenaResult = futurePayloadZenaType(resultTy, uses); if (slotTypes.length == 1) { // One core value: returned as the call's result. sb.append("export function ").append(base) .append(componentSyncExportSuffix).append("(") .append(params.rawSig.toString()).append("): ") .append(slotTypes[0]).append(" {\n"); sb.append(params.liftStmts.toString()); sb.append(" let value = ").append(callee).append("(") .append(params.callArgs.toString()).append(");\n"); let zero = if (slotTypes[0] == "f32" || slotTypes[0] == "f64") "0.0" else "0"; sb.append(" var s0: ").append(slotTypes[0]).append(" = ") .append(zero).append(";\n"); let slotNames = growable(["s0"]); currentSlotTypes = slotTypes; lowerFlatStmts(sb, resultTy, "value", slotNames, 0, " ", uses); sb.append(" return s0;\n}\n"); return; } // Past one core value: the canonical layout in a return area. The // area and everything the value stages inside it (a string's bytes, // a list's elements) stay allocated until the host has read them // and calls `post-return`, which releases the staged range. uses.useAbi("stagedMark"); uses.useAbi("stageBuffer"); uses.useAbi("notePostReturn"); sb.append("export function ").append(base) .append(componentSyncExportSuffix).append("(") .append(params.rawSig.toString()).append("): i32 {\n"); sb.append(params.liftStmts.toString()); sb.append(" let value = ").append(callee).append("(") .append(params.callArgs.toString()).append(");\n"); sb.append(" let m0 = stagedMark();\n"); sb.append(" let ret = stageBuffer(") .append(i32ToString(resultTy.size)).append(");\n"); emit(sb, " ", lowerMemStmts(resultTy, "value", "ret", uses)); sb.append("\n"); sb.append(" notePostReturn(m0);\n"); sb.append(" return ret;\n}\n"); } /** * One async export's typed return and `_export` wrapper. Throws * with the reason on a parameter or result this cannot marshal. */ function renderExportWrapper(sb: StringBuilder, target: ExportTarget, func: Func, items: GrowableArray, uses: SynthUses, returnScope: String): void { let witName = target.witName; let base = target.base; let callee = target.callee(); let refuse = (what: String, why: String) => new Error("The declared world's async export '" + witName + "', " + what + ": " + why); let params = renderWrapperParams(target, func, items, uses); let {rawSig, liftStmts, callArgs} = params; let result = func.result; var hasResult = false; var resultTy = voidTy(); var zenaResult = "void"; let slotNames = new Array(); var slotTypes = new Array(); if (result != null) { hasResult = true; let resultType = result as Type; resultTy = classifyType(resultType, items); if (resultTy.kind == TyKind.Unsupported) { throw refuse("the result", resultTy.reason); } if (resultTy.kind == TyKind.ResultT) { for (let child in resultTy.children) { if (isVoid(child)) { continue; } let blocked = lowerBlocker(child); if (blocked != "") { throw refuse("the result", blocked); } } } else { let blocked = lowerBlocker(resultTy); if (blocked != "") { throw refuse("the result", blocked); } } let slots = flatCoreSlots(resultTy); if (slots == null) { throw refuse("the result", "its variant payloads join across " + "core types, which waits on the interop stages"); } slotTypes = slots as GrowableArray; if (slotTypes.length > 16) { throw refuse("the result", "a result spilling past sixteen core " + "values waits on the interop stages"); } zenaResult = futurePayloadZenaType(resultTy, uses); // The typed return, at the WIT's own spelling of the result: the // encoder writes the type, and the flat parameters are its // flattening. let typeText = spanText(resultType.span.start, resultType.span.end); sb.append("@external(\"canon\", \"task.return#").append(witName) .append("\", \"return:").append(returnScope).append("#") .append(typeText).append("\")\n"); sb.append("declare function taskReturn").append(pascalName(base)) .append("("); for (var k = 0; k < slotTypes.length; k += 1) { let slotName = "s" + i32ToString(k); slotNames.push(slotName); if (k > 0) { sb.append(", "); } sb.append(slotName).append(": ").append(slotTypes[k]); } sb.append("): void;\n\n"); } sb.append("export function ").append(base) .append(componentExportSuffix).append("(").append(rawSig.toString()) .append("): void {\n"); sb.append(liftStmts.toString()); if (!hasResult) { // Nothing to return, but not before the work is done. An async // implementation hands its future to the driver, which issues the // bare `task.return` once it settles: a task whose work pends on a // waitable another task armed has nothing in its own set, and // would otherwise exit at its first entry. A synchronous one is // done when it returns, and the driver's exit returns for it. let entry = currentEntryAst; let isAsyncCallee = entry != null && target.kind != "constructor" && exportedFunctionIsAsync(entry as Module, target.base, target.className, target.member); if (isAsyncCallee) { sb.append(" finishVoidTask(").append(callee).append("(") .append(callArgs.toString()).append("));\n}\n"); } else { sb.append(" ").append(callee).append("(").append(callArgs.toString()) .append(");\n}\n"); } return; } sb.append(" finishTask<").append(zenaResult).append(">(") .append(callee).append("(").append(callArgs.toString()) .append("), (value: ").append(zenaResult).append("): void => {\n"); let staging = mayStage(resultTy); if (staging) { // Staged until the return has consumed them: `task.return` lifts // its arguments during the call. uses.useAbi("stagedMark"); uses.useAbi("releaseStagedFrom"); sb.append(" let m0 = stagedMark();\n"); } for (var k = 0; k < slotNames.length; k += 1) { let zero = if (slotTypes[k] == "f32" || slotTypes[k] == "f64") "0.0" else "0"; sb.append(" var ").append(slotNames[k]).append(": ") .append(slotTypes[k]).append(" = ").append(zero).append(";\n"); } currentSlotTypes = slotTypes; lowerFlatStmts(sb, resultTy, "value", slotNames, 0, " ", uses); sb.append(" taskReturn").append(pascalName(base)).append("("); for (var k = 0; k < slotNames.length; k += 1) { if (k > 0) { sb.append(", "); } sb.append(slotNames[k]); } sb.append(");\n"); if (staging) { sb.append(" releaseStagedFrom(m0);\n"); } sb.append(" });\n}\n"); }