🥮 mooncakes.io

    marianoguerra/wax/ast does not have a README file

    Attributes

    source
    type Attributes = Array[Attribute]

    An Array is a collection of values that supports random access and can grow in size.

    Body

    source

    A braced block of instructions together with the span of its braces.

    FieldType

    source

    A type paired with its mutability. Used for both globals and struct fields, which is why it is generic in the thing being made mutable.

    HeapType

    source

    A heap type: what a reference can point at.

    The No* cases are the bottom types of each hierarchy (nofunc is a subtype of every function type and has no values), and None_ is the bottom of the internal hierarchy. Type names a concrete defined type; Exact names one and forbids subtypes, which is the custom-descriptors proposal's &!t.

    LocModule

    source

    The module type the parser produces, before any type checking.

    Module

    source

    A module: a list of spanned fields.

    There is no wrapper node -- a Wax file IS its field list.

    RecType

    source

    A recursion group: types that may refer to each other.

    A single type t = ... is a one-member group, so there is no separate non-recursive form.

    RefType

    source

    A reference type: a heap type plus whether null is allowed.

    StorageType

    source

    What a struct field or array element stores.

    ValType

    source

    The Wax instantiations of the shared type family.

    Wax refers to types by NAME, so every one of these is at Idx = Ident. Naming them here keeps [Ident] out of the ~90 AST constructors, and means the binary form's instantiation (at Idx = Int, for the code generator) will sit beside these rather than replace them.

    Note Limits is deliberately absent: the Wax AST stores memory and table bounds inline as (UInt64, UInt64?)?, exactly as the reference does, and the Limits record in wasm_types belongs to the binary form.

    Attribute

    source

    An attribute, #[name] or #[name = value].

    BinOp

    source

    Binary operators.

    Signedness is part of the operator rather than inferred, because WebAssembly has genuinely different instructions for signed and unsigned division, remainder, shift and comparison. It is optional on the operators where floats also apply (/, <, >, <=, >=): None means the spelling did not commit, and the typer resolves it from the operand type.

    CastType

    source
    pub(all) enum CastType {
      Value(
    ValType    [Ident])
      Func(nullable~ : Bool, sign~ : FuncType)
      Signed(typ~ : NumType, signage~ : 
    Signage    , strict~ : Bool)
    } derive(Eq, 
    Debug    )

    What an as cast targets.

    Catch

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

    A try_table catch clause.

    The Ref variants deliver the exception reference itself alongside the payload, so a handler can rethrow.

    CompType

    source

    What a defined type actually is.

    DataElem

    source

    One element of a data segment's contents.

    Holds no instructions: every value is a literal. In a run the element type is stated once and the values are RAW literal strings, packed little-endian -- raw for the same round-tripping reason as numeric literals.

    DataMode

    source
    pub(all) enum DataMode[Info] {
      Passive
      Active(Ident, Instr[Info])
    } derive(Eq, 
    Debug    )

    Whether a data segment is copied in at instantiation or only on demand.

    ElemMode

    source
    pub(all) enum ElemMode[Info] {
      EPassive
      EActive(Ident, Instr[Info])
    } derive(Eq, 
    Debug    )

    FuncType

    source

    A function signature.

    Parameters may be anonymous (fn(i32)) or named (fn(x: i32)), hence the optional name; results never are.

    FuncType::to_json

    source
    fn FuncType::to_json(self : FuncType) -> Json

    Hint

    source
    pub(all) struct Hint[T] {
      value : T
      loc : 
    Location
    } derive(Eq, 
    Debug    )

    Advisory metadata.code.* metadata attached to an instruction.

    Written in Wax as an attribute prefixing the instruction (#[likely], #[freq = 16], #[targets(f: 0.73)]). These never affect behaviour: an engine may ignore them, and dropping one changes performance, never semantics.

    A hint carries the span of the attribute it was written as, so a diagnostic about a malformed hint blames the hint rather than the instruction it decorates.

    Hints

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

    Hints::is_empty

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

    Ident

    source
    #alias(Label)
    pub(all) struct Ident {
      name : String
      loc : 
    Location
    } derive(Eq, 
    Debug    )

    An identifier with its span.

    This is the Idx the Wax AST instantiates the type family at. The reference spells it (string, location) annotated; a named struct is the same shape with readable field names.

    Ident::to_json

    source
    fn Ident::to_json(self : Ident) -> Json

    ImportDecl

    source
    pub(all) struct ImportDecl {
      id : Ident
      kind : ImportKind
      attributes : Array[Attribute]
    } derive(Eq, 
    Debug    )

    A single imported entity.

    It is imported under id unless a name-only #[import = "name"] attribute overrides it. attributes also carries e.g. #[export] to re-export it.

    ImportKind

    source
    pub(all) enum ImportKind {
      Func(typ~ : Ident?, sign~ : FuncType?, exact~ : Bool)
      Global(mut_~ : Bool, typ~ : 
    ValType    [Ident])
      Tag(typ~ : Ident?, sign~ : FuncType?)
      Memory(address_type~ : 
    AddressType    , limits~ : (UInt64, UInt64?)?, page_size_log2~ : Int?, shared~ : Bool)
      Table(address_type~ : 
    AddressType    , reftype~ : 
    RefType    [Ident], limits~ : (UInt64, UInt64?)?)
    } derive(Eq, 
    Debug    )

    What an import "module" { ... } entry brings in.

    Imports have no body, so these carry only type-level information.

    Instr

    source
    pub(all) struct Instr[Info] {
      desc : InstrDesc[Info]
      info : Info
      hints : Hints
      expected : 
    ValType    [Ident]?
    } derive(Eq, 
    Debug    )

    An instruction node.

    hints and expected are fields rather than wrapper nodes so the pervasive matches on desc neither see them nor have to see through them.

    Instr::iter_instr

    source
    fn[I] Instr::iter_instr(self : Instr[I], f : (Instr[I]) -> Unit) -> Unit

    Apply f to this instruction and, recursively, to everything within it.

    Unlike map_info, f sees the whole node, so it can look at the desc.

    Instr::map_info

    source
    fn[A, B] Instr::map_info(self : Instr[A], f : (A) -> B) -> Instr[B]

    Re-annotate every node, keeping the shape.

    The type checker's move: the parser builds Instr[Location] and typing rebuilds the same tree carrying inferred types.

    Instr::sub_instrs

    source
    fn[I] Instr::sub_instrs(self : Instr[I]) -> Array[Instr[I]]

    The instructions immediately nested within this one, in no particular order.

    Instr::to_json

    source
    fn[Info] Instr::to_json(self : Instr[Info]) -> Json

    The instruction tree.

    Deliberately shallow in places -- a node's own kind and its children, not every field -- because these snapshots exist to catch a wrong SHAPE, and a full dump would churn on every unrelated change.

    InstrDesc

    source
    pub(all) enum InstrDesc[Info] {
      Block(label~ : Ident?, typ~ : FuncType, block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ])
      Loop(label~ : Ident?, typ~ : FuncType, block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ])
      While(label~ : Ident?, cond~ : Instr[Info], step~ : Instr[Info]?, block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ])
      If(label~ : Ident?, typ~ : FuncType, cond~ : Instr[Info], if_block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ], else_block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ]?)
      TryTable(label~ : Ident?, typ~ : FuncType, catches~ : Array[Catch], block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ])
      Try(label~ : Ident?, typ~ : FuncType, block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ], catches~ : Array[(Ident, 
    Annotated    [Array[Instr[Info]], 
    Location    ])], catch_all~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ]?)
      TryCatch(label~ : Ident?, typ~ : FuncType, block~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ], arms~ : Array[TryCatchArm[Info]])
      Unreachable
      Nop
      Hole
      Null
      Get(Ident)
      Path(Ident, Ident)
      Set(Ident, 
    Annotated    [BinOp, 
    Location    ]?, Instr[Info])
      Tee(Ident, Instr[Info])
      Call(Instr[Info], Array[Instr[Info]])
      TailCall(Instr[Info], Array[Instr[Info]])
      Labelled(Ident, Instr[Info])
      Char(Char)
      Str(Ident?, Bytes)
      Int(String)
      Float(String)
      Cast(Instr[Info], CastType)
      CastDesc(Instr[Info], Bool, Instr[Info])
      Test(Instr[Info], 
    RefType    [Ident])
      NonNull(Instr[Info])
      Struct(Ident?, Array[(Ident, Instr[Info]?)])
      StructDefault(Ident?)
      StructDesc(Instr[Info], Array[(Ident, Instr[Info]?)])
      StructDefaultDesc(Instr[Info])
      StructGet(Instr[Info], Ident)
      GetDescriptor(Instr[Info])
      StructSet(Instr[Info], Ident, Instr[Info])
      Array(Ident?, Instr[Info], Instr[Info])
      ArrayDefault(Ident?, Instr[Info])
      ArrayFixed(Ident?, Array[Instr[Info]])
      ArraySegment(Ident?, Ident, Instr[Info], Instr[Info])
      ArrayGet(Instr[Info], Instr[Info])
      ArraySet(Instr[Info], Instr[Info], Instr[Info])
      BinOpI(
    Annotated    [BinOp, 
    Location    ], Instr[Info], Instr[Info])
      UnOpI(
    Annotated    [UnOp, 
    Location    ], Instr[Info])
      Let(Array[(Ident?, 
    ValType    [Ident]?)], Instr[Info]?)
      Br(Ident, Instr[Info]?)
      BrIf(Ident, Instr[Info])
      BrTable(Array[Ident], Instr[Info])
      Dispatch(index~ : Instr[Info], cases~ : Array[Ident], default~ : Ident, arms~ : Array[(Ident, 
    Annotated    [Array[Instr[Info]], 
    Location    ])])
      Match(scrutinee~ : Instr[Info], arms~ : Array[(MatchPattern, 
    Annotated    [Array[Instr[Info]], 
    Location    ])], default~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ])
      BrOnNull(Ident, Instr[Info])
      BrOnNonNull(Ident, Instr[Info])
      BrOnCast(Ident, 
    RefType    [Ident], Instr[Info])
      BrOnCastFail(Ident, 
    RefType    [Ident], Instr[Info])
      BrOnCastDescEq(Ident, Bool, Instr[Info], Instr[Info])
      BrOnCastDescEqFail(Ident, Bool, Instr[Info], Instr[Info])
      Throw(Ident, Array[Instr[Info]])
      ThrowRef(Instr[Info])
      ContNew(Ident, Instr[Info])
      ContBind(Ident, Ident, Array[Instr[Info]])
      Suspend(Ident, Array[Instr[Info]])
      Resume(Ident, Array[OnClause], Array[Instr[Info]])
      ResumeThrow(Ident, Ident, Array[OnClause], Array[Instr[Info]])
      ResumeThrowRef(Ident, Array[OnClause], Array[Instr[Info]])
      Switch(Ident, Ident, Array[Instr[Info]])
      On(Instr[Info], Array[OnClause])
      Return(Instr[Info]?)
      Sequence(Array[Instr[Info]])
      Select(Instr[Info], Instr[Info], Instr[Info])
      IfAnnotation(cond~ : 
    Cond    , then_body~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ], else_body~ : 
    Annotated    [Array[Instr[Info]], 
    Location    ]?)
    } derive(Eq, 
    Debug    )

    A statement or expression. Wax is expression-oriented, so there is no separate statement type.

    InstrDesc::map_desc

    source
    fn[A, B] InstrDesc::map_desc(self : InstrDesc[A], instr~ : (Instr[A]) -> Instr[B], block~ : (Array[Instr[A]]) -> Array[Instr[B]]) -> InstrDesc[B]

    Rebuild a desc, rewriting every nested operand and every nested body.

    The one exhaustive match over InstrDesc. Changing the type breaks this and nothing else, which is the point.

    InstrDesc::to_json

    source
    fn[Info] InstrDesc::to_json(self : InstrDesc[Info]) -> Json

    MatchPattern

    source
    pub(all) enum MatchPattern {
      MatchCast(Ident?, 
    RefType    [Ident])
      MatchNull
    } derive(Eq, 
    Debug    )

    A match arm pattern: an optionally-bound reference-type test, or a null test.

    MemData

    source
    pub(all) struct MemData[Info] {
      data_name : Ident?
      offset : Instr[Info]
      init : Array[DataElem]
    } derive(Eq, 
    Debug    )

    A data segment attached to a memory definition.

    ModuleField

    source
    pub(all) enum ModuleField[Info] {
      Type(Array[
    Annotated    [(Ident, SubType), 
    Location    ]])
      Func(name~ : Ident, typ~ : Ident?, sign~ : FuncType?, body~ : (Ident?, Array[Instr[Info]]), attributes~ : Array[Attribute])
      Global(name~ : Ident, mut_~ : Bool, typ~ : 
    ValType    [Ident]?, def~ : Instr[Info], attributes~ : Array[Attribute])
      Tag(name~ : Ident, typ~ : Ident?, sign~ : FuncType?, attributes~ : Array[Attribute])
      Memory(name~ : Ident, address_type~ : 
    AddressType    , limits~ : (UInt64, UInt64?)?, page_size_log2~ : Int?, shared~ : Bool, data~ : Array[MemData[Info]], attributes~ : Array[Attribute])
      Data(name~ : Ident?, mode~ : DataMode[Info], init~ : Array[DataElem], attributes~ : Array[Attribute])
      Table(name~ : Ident, address_type~ : 
    AddressType    , reftype~ : 
    RefType    [Ident], limits~ : (UInt64, UInt64?)?, init~ : Instr[Info]?, attributes~ : Array[Attribute])
      Elem(name~ : Ident, reftype~ : 
    RefType    [Ident], mode~ : ElemMode[Info], init~ : Array[Instr[Info]], attributes~ : Array[Attribute])
      Import(module_~ : 
    Annotated    [Bytes, 
    Location    ], decl~ : 
    Annotated    [ImportDecl, 
    Location    ])
      ImportGroup(module_~ : 
    Annotated    [Bytes, 
    Location    ], decls~ : Array[
    Annotated    [ImportDecl, 
    Location    ]])
      ModuleAnnotation(Array[Attribute])
      Conditional(cond~ : 
    Cond    , then_fields~ : 
    Annotated    [Array[
    Annotated    [ModuleField[Info], 
    Location    ]], 
    Location    ], else_fields~ : 
    Annotated    [Array[
    Annotated    [ModuleField[Info], 
    Location    ]], 
    Location    ]?)
    } derive(Eq, 
    Debug    )

    A top-level definition.

    ModuleField::to_json

    source
    fn[Info] ModuleField::to_json(self : ModuleField[Info]) -> Json

    NumType

    source
    pub(all) enum NumType {
      I32
      I64
      F32
      F64
    } derive(Eq, 
    Debug    )

    The four numeric types, where a construct admits only those.

    NumType::to_str

    source
    fn NumType::to_str(self : NumType) -> String

    OnClause

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

    A stack-switching handler clause, e on [tag -> 'label].

    SubType

    source
    pub(all) struct SubType {
      typ : CompType
      supertype : Ident?
      final_ : Bool
      descriptor : Ident?
      describes : Ident?
    } derive(Eq, 
    Debug    )

    One member of a recursion group.

    descriptor/describes are the custom-descriptors proposal's pairing; both are present because the relation is navigable in each direction.

    TryCatchArm

    source

    One arm of a structured try ... catch.

    UnOp

    source
    pub(all) enum UnOp {
      Neg
      Pos
      Not
    } derive(Eq, 
    Debug    )

    Unary operators.

    build

    source

    Build an instruction with a span and no hints.

    format_signed_type

    source
    fn format_signed_type(typ : NumType, signage : 
    Signage    , strict : Bool) -> String

    Render a signed numeric cast type, e.g. i32_s or i64_u_strict.

    heaptype_json

    source

    import_name

    source

    The name an imported entity is bound to in wasm.

    The name-only #[import = "name"] override if there is one, else the Wax name.

    BYTES, where the reference has a string: a wasm import name is a byte string, and this port keeps a string literal as the bytes the lexer decoded rather than re-encoding at every use. The Wax name is encoded here, which is lossless -- an identifier is UTF-8 by construction.

    is_splice_field

    source

    lower_dispatch

    source
    fn[I] lower_dispatch(block_info : I, index~ : Instr[I], cases~ : Array[Ident], default~ : Ident, arms~ : Array[(Ident, 
    Annotated    [Array[Instr[I]], 
    Location    ])]) -> Array[Instr[I]]

    Lower a dispatch to a br_table inside nested case blocks.

    One void block per case, the br_table innermost, each case body just after its own block. Branching to case c exits c's block, runs c's body, and falls through into the enclosing cases -- so the arms are listed in fall-through order, which is the REVERSE of the block nesting. The last arm is therefore outermost and its body trails the whole structure, which is why this returns a list rather than one instruction.

    lower_match

    source

    Lower a match to the nested type-test ladder.

    The scrutinee is evaluated ONCE and threaded through a chain of br_on_cast (or br_on_null for a null arm) in the innermost block: each test, on success, branches out to its arm's block carrying the narrowed value; on failure it leaves the progressively narrowed value for the next test. The first arm is innermost, so arm i's body sits in arm i + 1's block and the last arm's body sits in the escape block. After every test fails the innermost block drops the value and branches to escape, past all the arm bodies, and the default follows the (void) escape block as trailing code.

    labels supplies n + 1 fresh labels: one per arm in order, then escape.

    lower_trycatch

    source
    fn[I] lower_trycatch(block_info : I, join~ : Ident, arm_labels~ : Array[Ident], typ~ : FuncType, block~ : 
    Annotated    [Array[Instr[I]], 
    Location    ], arms~ : Array[TryCatchArm[I]]) -> Instr[I]

    Lower a structured try/catch to try_table plus a block ladder.

    One block per arm (the first innermost) inside the join block, the try_table innermost with one catch clause per arm, and each arm body as trailing code just after its block -- so an arm's completion falls into the next arm and the last arm's falls out of the join as the try's value. The body's normal completion escapes past all arms with the one implicit branch to join, carrying the value.

    arm_labels supplies one fresh label per arm; join is the try's own label when it has one. Each arm block's result type is the arm's entry stack (arm_types, which the typer fills).

    lower_while

    source
    fn[I] lower_while(block_info : I, fresh_loop~ : Ident, label~ : Ident?, cond~ : Instr[I], step~ : Instr[I]?, block~ : Array[Instr[I]]) -> Array[Instr[I]]

    Lower a leading-test while C { B } to 'L: loop { if C { B; br 'L; } }.

    A continue-expression step has to run at the end of EVERY iteration, including one reached by continue (a branch to the loop label). When the loop is labelled -- so a continue can target it -- the body is wrapped in a block carrying the user's label, and the back-edge uses fresh_loop: br 'L then exits that block, runs the step, and takes the back-edge. An unlabelled stepped loop cannot be continued, so the step is simply appended to the body.

    module_to_json

    source

    The whole module.

    no_hints

    source
    let no_hints : Hints

    An instruction with no hints, which is what everything carries unless an attribute says otherwise.

    no_loc_instr

    source

    A synthesized instruction: no source span, no hints.

    splice_field

    source

    Build the .. splice sentinel at the given span.

    splice_field_name

    source
    let splice_field_name : String

    The field name marking a .. splice at the head of a struct definition, which inherits the supertype's fields.

    .. is not a valid identifier, so it can never collide with a real field. The typer replaces it with the supertype's fields and the printer renders it back as ..; its field TYPE is a placeholder and is never inspected.

    synthetic_loop_label

    source
    let synthetic_loop_label : String

    The label of the loop a label-less while lowers to.

    # is not a Wax identifier character, so this can never clash with a source label nor be the target of a user br. It only ever labels the lowering the type checker discards -- conversion to wasm picks a readable name instead, and that is what reaches emitted wat.

    valtype_json

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io