🥮 mooncakes.io

    marianoguerra/wax/wasm/bin does not have a README file

    FieldType

    source

    A struct field or array element type: a storage type plus mutability.

    GlobalType

    source

    A global's type: a value type plus mutability.

    HeapType

    source

    What a reference can point at.

    Limits

    source

    The size bounds of a memory or table.

    Upstream split this into a bare {min, max} plus is_memory64, page_size_log2 and is_table64 fields hung off the memory and table types. The shared spine already carries all of them, and carries shared besides, which upstream cannot express at all -- so a shared memory was silently unrepresentable there.

    RefType

    source

    A reference type: nullability plus what it points at.

    StorageType

    source

    What a struct field or array element stores.

    ValType

    source

    A value type, at the binary form's index instantiation.

    EncodeError

    source
    pub suberror EncodeError {
      UnresolvedBlockType
    } derive(Eq, 
    Debug    )

    A module that cannot be encoded as it stands.

    Upstream had no such error. It emitted 0x00 -- unreachable -- for any instruction its match did not cover, and an empty block type for any block whose signature had not been resolved to a type index. Both produce a wasm file that loads, validates and runs, and silently does the wrong thing; against a differential harness that is the worst possible failure mode, because the diff says "these bytes differ" rather than "this is unhandled".

    Only one case is left. The opcode table is now total over Instruction -- the compiler says so, which is why there is no "unsupported instruction" variant here.
    impl Show for EncodeError

    ArrayType

    source

    An array type.

    BlockType

    source

    What a block, loop or if consumes and produces.

    CatchHandler

    source
    pub(all) enum CatchHandler {
      Catch(Int, Int)
      CatchRef(Int, Int)
      CatchAll(Int)
      CatchAllRef(Int)
    } derive(Eq, 
    Debug    )

    One arm of a try_table.

    CompositeType

    source
    pub(all) enum CompositeType {
      Func(FuncType)
      Struct(StructType)
      Array(ArrayType)
      Cont(Int)
    } derive(Eq, 
    Debug    )

    What a defined type actually defines.

    CondGroup

    source

    One #[if(..)] group: the condition as the TEXT format writes it, and where each branch stood in the source.

    Data

    source
    pub(all) struct Data {
      mode : DataMode
      init : Bytes
      offset_spans : Array[Span]
      spelling : Array[DataPiece]
    } derive(Eq, 
    Debug    )

    DataMode

    source
    pub(all) enum DataMode {
      Active(Int, Array[Instruction])
      Passive
    } derive(Eq, 
    Debug    )

    How a data segment reaches its memory.

    Upstream had no such type: it hung a bare memory_idx off the segment and signalled "passive" with a NEGATIVE index. That makes an unrepresentable state representable -- an active segment with an empty offset expression -- and it decided the encoding from offset.is_empty(), so such a segment was silently written as active-at-an-explicit-memory instead.

    DataPiece

    source
    pub(all) enum DataPiece {
      PieceStr(Bytes)
      PieceRun(String, Array[String])
    } derive(Eq, 
    Debug    )

    One piece of a data segment, as the source wrote it.

    ElemMode

    source
    pub(all) enum ElemMode {
      Active(Int, Array[Instruction])
      Passive
      Declarative
    } derive(Eq, 
    Debug    )

    How an element segment reaches its table.

    Element

    source
    pub(all) struct Element {
      mode : ElemMode
      type_ : 
    RefType    [Int]
      init : Array[Array[Instruction]]
      init_spans : Array[Array[Span]]
      offset_spans : Array[Span]
    } derive(Eq, 
    Debug    )

    Export

    source
    pub(all) struct Export {
      name : Bytes
      desc : ExportDesc
    } derive(Eq, 
    Debug    )

    ExportDesc

    source
    pub(all) enum ExportDesc {
      Func(Int)
      Table(Int)
      Memory(Int)
      Global(Int)
      Tag(Int)
    } derive(Eq, 
    Debug    )

    What an export names, as an index into the matching space.

    FieldRef

    source
    pub(all) enum FieldRef {
      FTypes(Array[Int])
      FFeature(Bytes)
      FImport(Int)
      FFunc(Int)
      FStart(Int)
      FExport(Int)
      FTable(Int)
      FMemory(Int)
      FGlobal(Int)
      FTag(Int)
      FElem(Int)
      FData(Int)
    } derive(Eq, 
    Debug    )

    One field of a module, named by where its item landed.

    FuncType

    source

    A function type.

    FunctionCode

    source
    pub(all) struct FunctionCode {
      locals : Array[
    ValType    [Int]]
      body : Array[Instruction]
      spans : Array[Span]
      nested_spans : Array[Array[Span]]
      conditionals : Array[CondGroup]
      priority : Priority?
    } derive(Eq, 
    Debug    )

    Global

    source

    Import

    source
    pub(all) struct Import {
      mod_name : Bytes
      name : Bytes
      desc : ImportDesc
      group : ImportGroup?
    } derive(Eq, 
    Debug    )

    ImportDesc

    source
    pub(all) enum ImportDesc {
      Func(Int, Bool)
      Table(TableType)
      Memory(MemoryType)
      Global(
    MutType    [
    ValType    [Int]])
      Tag(Int)
    } derive(Eq, 
    Debug    )

    What an import brings in.

    ImportGroup

    source
    pub(all) enum ImportGroup {
      Heterogeneous(Array[(Bytes, ImportDesc)])
      Homogeneous(Array[Bytes])
    } derive(Eq, 
    Debug    )

    The two compact forms: per-item descriptors, or one shared descriptor and a list of names.

    InstrHints

    source
    pub(all) struct InstrHints {
      branch : Bool?
      freq : Int?
      targets : Array[(Int, Int)]?
    } derive(Eq, 
    Debug    )

    The compilation hints attached to a single instruction.

    These do not change what the instruction does; they are advice, carried out of line in the metadata.code.* sections, keyed by the instruction's byte offset within its function body. Which is why they hang off the instruction here: the offset is only knowable while encoding, and only the encoder knows it.

    InstrHints::is_empty

    source
    fn InstrHints::is_empty(self : InstrHints) -> Bool

    InstrHints::none

    source
    fn InstrHints::none() -> InstrHints

    No hints.

    Instruction

    source
    pub(all) enum Instruction {
      Unreachable
      Nop
      Block(BlockType, Array[Instruction])
      Loop(BlockType, Array[Instruction])
      If(BlockType, Array[Instruction], Array[Instruction])
      Br(Int)
      BrIf(Int)
      BrTable(Array[Int], Int)
      Return
      Call(Int)
      CallIndirect(Int, Int)
      CallRef(Int)
      ReturnCall(Int)
      ReturnCallIndirect(Int, Int)
      ReturnCallRef(Int)
      Throw(Int)
      ThrowRef
      TryTable(BlockType, Array[CatchHandler], Array[Instruction])
      LegacyTry(BlockType, Array[Instruction], Array[(Int, Array[Instruction])], Array[Instruction]?)
      Drop
      Select
      SelectTyped(Array[
    ValType    [Int]])
      LocalGet(Int)
      LocalSet(Int)
      LocalTee(Int)
      GlobalGet(Int)
      GlobalSet(Int)
      TableGet(Int)
      TableSet(Int)
      TableSize(Int)
      TableGrow(Int)
      TableFill(Int)
      TableCopy(Int, Int)
      TableInit(Int, Int)
      I32Load(Int, Int, Int64)
      I64Load(Int, Int, Int64)
      F32Load(Int, Int, Int64)
      F64Load(Int, Int, Int64)
      I32Load8S(Int, Int, Int64)
      I32Load8U(Int, Int, Int64)
      I32Load16S(Int, Int, Int64)
      I32Load16U(Int, Int, Int64)
      I64Load8S(Int, Int, Int64)
      I64Load8U(Int, Int, Int64)
      I64Load16S(Int, Int, Int64)
      I64Load16U(Int, Int, Int64)
      I64Load32S(Int, Int, Int64)
      I64Load32U(Int, Int, Int64)
      I32Store(Int, Int, Int64)
      I64Store(Int, Int, Int64)
      F32Store(Int, Int, Int64)
      F64Store(Int, Int, Int64)
      I32Store8(Int, Int, Int64)
      I32Store16(Int, Int, Int64)
      I64Store8(Int, Int, Int64)
      I64Store16(Int, Int, Int64)
      I64Store32(Int, Int, Int64)
      MemorySize(Int)
      MemoryGrow(Int)
      MemoryInit(Int, Int)
      DataDrop(Int)
      MemoryCopy(Int, Int)
      MemoryFill(Int)
      ElemDrop(Int)
      Atomic(Int, Int, Int, Int64)
      AtomicFence
      ContNew(Int)
      ContBind(Int, Int)
      Suspend(Int)
      Resume(Int, Array[OnClause])
      ResumeThrow(Int, Int, Array[OnClause])
      ResumeThrowRef(Int, Array[OnClause])
      Switch(Int, Int)
      Hinted(InstrHints, Instruction)
      Spelled(String, Instruction)
      FromString(Bytes, Instruction)
      FromChar(Bytes, Instruction)
      RefNull(
    HeapType    [Int])
      RefIsNull
      RefFunc(Int)
      RefAsNonNull
      RefEqInstr
      BrOnNull(Int)
      BrOnNonNull(Int)
      I32Const(Int)
      I64Const(Int64)
      F32Const(Float)
      F64Const(Double)
      I32Eqz
      I32Eq
      I32Ne
      I32LtS
      I32LtU
      I32GtS
      I32GtU
      I32LeS
      I32LeU
      I32GeS
      I32GeU
      I32Clz
      I32Ctz
      I32Popcnt
      I32Add
      I32Sub
      I32Mul
      I32DivS
      I32DivU
      I32RemS
      I32RemU
      I32And
      I32Or
      I32Xor
      I32Shl
      I32ShrS
      I32ShrU
      I32Rotl
      I32Rotr
      I32Extend8S
      I32Extend16S
      I64Eqz
      I64Eq
      I64Ne
      I64LtS
      I64LtU
      I64GtS
      I64GtU
      I64LeS
      I64LeU
      I64GeS
      I64GeU
      I64Clz
      I64Ctz
      I64Popcnt
      I64Add
      I64Sub
      I64Mul
      I64MulWideS
      I64MulWideU
      I64Add128
      I64Sub128
      I64DivS
      I64DivU
      I64RemS
      I64RemU
      I64And
      I64Or
      I64Xor
      I64Shl
      I64ShrS
      I64ShrU
      I64Rotl
      I64Rotr
      I64Extend8S
      I64Extend16S
      I64Extend32S
      F32Eq
      F32Ne
      F32Lt
      F32Gt
      F32Le
      F32Ge
      F32Abs
      F32Neg
      F32Ceil
      F32Floor
      F32Trunc
      F32Nearest
      F32Sqrt
      F32Add
      F32Sub
      F32Mul
      F32Div
      F32Min
      F32Max
      F32Copysign
      F64Eq
      F64Ne
      F64Lt
      F64Gt
      F64Le
      F64Ge
      F64Abs
      F64Neg
      F64Ceil
      F64Floor
      F64Trunc
      F64Nearest
      F64Sqrt
      F64Add
      F64Sub
      F64Mul
      F64Div
      F64Min
      F64Max
      F64Copysign
      I32WrapI64
      I32TruncF32S
      I32TruncF32U
      I32TruncF64S
      I32TruncF64U
      I64ExtendI32S
      I64ExtendI32U
      I64TruncF32S
      I64TruncF32U
      I64TruncF64S
      I64TruncF64U
      F32ConvertI32S
      F32ConvertI32U
      F32ConvertI64S
      F32ConvertI64U
      F32DemoteF64
      F64ConvertI32S
      F64ConvertI32U
      F64ConvertI64S
      F64ConvertI64U
      F64PromoteF32
      I32ReinterpretF32
      I64ReinterpretF64
      F32ReinterpretI32
      F64ReinterpretI64
      I32TruncSatF32S
      I32TruncSatF32U
      I32TruncSatF64S
      I32TruncSatF64U
      I64TruncSatF32S
      I64TruncSatF32U
      I64TruncSatF64S
      I64TruncSatF64U
      StructNewDesc(Int)
      StructNewDefaultDesc(Int)
      RefGetDesc(Int)
      RefCastDescEq(
    RefType    [Int])
      BrOnCastDescEq(Int, 
    RefType    [Int], 
    RefType    [Int])
      BrOnCastDescEqFail(Int, 
    RefType    [Int], 
    RefType    [Int])
      StructNew(Int)
      StructNewDefault(Int)
      StructGet(Int, Int)
      StructGetS(Int, Int)
      StructGetU(Int, Int)
      StructSet(Int, Int)
      ArrayNew(Int)
      ArrayNewDefault(Int)
      ArrayNewFixed(Int, Int)
      ArrayNewData(Int, Int)
      ArrayNewElem(Int, Int)
      ArrayGet(Int)
      ArrayGetS(Int)
      ArrayGetU(Int)
      ArraySet(Int)
      ArrayLen
      ArrayFill(Int)
      ArrayCopy(Int, Int)
      ArrayInitData(Int, Int)
      ArrayInitElem(Int, Int)
      RefTest(
    RefType    [Int])
      RefCast(
    RefType    [Int])
      BrOnCast(Int, 
    RefType    [Int], 
    RefType    [Int])
      BrOnCastFail(Int, 
    RefType    [Int], 
    RefType    [Int])
      RefI31
      I31GetS
      I31GetU
      AnyConvertExtern
      ExternConvertAny
      V128Const(Bytes)
      V128Load(Int, Int, Int64)
      V128Load8x8S(Int, Int, Int64)
      V128Load8x8U(Int, Int, Int64)
      V128Load16x4S(Int, Int, Int64)
      V128Load16x4U(Int, Int, Int64)
      V128Load32x2S(Int, Int, Int64)
      V128Load32x2U(Int, Int, Int64)
      V128Load8Splat(Int, Int, Int64)
      V128Load16Splat(Int, Int, Int64)
      V128Load32Splat(Int, Int, Int64)
      V128Load64Splat(Int, Int, Int64)
      V128Load32Zero(Int, Int, Int64)
      V128Load64Zero(Int, Int, Int64)
      V128Store(Int, Int, Int64)
      V128Load8Lane(Int, Int, Int64, Int)
      V128Load16Lane(Int, Int, Int64, Int)
      V128Load32Lane(Int, Int, Int64, Int)
      V128Load64Lane(Int, Int, Int64, Int)
      V128Store8Lane(Int, Int, Int64, Int)
      V128Store16Lane(Int, Int, Int64, Int)
      V128Store32Lane(Int, Int, Int64, Int)
      V128Store64Lane(Int, Int, Int64, Int)
      I8x16Shuffle(FixedArray[Int])
      I8x16Swizzle
      I8x16Splat
      I16x8Splat
      I32x4Splat
      I64x2Splat
      F32x4Splat
      F64x2Splat
      I8x16ExtractLaneS(Int)
      I8x16ExtractLaneU(Int)
      I16x8ExtractLaneS(Int)
      I16x8ExtractLaneU(Int)
      I32x4ExtractLane(Int)
      I64x2ExtractLane(Int)
      F32x4ExtractLane(Int)
      F64x2ExtractLane(Int)
      I8x16ReplaceLane(Int)
      I16x8ReplaceLane(Int)
      I32x4ReplaceLane(Int)
      I64x2ReplaceLane(Int)
      F32x4ReplaceLane(Int)
      F64x2ReplaceLane(Int)
      I8x16Eq
      I8x16Ne
      I8x16LtS
      I8x16LtU
      I8x16GtS
      I8x16GtU
      I8x16LeS
      I8x16LeU
      I8x16GeS
      I8x16GeU
      I16x8Eq
      I16x8Ne
      I16x8LtS
      I16x8LtU
      I16x8GtS
      I16x8GtU
      I16x8LeS
      I16x8LeU
      I16x8GeS
      I16x8GeU
      I32x4Eq
      I32x4Ne
      I32x4LtS
      I32x4LtU
      I32x4GtS
      I32x4GtU
      I32x4LeS
      I32x4LeU
      I32x4GeS
      I32x4GeU
      I64x2Eq
      I64x2Ne
      I64x2LtS
      I64x2GtS
      I64x2LeS
      I64x2GeS
      F32x4Eq
      F32x4Ne
      F32x4Lt
      F32x4Gt
      F32x4Le
      F32x4Ge
      F64x2Eq
      F64x2Ne
      F64x2Lt
      F64x2Gt
      F64x2Le
      F64x2Ge
      V128Not
      V128And
      V128AndNot
      V128Or
      V128Xor
      V128Bitselect
      V128AnyTrue
      I8x16Abs
      I8x16Neg
      I8x16Popcnt
      I8x16AllTrue
      I8x16Bitmask
      I8x16NarrowI16x8S
      I8x16NarrowI16x8U
      I8x16Shl
      I8x16ShrS
      I8x16ShrU
      I8x16Add
      I8x16AddSatS
      I8x16AddSatU
      I8x16Sub
      I8x16SubSatS
      I8x16SubSatU
      I8x16MinS
      I8x16MinU
      I8x16MaxS
      I8x16MaxU
      I8x16AvgrU
      I16x8ExtAddPairwiseI8x16S
      I16x8ExtAddPairwiseI8x16U
      I16x8Abs
      I16x8Neg
      I16x8Q15MulrSatS
      I16x8AllTrue
      I16x8Bitmask
      I16x8NarrowI32x4S
      I16x8NarrowI32x4U
      I16x8ExtendLowI8x16S
      I16x8ExtendHighI8x16S
      I16x8ExtendLowI8x16U
      I16x8ExtendHighI8x16U
      I16x8Shl
      I16x8ShrS
      I16x8ShrU
      I16x8Add
      I16x8AddSatS
      I16x8AddSatU
      I16x8Sub
      I16x8SubSatS
      I16x8SubSatU
      I16x8Mul
      I16x8MinS
      I16x8MinU
      I16x8MaxS
      I16x8MaxU
      I16x8AvgrU
      I16x8ExtMulLowI8x16S
      I16x8ExtMulHighI8x16S
      I16x8ExtMulLowI8x16U
      I16x8ExtMulHighI8x16U
      I32x4ExtAddPairwiseI16x8S
      I32x4ExtAddPairwiseI16x8U
      I32x4Abs
      I32x4Neg
      I32x4AllTrue
      I32x4Bitmask
      I32x4ExtendLowI16x8S
      I32x4ExtendHighI16x8S
      I32x4ExtendLowI16x8U
      I32x4ExtendHighI16x8U
      I32x4Shl
      I32x4ShrS
      I32x4ShrU
      I32x4Add
      I32x4Sub
      I32x4Mul
      I32x4MinS
      I32x4MinU
      I32x4MaxS
      I32x4MaxU
      I32x4DotI16x8S
      I32x4ExtMulLowI16x8S
      I32x4ExtMulHighI16x8S
      I32x4ExtMulLowI16x8U
      I32x4ExtMulHighI16x8U
      I64x2Abs
      I64x2Neg
      I64x2AllTrue
      I64x2Bitmask
      I64x2ExtendLowI32x4S
      I64x2ExtendHighI32x4S
      I64x2ExtendLowI32x4U
      I64x2ExtendHighI32x4U
      I64x2Shl
      I64x2ShrS
      I64x2ShrU
      I64x2Add
      I64x2Sub
      I64x2Mul
      I64x2ExtMulLowI32x4S
      I64x2ExtMulHighI32x4S
      I64x2ExtMulLowI32x4U
      I64x2ExtMulHighI32x4U
      F32x4Ceil
      F32x4Floor
      F32x4Trunc
      F32x4Nearest
      F32x4Abs
      F32x4Neg
      F32x4Sqrt
      F32x4Add
      F32x4Sub
      F32x4Mul
      F32x4Div
      F32x4Min
      F32x4Max
      F32x4Pmin
      F32x4Pmax
      F64x2Ceil
      F64x2Floor
      F64x2Trunc
      F64x2Nearest
      F64x2Abs
      F64x2Neg
      F64x2Sqrt
      F64x2Add
      F64x2Sub
      F64x2Mul
      F64x2Div
      F64x2Min
      F64x2Max
      F64x2Pmin
      F64x2Pmax
      I32x4TruncSatF32x4S
      I32x4TruncSatF32x4U
      F32x4ConvertI32x4S
      F32x4ConvertI32x4U
      I32x4TruncSatF64x2SZero
      I32x4TruncSatF64x2UZero
      F64x2ConvertLowI32x4S
      F64x2ConvertLowI32x4U
      F32x4DemoteF64x2Zero
      F64x2PromoteLowF32x4
      I8x16RelaxedSwizzle
      I32x4RelaxedTruncF32x4S
      I32x4RelaxedTruncF32x4U
      I32x4RelaxedTruncF64x2SZero
      I32x4RelaxedTruncF64x2UZero
      F32x4RelaxedMadd
      F32x4RelaxedNmadd
      F64x2RelaxedMadd
      F64x2RelaxedNmadd
      I8x16RelaxedLaneselect
      I16x8RelaxedLaneselect
      I32x4RelaxedLaneselect
      I64x2RelaxedLaneselect
      F32x4RelaxedMin
      F32x4RelaxedMax
      F64x2RelaxedMin
      F64x2RelaxedMax
      I16x8RelaxedQ15mulrS
      I16x8RelaxedDotI8x16I7x16S
      I32x4RelaxedDotI8x16I7x16AddS
    } derive(Eq, 
    Debug    )

    MemoryType

    source

    A memory's type.

    Module

    source
    pub(all) struct Module {
      types : Array[SubType]
      rec_groups : Array[RecGroup]
      imports : Array[Import]
      funcs : Array[Int]
      tables : Array[Table]
      memories : Array[MemoryType]
      globals : Array[Global]
      exports : Array[Export]
      start : Int?
      elems : Array[Element]
      codes : Array[FunctionCode]
      datas : Array[Data]
      tags : Array[TagType]
      text : TextView
      names : Names
      target_features : Array[(Int, Bytes)]
    } derive(
    Debug    )

    A whole module, in the form the encoder writes out.

    Module::empty

    source
    fn Module::empty() -> Module

    A module with nothing in it.

    Names

    source
    pub(all) struct Names {
      module_ : Bytes?
      functions : Map[Int, Bytes]
      locals : Map[Int, Map[Int, Bytes]]
      labels : Map[Int, Map[Int, Bytes]]
      types : Map[Int, Bytes]
      tables : Map[Int, Bytes]
      memories : Map[Int, Bytes]
      globals : Map[Int, Bytes]
      elem : Map[Int, Bytes]
      data : Map[Int, Bytes]
      fields : Map[Int, Map[Int, Bytes]]
      tags : Map[Int, Bytes]
    } derive(
    Debug    )

    The name custom section: what everything in the module is called.

    Upstream had a single func_names : Map[Int, String] on the module, which the encoder never read -- so every name was dropped. There are twelve name spaces, not one, and wasm_output.ml emits all of them.

    Maps rather than arrays, mirroring the reference's IntMap: the format wants each vector in ascending index order, and making that the encoder's job rather than the caller's is one fewer way to differ by a byte.

    Names::empty

    source
    fn Names::empty() -> Names

    No names at all, which is also what makes the section disappear.

    OnClause

    source
    pub(all) enum OnClause {
      OnLabel(Int, Int)
      OnSwitch(Int)
    } derive(Eq, 
    Debug    )

    One arm of a resume table: what happens when the continuation suspends with a given tag.

    ParamOwner

    source
    pub(all) enum ParamOwner {
      OwnerFunc(Int)
      OwnerTag(Int)
      OwnerType(Int)
    } derive(Eq, Hash, 
    Debug    )

    Whose parameters a name list belongs to. Imported functions and tags sit in different index spaces, so the index alone does not say.

    Priority

    source
    pub(all) struct Priority {
      compilation : Int
      optimization : Int?
    } derive(Eq, 
    Debug    )

    #[priority]: advice about the function as a whole rather than about one instruction, which is why it lives on the code entry and is recorded at offset 0 -- the position that means "the function itself".

    RecGroup

    source
    pub(all) struct RecGroup {
      start : Int
      len : Int
      explicit : Bool
    } derive(Eq, 
    Debug    )

    A run of defined types emitted as one rec (...).

    Upstream carried this as one group id per type and then never read it: the type section wrote every type flat, so a module whose types referred to each other came out as a set of unrelated definitions.

    explicit is not redundant with len == 1. A singleton rec is a different type from the same definition written bare -- recursive type identity is by group -- so the encoder cannot infer the prefix from the length, and what the source said has to be recorded.

    Span

    source
    pub(all) struct Span {
      start : Int
      head : Int
      end : Int
      loc : 
    Location
    } derive(Eq, 
    Debug    )

    A function body: its locals, then its instructions. One node's run in a body: where it starts, where its OWN emission begins (everything before that is its operands), where it ends, and where the source wrote it.

    StructType

    source

    A struct type.

    SubType

    source
    pub(all) struct SubType {
      final_ : Bool
      supertypes : Array[Int]
      descriptor : Int?
      describes : Int?
      composite : CompositeType
    } derive(Eq, 
    Debug    )

    A defined type, with its supertypes and whether it may be subtyped further.

    descriptor and describes are the custom-descriptors proposal's two clauses, and they come in pairs: descriptor names the type of this struct's runtime descriptor, describes names the struct this one is the descriptor OF. A type may carry either, both, or neither.

    SubType::func

    source

    A final function type, from its parameters and results.

    SubType::simple

    source
    fn SubType::simple(composite : CompositeType) -> SubType

    A subtype that is final and inherits from nothing -- the common case.

    Table

    source
    pub(all) struct Table {
      type_ : TableType
      init : Array[Instruction]?
      init_spans : Array[Span]
    } derive(Eq, 
    Debug    )

    A defined table, with the initialiser every element starts at.

    TableType

    source

    A table's type. The element type is a REFERENCE type, not a value type: nothing else can go in a table.

    TagType

    source
    pub(all) struct TagType {
      type_idx : Int
    } derive(Eq, 
    Debug    )

    An exception tag: an index into the type section, naming a function type whose parameters are the exception's payload and whose results are empty.

    TextView

    source
    pub(all) struct TextView {
      field_order : Array[FieldRef]
      field_locs : Array[
    Location    ]
      decl_param_names : Map[ParamOwner, Map[Int, Bytes]]
      decl_typeuse : Map[ParamOwner, TypeUse]
      standalone_exports : Map[Int, Bool]
      named_types : Map[Int, Bool]
      conditionals : Array[CondGroup]
    } derive(
    Debug    )

    The source facts the text form needs and the binary has no room for.

    Recorded as the lowering goes rather than recovered afterwards: there is nothing in the sections to recover them from, and a second derivation could disagree with the first with nothing to say which output is wrong.

    TextView::empty

    source
    fn TextView::empty() -> TextView

    An empty view, for a module nothing recorded one for.

    TypeUse

    source
    pub(all) struct TypeUse {
      named : Bool
      spelled : Bool
    } derive(Eq, 
    Debug    )

    Which of the two clauses a declaration wrote for its type. Both are optional and they are independent: fn f: ft(i32) wrote both.

    encode

    source
    fn encode(mod : Module) -> Bytes raise EncodeError

    Encode a module.

    Section order is the reference's, which is the format's and not the order of the section ids: tags (13) go between memories (5) and globals (6), the data count (12) before the code (10), and the custom sections last -- except the metadata.code.* ones, which the branch-hinting proposal requires between the function and code sections, and which are not emitted yet.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io