wat_syntax 0.10.1

WebAssembly Text Format syntaxes.
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[expect(non_camel_case_types)]
/// Syntax kind enum for nodes and tokens.
pub enum SyntaxKind {
    // SyntaxToken
    WHITESPACE = 0,
    LINE_COMMENT,
    BLOCK_COMMENT,
    L_PAREN,
    R_PAREN,
    KEYWORD,
    INSTR_NAME,
    IDENT,
    STRING,
    INT,
    UNSIGNED_INT,
    FLOAT,
    TYPE_KEYWORD,
    MODIFIER_KEYWORD,
    EQ,
    MEM_ARG_KEYWORD,
    SHAPE_DESCRIPTOR,
    ANNOT_START,
    ANNOT_ELEM,
    ANNOT_END,
    ERROR,

    // SyntaxNode
    MODULE_NAME,
    NAME,
    NUM_TYPE,
    VEC_TYPE,
    REF_TYPE,
    HEAP_TYPE,
    PACKED_TYPE,
    FIELD_TYPE,
    STRUCT_TYPE,
    ARRAY_TYPE,
    FUNC_TYPE,
    CONT_TYPE,
    PARAM,
    RESULT,
    FIELD,
    SUB_TYPE,
    TABLE_TYPE,
    MEM_TYPE,
    ADDR_TYPE,
    GLOBAL_TYPE,
    PLAIN_INSTR,
    BLOCK_BLOCK,
    BLOCK_LOOP,
    BLOCK_IF,
    BLOCK_IF_THEN,
    BLOCK_IF_ELSE,
    BLOCK_TRY_TABLE,
    CATCH,
    CATCH_ALL,
    MEM_ARG,
    ON_CLAUSE,
    IMMEDIATE,
    TYPE_USE,
    LIMITS,
    IMPORT,
    EXPORT,
    EXTERN_TYPE_FUNC,
    EXTERN_TYPE_TABLE,
    EXTERN_TYPE_MEMORY,
    EXTERN_TYPE_GLOBAL,
    EXTERN_TYPE_TAG,
    EXTERN_IDX_FUNC,
    EXTERN_IDX_TABLE,
    EXTERN_IDX_MEMORY,
    EXTERN_IDX_GLOBAL,
    EXTERN_IDX_TAG,
    INDEX,
    LOCAL,
    MEM_PAGE_SIZE,
    MEM_USE,
    OFFSET,
    ELEM,
    ELEM_LIST,
    ELEM_EXPR,
    TABLE_USE,
    DATA,
    MODULE,
    MODULE_FIELD_DATA,
    MODULE_FIELD_ELEM,
    MODULE_FIELD_EXPORT,
    MODULE_FIELD_FUNC,
    MODULE_FIELD_GLOBAL,
    MODULE_FIELD_IMPORT,
    MODULE_FIELD_MEMORY,
    MODULE_FIELD_START,
    MODULE_FIELD_TABLE,
    MODULE_FIELD_TAG,
    TYPE_DEF,
    REC_TYPE,
    ROOT,
}

impl SyntaxKind {
    #[inline]
    /// Checks if it is whitespace or comment or annotation.
    pub fn is_trivia(self) -> bool {
        matches!(
            self,
            SyntaxKind::WHITESPACE
                | SyntaxKind::LINE_COMMENT
                | SyntaxKind::BLOCK_COMMENT
                | SyntaxKind::ANNOT_START
                | SyntaxKind::ANNOT_ELEM
                | SyntaxKind::ANNOT_END
        )
    }

    #[inline]
    pub fn is_comment(self) -> bool {
        matches!(self, SyntaxKind::LINE_COMMENT | SyntaxKind::BLOCK_COMMENT)
    }

    #[inline]
    /// Checks if it is punctuation.
    pub fn is_punc(self) -> bool {
        matches!(self, SyntaxKind::L_PAREN | SyntaxKind::R_PAREN)
    }
}

/// Trait for matching syntax kinds, used in `*_by_kind` methods.
pub trait SyntaxKindMatch {
    fn matches(&self, kind: SyntaxKind) -> bool;
}
impl SyntaxKindMatch for SyntaxKind {
    #[inline]
    fn matches(&self, kind: SyntaxKind) -> bool {
        *self == kind
    }
}
impl<F> SyntaxKindMatch for F
where
    F: Fn(SyntaxKind) -> bool,
{
    #[inline]
    fn matches(&self, kind: SyntaxKind) -> bool {
        self(kind)
    }
}
impl<const N: usize> SyntaxKindMatch for [SyntaxKind; N] {
    #[inline]
    fn matches(&self, kind: SyntaxKind) -> bool {
        self.contains(&kind)
    }
}