wat_syntax/ast/
ty.rs

1use super::{
2    AstChildren, AstNode,
3    module::{Index, TypeUse},
4    support::*,
5};
6use crate::{SyntaxKind, SyntaxNode, SyntaxToken};
7
8#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9pub struct AddrType {
10    syntax: SyntaxNode,
11}
12impl AddrType {
13    #[inline]
14    pub fn type_keyword(&self) -> Option<SyntaxToken> {
15        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
16    }
17}
18impl AstNode for AddrType {
19    #[inline]
20    fn can_cast(kind: SyntaxKind) -> bool
21    where
22        Self: Sized,
23    {
24        kind == SyntaxKind::ADDR_TYPE
25    }
26    #[inline]
27    fn cast(syntax: SyntaxNode) -> Option<Self>
28    where
29        Self: Sized,
30    {
31        if Self::can_cast(syntax.kind()) {
32            Some(AddrType { syntax })
33        } else {
34            None
35        }
36    }
37    #[inline]
38    fn syntax(&self) -> &SyntaxNode {
39        &self.syntax
40    }
41}
42
43#[derive(Debug, Clone, PartialEq, Eq, Hash)]
44pub struct ArrayType {
45    syntax: SyntaxNode,
46}
47impl ArrayType {
48    #[inline]
49    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
50        token(&self.syntax, SyntaxKind::L_PAREN)
51    }
52    #[inline]
53    pub fn keyword(&self) -> Option<SyntaxToken> {
54        token(&self.syntax, SyntaxKind::KEYWORD)
55    }
56    #[inline]
57    pub fn field_type(&self) -> Option<FieldType> {
58        child(&self.syntax)
59    }
60    #[inline]
61    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
62        token(&self.syntax, SyntaxKind::R_PAREN)
63    }
64}
65impl AstNode for ArrayType {
66    #[inline]
67    fn can_cast(kind: SyntaxKind) -> bool
68    where
69        Self: Sized,
70    {
71        kind == SyntaxKind::ARRAY_TYPE
72    }
73    #[inline]
74    fn cast(syntax: SyntaxNode) -> Option<Self>
75    where
76        Self: Sized,
77    {
78        if Self::can_cast(syntax.kind()) {
79            Some(ArrayType { syntax })
80        } else {
81            None
82        }
83    }
84    #[inline]
85    fn syntax(&self) -> &SyntaxNode {
86        &self.syntax
87    }
88}
89
90#[derive(Debug, Clone, PartialEq, Eq, Hash)]
91pub enum CompType {
92    Array(ArrayType),
93    Struct(StructType),
94    Func(FuncType),
95    Cont(ContType),
96}
97impl AstNode for CompType {
98    #[inline]
99    fn can_cast(kind: SyntaxKind) -> bool
100    where
101        Self: Sized,
102    {
103        matches!(
104            kind,
105            SyntaxKind::ARRAY_TYPE | SyntaxKind::STRUCT_TYPE | SyntaxKind::FUNC_TYPE | SyntaxKind::CONT_TYPE
106        )
107    }
108    #[inline]
109    fn cast(syntax: SyntaxNode) -> Option<Self>
110    where
111        Self: Sized,
112    {
113        match syntax.kind() {
114            SyntaxKind::ARRAY_TYPE => Some(CompType::Array(ArrayType { syntax })),
115            SyntaxKind::STRUCT_TYPE => Some(CompType::Struct(StructType { syntax })),
116            SyntaxKind::FUNC_TYPE => Some(CompType::Func(FuncType { syntax })),
117            SyntaxKind::CONT_TYPE => Some(CompType::Cont(ContType { syntax })),
118            _ => None,
119        }
120    }
121    #[inline]
122    fn syntax(&self) -> &SyntaxNode {
123        match self {
124            CompType::Array(it) => it.syntax(),
125            CompType::Struct(it) => it.syntax(),
126            CompType::Func(it) => it.syntax(),
127            CompType::Cont(it) => it.syntax(),
128        }
129    }
130}
131
132#[derive(Debug, Clone, PartialEq, Eq, Hash)]
133pub struct ContType {
134    syntax: SyntaxNode,
135}
136impl ContType {
137    #[inline]
138    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
139        token(&self.syntax, SyntaxKind::L_PAREN)
140    }
141    #[inline]
142    pub fn keyword(&self) -> Option<SyntaxToken> {
143        token(&self.syntax, SyntaxKind::KEYWORD)
144    }
145    #[inline]
146    pub fn index(&self) -> Option<Index> {
147        child(&self.syntax)
148    }
149    #[inline]
150    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
151        token(&self.syntax, SyntaxKind::R_PAREN)
152    }
153}
154impl AstNode for ContType {
155    #[inline]
156    fn can_cast(kind: SyntaxKind) -> bool
157    where
158        Self: Sized,
159    {
160        kind == SyntaxKind::CONT_TYPE
161    }
162    #[inline]
163    fn cast(syntax: SyntaxNode) -> Option<Self>
164    where
165        Self: Sized,
166    {
167        if Self::can_cast(syntax.kind()) {
168            Some(ContType { syntax })
169        } else {
170            None
171        }
172    }
173    #[inline]
174    fn syntax(&self) -> &SyntaxNode {
175        &self.syntax
176    }
177}
178
179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
180pub enum ExternType {
181    Func(ExternTypeFunc),
182    Global(ExternTypeGlobal),
183    Memory(ExternTypeMemory),
184    Table(ExternTypeTable),
185    Tag(ExternTypeTag),
186}
187impl AstNode for ExternType {
188    #[inline]
189    fn can_cast(kind: SyntaxKind) -> bool
190    where
191        Self: Sized,
192    {
193        matches!(
194            kind,
195            SyntaxKind::EXTERN_TYPE_FUNC
196                | SyntaxKind::EXTERN_TYPE_GLOBAL
197                | SyntaxKind::EXTERN_TYPE_MEMORY
198                | SyntaxKind::EXTERN_TYPE_TABLE
199                | SyntaxKind::EXTERN_TYPE_TAG
200        )
201    }
202    #[inline]
203    fn cast(syntax: SyntaxNode) -> Option<Self>
204    where
205        Self: Sized,
206    {
207        match syntax.kind() {
208            SyntaxKind::EXTERN_TYPE_FUNC => Some(ExternType::Func(ExternTypeFunc { syntax })),
209            SyntaxKind::EXTERN_TYPE_GLOBAL => Some(ExternType::Global(ExternTypeGlobal { syntax })),
210            SyntaxKind::EXTERN_TYPE_MEMORY => Some(ExternType::Memory(ExternTypeMemory { syntax })),
211            SyntaxKind::EXTERN_TYPE_TABLE => Some(ExternType::Table(ExternTypeTable { syntax })),
212            SyntaxKind::EXTERN_TYPE_TAG => Some(ExternType::Tag(ExternTypeTag { syntax })),
213            _ => None,
214        }
215    }
216    #[inline]
217    fn syntax(&self) -> &SyntaxNode {
218        match self {
219            ExternType::Func(it) => it.syntax(),
220            ExternType::Global(it) => it.syntax(),
221            ExternType::Memory(it) => it.syntax(),
222            ExternType::Table(it) => it.syntax(),
223            ExternType::Tag(it) => it.syntax(),
224        }
225    }
226}
227
228#[derive(Debug, Clone, PartialEq, Eq, Hash)]
229pub struct ExternTypeFunc {
230    syntax: SyntaxNode,
231}
232impl ExternTypeFunc {
233    #[inline]
234    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
235        token(&self.syntax, SyntaxKind::L_PAREN)
236    }
237    #[inline]
238    pub fn keyword(&self) -> Option<SyntaxToken> {
239        token(&self.syntax, SyntaxKind::KEYWORD)
240    }
241    #[inline]
242    pub fn ident_token(&self) -> Option<SyntaxToken> {
243        token(&self.syntax, SyntaxKind::IDENT)
244    }
245    #[inline]
246    pub fn type_use(&self) -> Option<TypeUse> {
247        child(&self.syntax)
248    }
249    #[inline]
250    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
251        token(&self.syntax, SyntaxKind::R_PAREN)
252    }
253}
254impl AstNode for ExternTypeFunc {
255    #[inline]
256    fn can_cast(kind: SyntaxKind) -> bool
257    where
258        Self: Sized,
259    {
260        kind == SyntaxKind::EXTERN_TYPE_FUNC
261    }
262    #[inline]
263    fn cast(syntax: SyntaxNode) -> Option<Self>
264    where
265        Self: Sized,
266    {
267        if Self::can_cast(syntax.kind()) {
268            Some(ExternTypeFunc { syntax })
269        } else {
270            None
271        }
272    }
273    #[inline]
274    fn syntax(&self) -> &SyntaxNode {
275        &self.syntax
276    }
277}
278
279#[derive(Debug, Clone, PartialEq, Eq, Hash)]
280pub struct ExternTypeGlobal {
281    syntax: SyntaxNode,
282}
283impl ExternTypeGlobal {
284    #[inline]
285    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
286        token(&self.syntax, SyntaxKind::L_PAREN)
287    }
288    #[inline]
289    pub fn keyword(&self) -> Option<SyntaxToken> {
290        token(&self.syntax, SyntaxKind::KEYWORD)
291    }
292    #[inline]
293    pub fn ident_token(&self) -> Option<SyntaxToken> {
294        token(&self.syntax, SyntaxKind::IDENT)
295    }
296    #[inline]
297    pub fn global_type(&self) -> Option<GlobalType> {
298        child(&self.syntax)
299    }
300    #[inline]
301    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
302        token(&self.syntax, SyntaxKind::R_PAREN)
303    }
304}
305impl AstNode for ExternTypeGlobal {
306    #[inline]
307    fn can_cast(kind: SyntaxKind) -> bool
308    where
309        Self: Sized,
310    {
311        kind == SyntaxKind::EXTERN_TYPE_GLOBAL
312    }
313    #[inline]
314    fn cast(syntax: SyntaxNode) -> Option<Self>
315    where
316        Self: Sized,
317    {
318        if Self::can_cast(syntax.kind()) {
319            Some(ExternTypeGlobal { syntax })
320        } else {
321            None
322        }
323    }
324    #[inline]
325    fn syntax(&self) -> &SyntaxNode {
326        &self.syntax
327    }
328}
329
330#[derive(Debug, Clone, PartialEq, Eq, Hash)]
331pub struct ExternTypeMemory {
332    syntax: SyntaxNode,
333}
334impl ExternTypeMemory {
335    #[inline]
336    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
337        token(&self.syntax, SyntaxKind::L_PAREN)
338    }
339    #[inline]
340    pub fn keyword(&self) -> Option<SyntaxToken> {
341        token(&self.syntax, SyntaxKind::KEYWORD)
342    }
343    #[inline]
344    pub fn ident_token(&self) -> Option<SyntaxToken> {
345        token(&self.syntax, SyntaxKind::IDENT)
346    }
347    #[inline]
348    pub fn mem_type(&self) -> Option<MemType> {
349        child(&self.syntax)
350    }
351    #[inline]
352    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
353        token(&self.syntax, SyntaxKind::R_PAREN)
354    }
355}
356impl AstNode for ExternTypeMemory {
357    #[inline]
358    fn can_cast(kind: SyntaxKind) -> bool
359    where
360        Self: Sized,
361    {
362        kind == SyntaxKind::EXTERN_TYPE_MEMORY
363    }
364    #[inline]
365    fn cast(syntax: SyntaxNode) -> Option<Self>
366    where
367        Self: Sized,
368    {
369        if Self::can_cast(syntax.kind()) {
370            Some(ExternTypeMemory { syntax })
371        } else {
372            None
373        }
374    }
375    #[inline]
376    fn syntax(&self) -> &SyntaxNode {
377        &self.syntax
378    }
379}
380
381#[derive(Debug, Clone, PartialEq, Eq, Hash)]
382pub struct ExternTypeTable {
383    syntax: SyntaxNode,
384}
385impl ExternTypeTable {
386    #[inline]
387    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
388        token(&self.syntax, SyntaxKind::L_PAREN)
389    }
390    #[inline]
391    pub fn keyword(&self) -> Option<SyntaxToken> {
392        token(&self.syntax, SyntaxKind::KEYWORD)
393    }
394    #[inline]
395    pub fn ident_token(&self) -> Option<SyntaxToken> {
396        token(&self.syntax, SyntaxKind::IDENT)
397    }
398    #[inline]
399    pub fn table_type(&self) -> Option<TableType> {
400        child(&self.syntax)
401    }
402    #[inline]
403    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
404        token(&self.syntax, SyntaxKind::R_PAREN)
405    }
406}
407impl AstNode for ExternTypeTable {
408    #[inline]
409    fn can_cast(kind: SyntaxKind) -> bool
410    where
411        Self: Sized,
412    {
413        kind == SyntaxKind::EXTERN_TYPE_TABLE
414    }
415    #[inline]
416    fn cast(syntax: SyntaxNode) -> Option<Self>
417    where
418        Self: Sized,
419    {
420        if Self::can_cast(syntax.kind()) {
421            Some(ExternTypeTable { syntax })
422        } else {
423            None
424        }
425    }
426    #[inline]
427    fn syntax(&self) -> &SyntaxNode {
428        &self.syntax
429    }
430}
431
432#[derive(Debug, Clone, PartialEq, Eq, Hash)]
433pub struct ExternTypeTag {
434    syntax: SyntaxNode,
435}
436impl ExternTypeTag {
437    #[inline]
438    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
439        token(&self.syntax, SyntaxKind::L_PAREN)
440    }
441    #[inline]
442    pub fn keyword(&self) -> Option<SyntaxToken> {
443        token(&self.syntax, SyntaxKind::KEYWORD)
444    }
445    #[inline]
446    pub fn ident_token(&self) -> Option<SyntaxToken> {
447        token(&self.syntax, SyntaxKind::IDENT)
448    }
449    #[inline]
450    pub fn type_use(&self) -> Option<TypeUse> {
451        child(&self.syntax)
452    }
453    #[inline]
454    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
455        token(&self.syntax, SyntaxKind::R_PAREN)
456    }
457}
458impl AstNode for ExternTypeTag {
459    #[inline]
460    fn can_cast(kind: SyntaxKind) -> bool
461    where
462        Self: Sized,
463    {
464        kind == SyntaxKind::EXTERN_TYPE_TAG
465    }
466    #[inline]
467    fn cast(syntax: SyntaxNode) -> Option<Self>
468    where
469        Self: Sized,
470    {
471        if Self::can_cast(syntax.kind()) {
472            Some(ExternTypeTag { syntax })
473        } else {
474            None
475        }
476    }
477    #[inline]
478    fn syntax(&self) -> &SyntaxNode {
479        &self.syntax
480    }
481}
482
483#[derive(Debug, Clone, PartialEq, Eq, Hash)]
484pub struct Field {
485    syntax: SyntaxNode,
486}
487impl Field {
488    #[inline]
489    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
490        token(&self.syntax, SyntaxKind::L_PAREN)
491    }
492    #[inline]
493    pub fn keyword(&self) -> Option<SyntaxToken> {
494        token(&self.syntax, SyntaxKind::KEYWORD)
495    }
496    #[inline]
497    pub fn ident_token(&self) -> Option<SyntaxToken> {
498        token(&self.syntax, SyntaxKind::IDENT)
499    }
500    #[inline]
501    pub fn field_types(&self) -> AstChildren<FieldType> {
502        children(&self.syntax)
503    }
504    #[inline]
505    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
506        token(&self.syntax, SyntaxKind::R_PAREN)
507    }
508}
509impl AstNode for Field {
510    #[inline]
511    fn can_cast(kind: SyntaxKind) -> bool
512    where
513        Self: Sized,
514    {
515        kind == SyntaxKind::FIELD
516    }
517    #[inline]
518    fn cast(syntax: SyntaxNode) -> Option<Self>
519    where
520        Self: Sized,
521    {
522        if Self::can_cast(syntax.kind()) {
523            Some(Field { syntax })
524        } else {
525            None
526        }
527    }
528    #[inline]
529    fn syntax(&self) -> &SyntaxNode {
530        &self.syntax
531    }
532}
533
534#[derive(Debug, Clone, PartialEq, Eq, Hash)]
535pub struct FieldType {
536    syntax: SyntaxNode,
537}
538impl FieldType {
539    #[inline]
540    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
541        token(&self.syntax, SyntaxKind::L_PAREN)
542    }
543    #[inline]
544    pub fn mut_keyword(&self) -> Option<SyntaxToken> {
545        token(&self.syntax, SyntaxKind::KEYWORD)
546    }
547    #[inline]
548    pub fn storage_type(&self) -> Option<StorageType> {
549        child(&self.syntax)
550    }
551    #[inline]
552    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
553        token(&self.syntax, SyntaxKind::R_PAREN)
554    }
555}
556impl AstNode for FieldType {
557    #[inline]
558    fn can_cast(kind: SyntaxKind) -> bool
559    where
560        Self: Sized,
561    {
562        kind == SyntaxKind::FIELD_TYPE
563    }
564    #[inline]
565    fn cast(syntax: SyntaxNode) -> Option<Self>
566    where
567        Self: Sized,
568    {
569        if Self::can_cast(syntax.kind()) {
570            Some(FieldType { syntax })
571        } else {
572            None
573        }
574    }
575    #[inline]
576    fn syntax(&self) -> &SyntaxNode {
577        &self.syntax
578    }
579}
580
581#[derive(Debug, Clone, PartialEq, Eq, Hash)]
582pub struct FuncType {
583    syntax: SyntaxNode,
584}
585impl FuncType {
586    #[inline]
587    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
588        token(&self.syntax, SyntaxKind::L_PAREN)
589    }
590    #[inline]
591    pub fn keyword(&self) -> Option<SyntaxToken> {
592        token(&self.syntax, SyntaxKind::KEYWORD)
593    }
594    #[inline]
595    pub fn params(&self) -> AstChildren<Param> {
596        children(&self.syntax)
597    }
598    #[inline]
599    pub fn results(&self) -> AstChildren<Result> {
600        children(&self.syntax)
601    }
602    #[inline]
603    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
604        token(&self.syntax, SyntaxKind::R_PAREN)
605    }
606}
607impl AstNode for FuncType {
608    #[inline]
609    fn can_cast(kind: SyntaxKind) -> bool
610    where
611        Self: Sized,
612    {
613        kind == SyntaxKind::FUNC_TYPE
614    }
615    #[inline]
616    fn cast(syntax: SyntaxNode) -> Option<Self>
617    where
618        Self: Sized,
619    {
620        if Self::can_cast(syntax.kind()) {
621            Some(FuncType { syntax })
622        } else {
623            None
624        }
625    }
626    #[inline]
627    fn syntax(&self) -> &SyntaxNode {
628        &self.syntax
629    }
630}
631
632#[derive(Debug, Clone, PartialEq, Eq, Hash)]
633pub struct GlobalType {
634    syntax: SyntaxNode,
635}
636impl GlobalType {
637    #[inline]
638    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
639        token(&self.syntax, SyntaxKind::L_PAREN)
640    }
641    #[inline]
642    pub fn mut_keyword(&self) -> Option<SyntaxToken> {
643        token(&self.syntax, SyntaxKind::KEYWORD)
644    }
645    #[inline]
646    pub fn val_type(&self) -> Option<ValType> {
647        child(&self.syntax)
648    }
649    #[inline]
650    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
651        token(&self.syntax, SyntaxKind::R_PAREN)
652    }
653}
654impl AstNode for GlobalType {
655    #[inline]
656    fn can_cast(kind: SyntaxKind) -> bool
657    where
658        Self: Sized,
659    {
660        kind == SyntaxKind::GLOBAL_TYPE
661    }
662    #[inline]
663    fn cast(syntax: SyntaxNode) -> Option<Self>
664    where
665        Self: Sized,
666    {
667        if Self::can_cast(syntax.kind()) {
668            Some(GlobalType { syntax })
669        } else {
670            None
671        }
672    }
673    #[inline]
674    fn syntax(&self) -> &SyntaxNode {
675        &self.syntax
676    }
677}
678
679#[derive(Debug, Clone, PartialEq, Eq, Hash)]
680pub struct HeapType {
681    syntax: SyntaxNode,
682}
683impl HeapType {
684    #[inline]
685    pub fn type_keyword(&self) -> Option<SyntaxToken> {
686        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
687    }
688    #[inline]
689    pub fn index(&self) -> Option<Index> {
690        child(&self.syntax)
691    }
692}
693impl AstNode for HeapType {
694    #[inline]
695    fn can_cast(kind: SyntaxKind) -> bool
696    where
697        Self: Sized,
698    {
699        kind == SyntaxKind::HEAP_TYPE
700    }
701    #[inline]
702    fn cast(syntax: SyntaxNode) -> Option<Self>
703    where
704        Self: Sized,
705    {
706        if Self::can_cast(syntax.kind()) {
707            Some(HeapType { syntax })
708        } else {
709            None
710        }
711    }
712    #[inline]
713    fn syntax(&self) -> &SyntaxNode {
714        &self.syntax
715    }
716}
717
718#[derive(Debug, Clone, PartialEq, Eq, Hash)]
719pub struct Limits {
720    syntax: SyntaxNode,
721}
722impl Limits {
723    #[inline]
724    pub fn min(&self) -> Option<SyntaxToken> {
725        token(&self.syntax, SyntaxKind::UNSIGNED_INT)
726    }
727    #[inline]
728    pub fn max(&self) -> Option<SyntaxToken> {
729        self.syntax.tokens_by_kind(SyntaxKind::UNSIGNED_INT).nth(1)
730    }
731}
732impl AstNode for Limits {
733    #[inline]
734    fn can_cast(kind: SyntaxKind) -> bool
735    where
736        Self: Sized,
737    {
738        kind == SyntaxKind::LIMITS
739    }
740    #[inline]
741    fn cast(syntax: SyntaxNode) -> Option<Self>
742    where
743        Self: Sized,
744    {
745        if Self::can_cast(syntax.kind()) {
746            Some(Limits { syntax })
747        } else {
748            None
749        }
750    }
751    #[inline]
752    fn syntax(&self) -> &SyntaxNode {
753        &self.syntax
754    }
755}
756
757#[derive(Debug, Clone, PartialEq, Eq, Hash)]
758pub struct MemPageSize {
759    syntax: SyntaxNode,
760}
761impl MemPageSize {
762    #[inline]
763    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
764        token(&self.syntax, SyntaxKind::L_PAREN)
765    }
766    #[inline]
767    pub fn keyword(&self) -> Option<SyntaxToken> {
768        token(&self.syntax, SyntaxKind::KEYWORD)
769    }
770    #[inline]
771    pub fn unsigned_int_token(&self) -> Option<SyntaxToken> {
772        token(&self.syntax, SyntaxKind::UNSIGNED_INT)
773    }
774    #[inline]
775    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
776        token(&self.syntax, SyntaxKind::R_PAREN)
777    }
778}
779impl AstNode for MemPageSize {
780    #[inline]
781    fn can_cast(kind: SyntaxKind) -> bool
782    where
783        Self: Sized,
784    {
785        kind == SyntaxKind::MEM_PAGE_SIZE
786    }
787    #[inline]
788    fn cast(syntax: SyntaxNode) -> Option<Self>
789    where
790        Self: Sized,
791    {
792        if Self::can_cast(syntax.kind()) {
793            Some(MemPageSize { syntax })
794        } else {
795            None
796        }
797    }
798    #[inline]
799    fn syntax(&self) -> &SyntaxNode {
800        &self.syntax
801    }
802}
803
804#[derive(Debug, Clone, PartialEq, Eq, Hash)]
805pub struct MemType {
806    syntax: SyntaxNode,
807}
808impl MemType {
809    #[inline]
810    pub fn addr_type(&self) -> Option<AddrType> {
811        child(&self.syntax)
812    }
813    #[inline]
814    pub fn limits(&self) -> Option<Limits> {
815        child(&self.syntax)
816    }
817    #[inline]
818    pub fn share_keyword(&self) -> Option<SyntaxToken> {
819        token(&self.syntax, SyntaxKind::KEYWORD)
820    }
821    #[inline]
822    pub fn mem_page_size(&self) -> Option<MemPageSize> {
823        child(&self.syntax)
824    }
825}
826impl AstNode for MemType {
827    #[inline]
828    fn can_cast(kind: SyntaxKind) -> bool
829    where
830        Self: Sized,
831    {
832        kind == SyntaxKind::MEM_TYPE
833    }
834    #[inline]
835    fn cast(syntax: SyntaxNode) -> Option<Self>
836    where
837        Self: Sized,
838    {
839        if Self::can_cast(syntax.kind()) {
840            Some(MemType { syntax })
841        } else {
842            None
843        }
844    }
845    #[inline]
846    fn syntax(&self) -> &SyntaxNode {
847        &self.syntax
848    }
849}
850
851#[derive(Debug, Clone, PartialEq, Eq, Hash)]
852pub struct NumType {
853    syntax: SyntaxNode,
854}
855impl NumType {
856    #[inline]
857    pub fn type_keyword(&self) -> Option<SyntaxToken> {
858        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
859    }
860}
861impl AstNode for NumType {
862    #[inline]
863    fn can_cast(kind: SyntaxKind) -> bool
864    where
865        Self: Sized,
866    {
867        kind == SyntaxKind::NUM_TYPE
868    }
869    #[inline]
870    fn cast(syntax: SyntaxNode) -> Option<Self>
871    where
872        Self: Sized,
873    {
874        if Self::can_cast(syntax.kind()) {
875            Some(NumType { syntax })
876        } else {
877            None
878        }
879    }
880    #[inline]
881    fn syntax(&self) -> &SyntaxNode {
882        &self.syntax
883    }
884}
885
886#[derive(Debug, Clone, PartialEq, Eq, Hash)]
887pub struct PackedType {
888    syntax: SyntaxNode,
889}
890impl PackedType {
891    #[inline]
892    pub fn type_keyword(&self) -> Option<SyntaxToken> {
893        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
894    }
895}
896impl AstNode for PackedType {
897    #[inline]
898    fn can_cast(kind: SyntaxKind) -> bool
899    where
900        Self: Sized,
901    {
902        kind == SyntaxKind::PACKED_TYPE
903    }
904    #[inline]
905    fn cast(syntax: SyntaxNode) -> Option<Self>
906    where
907        Self: Sized,
908    {
909        if Self::can_cast(syntax.kind()) {
910            Some(PackedType { syntax })
911        } else {
912            None
913        }
914    }
915    #[inline]
916    fn syntax(&self) -> &SyntaxNode {
917        &self.syntax
918    }
919}
920
921#[derive(Debug, Clone, PartialEq, Eq, Hash)]
922pub struct Param {
923    syntax: SyntaxNode,
924}
925impl Param {
926    #[inline]
927    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
928        token(&self.syntax, SyntaxKind::L_PAREN)
929    }
930    #[inline]
931    pub fn keyword(&self) -> Option<SyntaxToken> {
932        token(&self.syntax, SyntaxKind::KEYWORD)
933    }
934    #[inline]
935    pub fn ident_token(&self) -> Option<SyntaxToken> {
936        token(&self.syntax, SyntaxKind::IDENT)
937    }
938    #[inline]
939    pub fn val_types(&self) -> AstChildren<ValType> {
940        children(&self.syntax)
941    }
942    #[inline]
943    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
944        token(&self.syntax, SyntaxKind::R_PAREN)
945    }
946}
947impl AstNode for Param {
948    #[inline]
949    fn can_cast(kind: SyntaxKind) -> bool
950    where
951        Self: Sized,
952    {
953        kind == SyntaxKind::PARAM
954    }
955    #[inline]
956    fn cast(syntax: SyntaxNode) -> Option<Self>
957    where
958        Self: Sized,
959    {
960        if Self::can_cast(syntax.kind()) {
961            Some(Param { syntax })
962        } else {
963            None
964        }
965    }
966    #[inline]
967    fn syntax(&self) -> &SyntaxNode {
968        &self.syntax
969    }
970}
971
972#[derive(Debug, Clone, PartialEq, Eq, Hash)]
973pub struct RefType {
974    syntax: SyntaxNode,
975}
976impl RefType {
977    #[inline]
978    pub fn type_keyword(&self) -> Option<SyntaxToken> {
979        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
980    }
981    #[inline]
982    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
983        token(&self.syntax, SyntaxKind::L_PAREN)
984    }
985    #[inline]
986    pub fn keyword(&self) -> Option<SyntaxToken> {
987        token(&self.syntax, SyntaxKind::KEYWORD)
988    }
989    #[inline]
990    pub fn null_keyword(&self) -> Option<SyntaxToken> {
991        token(&self.syntax, SyntaxKind::MODIFIER_KEYWORD)
992    }
993    #[inline]
994    pub fn heap_type(&self) -> Option<HeapType> {
995        child(&self.syntax)
996    }
997    #[inline]
998    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
999        token(&self.syntax, SyntaxKind::R_PAREN)
1000    }
1001}
1002impl AstNode for RefType {
1003    #[inline]
1004    fn can_cast(kind: SyntaxKind) -> bool
1005    where
1006        Self: Sized,
1007    {
1008        kind == SyntaxKind::REF_TYPE
1009    }
1010    #[inline]
1011    fn cast(syntax: SyntaxNode) -> Option<Self>
1012    where
1013        Self: Sized,
1014    {
1015        if Self::can_cast(syntax.kind()) {
1016            Some(RefType { syntax })
1017        } else {
1018            None
1019        }
1020    }
1021    #[inline]
1022    fn syntax(&self) -> &SyntaxNode {
1023        &self.syntax
1024    }
1025}
1026
1027#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1028pub struct Result {
1029    syntax: SyntaxNode,
1030}
1031impl Result {
1032    #[inline]
1033    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1034        token(&self.syntax, SyntaxKind::L_PAREN)
1035    }
1036    #[inline]
1037    pub fn keyword(&self) -> Option<SyntaxToken> {
1038        token(&self.syntax, SyntaxKind::KEYWORD)
1039    }
1040    #[inline]
1041    pub fn val_types(&self) -> AstChildren<ValType> {
1042        children(&self.syntax)
1043    }
1044    #[inline]
1045    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1046        token(&self.syntax, SyntaxKind::R_PAREN)
1047    }
1048}
1049impl AstNode for Result {
1050    #[inline]
1051    fn can_cast(kind: SyntaxKind) -> bool
1052    where
1053        Self: Sized,
1054    {
1055        kind == SyntaxKind::RESULT
1056    }
1057    #[inline]
1058    fn cast(syntax: SyntaxNode) -> Option<Self>
1059    where
1060        Self: Sized,
1061    {
1062        if Self::can_cast(syntax.kind()) {
1063            Some(Result { syntax })
1064        } else {
1065            None
1066        }
1067    }
1068    #[inline]
1069    fn syntax(&self) -> &SyntaxNode {
1070        &self.syntax
1071    }
1072}
1073
1074#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1075pub enum StorageType {
1076    Val(ValType),
1077    Packed(PackedType),
1078}
1079impl AstNode for StorageType {
1080    #[inline]
1081    fn can_cast(kind: SyntaxKind) -> bool
1082    where
1083        Self: Sized,
1084    {
1085        matches!(
1086            kind,
1087            SyntaxKind::NUM_TYPE | SyntaxKind::VEC_TYPE | SyntaxKind::REF_TYPE | SyntaxKind::PACKED_TYPE
1088        )
1089    }
1090    #[inline]
1091    fn cast(syntax: SyntaxNode) -> Option<Self>
1092    where
1093        Self: Sized,
1094    {
1095        match syntax.kind() {
1096            SyntaxKind::NUM_TYPE => Some(StorageType::Val(ValType::Num(NumType { syntax }))),
1097            SyntaxKind::VEC_TYPE => Some(StorageType::Val(ValType::Vec(VecType { syntax }))),
1098            SyntaxKind::REF_TYPE => Some(StorageType::Val(ValType::Ref(RefType { syntax }))),
1099            SyntaxKind::PACKED_TYPE => Some(StorageType::Packed(PackedType { syntax })),
1100            _ => None,
1101        }
1102    }
1103    #[inline]
1104    fn syntax(&self) -> &SyntaxNode {
1105        match self {
1106            StorageType::Val(it) => it.syntax(),
1107            StorageType::Packed(it) => it.syntax(),
1108        }
1109    }
1110}
1111
1112#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1113pub struct StructType {
1114    syntax: SyntaxNode,
1115}
1116impl StructType {
1117    #[inline]
1118    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1119        token(&self.syntax, SyntaxKind::L_PAREN)
1120    }
1121    #[inline]
1122    pub fn keyword(&self) -> Option<SyntaxToken> {
1123        token(&self.syntax, SyntaxKind::KEYWORD)
1124    }
1125    #[inline]
1126    pub fn fields(&self) -> AstChildren<Field> {
1127        children(&self.syntax)
1128    }
1129    #[inline]
1130    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1131        token(&self.syntax, SyntaxKind::R_PAREN)
1132    }
1133}
1134impl AstNode for StructType {
1135    #[inline]
1136    fn can_cast(kind: SyntaxKind) -> bool
1137    where
1138        Self: Sized,
1139    {
1140        kind == SyntaxKind::STRUCT_TYPE
1141    }
1142    #[inline]
1143    fn cast(syntax: SyntaxNode) -> Option<Self>
1144    where
1145        Self: Sized,
1146    {
1147        if Self::can_cast(syntax.kind()) {
1148            Some(StructType { syntax })
1149        } else {
1150            None
1151        }
1152    }
1153    #[inline]
1154    fn syntax(&self) -> &SyntaxNode {
1155        &self.syntax
1156    }
1157}
1158
1159#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1160pub struct SubType {
1161    syntax: SyntaxNode,
1162}
1163impl SubType {
1164    #[inline]
1165    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1166        token(&self.syntax, SyntaxKind::L_PAREN)
1167    }
1168    #[inline]
1169    pub fn keyword(&self) -> Option<SyntaxToken> {
1170        token(&self.syntax, SyntaxKind::KEYWORD)
1171    }
1172    #[inline]
1173    pub fn final_keyword(&self) -> Option<SyntaxToken> {
1174        self.syntax.tokens_by_kind(SyntaxKind::MODIFIER_KEYWORD).next()
1175    }
1176    #[inline]
1177    pub fn indexes(&self) -> AstChildren<Index> {
1178        children(&self.syntax)
1179    }
1180    #[inline]
1181    pub fn comp_type(&self) -> Option<CompType> {
1182        child(&self.syntax)
1183    }
1184    #[inline]
1185    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1186        token(&self.syntax, SyntaxKind::R_PAREN)
1187    }
1188}
1189impl AstNode for SubType {
1190    #[inline]
1191    fn can_cast(kind: SyntaxKind) -> bool
1192    where
1193        Self: Sized,
1194    {
1195        kind == SyntaxKind::SUB_TYPE
1196    }
1197    #[inline]
1198    fn cast(syntax: SyntaxNode) -> Option<Self>
1199    where
1200        Self: Sized,
1201    {
1202        if Self::can_cast(syntax.kind()) {
1203            Some(SubType { syntax })
1204        } else {
1205            None
1206        }
1207    }
1208    #[inline]
1209    fn syntax(&self) -> &SyntaxNode {
1210        &self.syntax
1211    }
1212}
1213
1214#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1215pub struct TableType {
1216    syntax: SyntaxNode,
1217}
1218impl TableType {
1219    #[inline]
1220    pub fn addr_type(&self) -> Option<AddrType> {
1221        child(&self.syntax)
1222    }
1223    #[inline]
1224    pub fn limits(&self) -> Option<Limits> {
1225        child(&self.syntax)
1226    }
1227    #[inline]
1228    pub fn ref_type(&self) -> Option<RefType> {
1229        child(&self.syntax)
1230    }
1231}
1232impl AstNode for TableType {
1233    #[inline]
1234    fn can_cast(kind: SyntaxKind) -> bool
1235    where
1236        Self: Sized,
1237    {
1238        kind == SyntaxKind::TABLE_TYPE
1239    }
1240    #[inline]
1241    fn cast(syntax: SyntaxNode) -> Option<Self>
1242    where
1243        Self: Sized,
1244    {
1245        if Self::can_cast(syntax.kind()) {
1246            Some(TableType { syntax })
1247        } else {
1248            None
1249        }
1250    }
1251    #[inline]
1252    fn syntax(&self) -> &SyntaxNode {
1253        &self.syntax
1254    }
1255}
1256
1257#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1258pub enum ValType {
1259    Num(NumType),
1260    Vec(VecType),
1261    Ref(RefType),
1262}
1263impl AstNode for ValType {
1264    #[inline]
1265    fn can_cast(kind: SyntaxKind) -> bool
1266    where
1267        Self: Sized,
1268    {
1269        matches!(kind, SyntaxKind::NUM_TYPE | SyntaxKind::VEC_TYPE | SyntaxKind::REF_TYPE)
1270    }
1271    #[inline]
1272    fn cast(syntax: SyntaxNode) -> Option<Self>
1273    where
1274        Self: Sized,
1275    {
1276        match syntax.kind() {
1277            SyntaxKind::NUM_TYPE => Some(ValType::Num(NumType { syntax })),
1278            SyntaxKind::VEC_TYPE => Some(ValType::Vec(VecType { syntax })),
1279            SyntaxKind::REF_TYPE => Some(ValType::Ref(RefType { syntax })),
1280            _ => None,
1281        }
1282    }
1283    #[inline]
1284    fn syntax(&self) -> &SyntaxNode {
1285        match self {
1286            ValType::Num(it) => it.syntax(),
1287            ValType::Vec(it) => it.syntax(),
1288            ValType::Ref(it) => it.syntax(),
1289        }
1290    }
1291}
1292
1293#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1294pub struct VecType {
1295    syntax: SyntaxNode,
1296}
1297impl VecType {
1298    #[inline]
1299    pub fn type_keyword(&self) -> Option<SyntaxToken> {
1300        token(&self.syntax, SyntaxKind::TYPE_KEYWORD)
1301    }
1302}
1303impl AstNode for VecType {
1304    #[inline]
1305    fn can_cast(kind: SyntaxKind) -> bool
1306    where
1307        Self: Sized,
1308    {
1309        kind == SyntaxKind::VEC_TYPE
1310    }
1311    #[inline]
1312    fn cast(syntax: SyntaxNode) -> Option<Self>
1313    where
1314        Self: Sized,
1315    {
1316        if Self::can_cast(syntax.kind()) {
1317            Some(VecType { syntax })
1318        } else {
1319            None
1320        }
1321    }
1322    #[inline]
1323    fn syntax(&self) -> &SyntaxNode {
1324        &self.syntax
1325    }
1326}
wat_syntax/ast/ty.rs

wat_syntax/ast/
ty.rs
