waside 0.1.0

An AST for WebAssembly that supports decoding, encoding, and printing.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

/// Owned data for a br_table instruction.
/// wasmparser's BrTable<'a> contains a BinaryReader with a lifetime,
/// so we convert it to this owned representation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BrTableData {
    /// Branch target labels (excluding the default).
    pub targets: Vec<u32>,
    /// The default branch target label.
    pub default: u32,
}

// ---- Instruction enum generation ----
// We use a tt-muncher to process each operator one at a time,
// accumulating enum variants. Only BrTable needs special handling
// (its wasmparser type has a lifetime). All other types (MemArg,
// Ordering, TryTable, ResumeTable, etc.) are 'static and used directly.

macro_rules! define_instruction {
    ($($all:tt)*) => {
        define_instruction_inner!(@enum [] $($all)*);
    };
}

macro_rules! define_instruction_inner {
    // Terminal: emit the enum with all accumulated variants
    (@enum [$($variants:tt)*]) => {
        #[derive(Debug, Clone, PartialEq, Eq)]
        #[allow(missing_docs, non_camel_case_types)]
        pub enum Instruction {
            $($variants)*
        }
    };

    // Special case: BrTable (has lifetime that must be replaced)
    (@enum [$($v:tt)*] @$p:ident BrTable { $arg:ident : $t:ty } => $visit:ident $ann:tt $($rest:tt)*) => {
        define_instruction_inner!(@enum [$($v)* BrTable { $arg: BrTableData },] $($rest)*);
    };

    // Generic with fields (types pass through verbatim - they're all 'static)
    (@enum [$($v:tt)*] @$p:ident $op:ident { $($arg:ident : $argty:ty),* } => $visit:ident $ann:tt $($rest:tt)*) => {
        define_instruction_inner!(@enum [$($v)* $op { $($arg: $argty),* },] $($rest)*);
    };

    // No fields
    (@enum [$($v:tt)*] @$p:ident $op:ident => $visit:ident $ann:tt $($rest:tt)*) => {
        define_instruction_inner!(@enum [$($v)* $op,] $($rest)*);
    };
}

wasmparser::for_each_operator!(define_instruction);

// ---- Operator -> Instruction conversion ----

macro_rules! define_from_operator {
    ($( @$proposal:ident $op:ident $({ $($arg:ident : $argty:ty),* })? => $visit:ident ($($ann:tt)*) )*) => {
        #[allow(missing_docs)]
        impl Instruction {
            pub fn from_operator(op: &wasmparser::Operator<'_>) -> Self {
                match op {
                    $(
                        wasmparser::Operator::$op $({ $($arg),* })? => {
                            define_from_operator!(@build $op $($($arg),*)?)
                        }
                    )*
                    _ => unreachable!("unknown operator"),
                }
            }
        }
    };

    // BrTable: convert from wasmparser::BrTable<'a> to BrTableData
    (@build BrTable $targets:ident) => {
        Instruction::BrTable {
            targets: BrTableData {
                targets: $targets.targets().map(|t| t.unwrap()).collect(),
                default: $targets.default(),
            }
        }
    };
    // No fields
    (@build $op:ident) => {
        Instruction::$op
    };
    // Generic fields: clone all (works for both Copy and non-Copy types)
    (@build $op:ident $($arg:ident),+) => {
        Instruction::$op { $($arg: $arg.clone()),+ }
    };
}

wasmparser::for_each_operator!(define_from_operator);