ridl_syntax/ast/
generated.rs

1//! The typed AST node structs, generated from `family.ungram`.
2//!
3//! @generated by `cargo xtask codegen` — do not edit by hand. The
4//! xtask drift test regenerates this file into a buffer and fails
5//! when the committed text differs.
6
7use super::AstChildren;
8use super::AstNode;
9use super::Backing;
10use super::Definition;
11use super::Expr;
12use super::FieldType;
13use super::InterfaceMember;
14use super::ParamType;
15use super::StructMember;
16use super::support;
17use crate::syntax_kind::{SyntaxKind, SyntaxNode, SyntaxToken};
18/// A `SourceFile` node (`family.ungram` rule `SourceFile`).
19#[derive(Debug, Clone, PartialEq, Eq, Hash)]
20pub struct SourceFile {
21    syntax: SyntaxNode,
22}
23impl AstNode for SourceFile {
24    fn cast(syntax: SyntaxNode) -> Option<Self> {
25        (syntax.kind() == SyntaxKind::SourceFile).then_some(Self { syntax })
26    }
27    fn syntax(&self) -> &SyntaxNode {
28        &self.syntax
29    }
30}
31impl SourceFile {
32    pub fn package_decl(&self) -> Option<PackageDecl> {
33        support::child(&self.syntax)
34    }
35    pub fn imports(&self) -> AstChildren<Import> {
36        support::children(&self.syntax)
37    }
38    pub fn definitions(&self) -> AstChildren<Definition> {
39        support::children(&self.syntax)
40    }
41    pub fn interfaces(&self) -> AstChildren<InterfaceDef> {
42        support::children(&self.syntax)
43    }
44    pub fn services(&self) -> AstChildren<ServiceDef> {
45        support::children(&self.syntax)
46    }
47    pub fn systems(&self) -> AstChildren<SystemDef> {
48        support::children(&self.syntax)
49    }
50    pub fn components(&self) -> AstChildren<ComponentDef> {
51        support::children(&self.syntax)
52    }
53    pub fn distributions(&self) -> AstChildren<DistributionDef> {
54        support::children(&self.syntax)
55    }
56    pub fn deployments(&self) -> AstChildren<DeploymentDef> {
57        support::children(&self.syntax)
58    }
59}
60/// A `PackageDecl` node (`family.ungram` rule `PackageDecl`).
61#[derive(Debug, Clone, PartialEq, Eq, Hash)]
62pub struct PackageDecl {
63    syntax: SyntaxNode,
64}
65impl AstNode for PackageDecl {
66    fn cast(syntax: SyntaxNode) -> Option<Self> {
67        (syntax.kind() == SyntaxKind::PackageDecl).then_some(Self { syntax })
68    }
69    fn syntax(&self) -> &SyntaxNode {
70        &self.syntax
71    }
72}
73impl PackageDecl {
74    pub fn qualified_name(&self) -> Option<QualifiedName> {
75        support::child(&self.syntax)
76    }
77    pub fn package_token(&self) -> Option<SyntaxToken> {
78        support::token(&self.syntax, SyntaxKind::PackageKw)
79    }
80}
81/// A `Import` node (`family.ungram` rule `Import`).
82#[derive(Debug, Clone, PartialEq, Eq, Hash)]
83pub struct Import {
84    syntax: SyntaxNode,
85}
86impl AstNode for Import {
87    fn cast(syntax: SyntaxNode) -> Option<Self> {
88        (syntax.kind() == SyntaxKind::Import).then_some(Self { syntax })
89    }
90    fn syntax(&self) -> &SyntaxNode {
91        &self.syntax
92    }
93}
94impl Import {
95    pub fn qualified_name(&self) -> Option<QualifiedName> {
96        support::child(&self.syntax)
97    }
98    pub fn alias(&self) -> Option<Name> {
99        support::child(&self.syntax)
100    }
101    pub fn import_token(&self) -> Option<SyntaxToken> {
102        support::token(&self.syntax, SyntaxKind::ImportKw)
103    }
104    pub fn as_token(&self) -> Option<SyntaxToken> {
105        support::token(&self.syntax, SyntaxKind::AsKw)
106    }
107}
108/// A `InterfaceDef` node (`family.ungram` rule `InterfaceDef`).
109#[derive(Debug, Clone, PartialEq, Eq, Hash)]
110pub struct InterfaceDef {
111    syntax: SyntaxNode,
112}
113impl AstNode for InterfaceDef {
114    fn cast(syntax: SyntaxNode) -> Option<Self> {
115        (syntax.kind() == SyntaxKind::InterfaceDef).then_some(Self { syntax })
116    }
117    fn syntax(&self) -> &SyntaxNode {
118        &self.syntax
119    }
120}
121impl InterfaceDef {
122    pub fn name(&self) -> Option<Name> {
123        support::child(&self.syntax)
124    }
125    pub fn members(&self) -> AstChildren<InterfaceMember> {
126        support::children(&self.syntax)
127    }
128    pub fn internal_token(&self) -> Option<SyntaxToken> {
129        support::token(&self.syntax, SyntaxKind::InternalKw)
130    }
131    pub fn error_token(&self) -> Option<SyntaxToken> {
132        support::token(&self.syntax, SyntaxKind::ErrorKw)
133    }
134    pub fn interface_token(&self) -> Option<SyntaxToken> {
135        support::token(&self.syntax, SyntaxKind::InterfaceKw)
136    }
137    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
138        support::token(&self.syntax, SyntaxKind::LBrace)
139    }
140    pub fn comma_token(&self) -> Option<SyntaxToken> {
141        support::token(&self.syntax, SyntaxKind::Comma)
142    }
143    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
144        support::token(&self.syntax, SyntaxKind::RBrace)
145    }
146}
147/// A `ServiceDef` node (`family.ungram` rule `ServiceDef`).
148#[derive(Debug, Clone, PartialEq, Eq, Hash)]
149pub struct ServiceDef {
150    syntax: SyntaxNode,
151}
152impl AstNode for ServiceDef {
153    fn cast(syntax: SyntaxNode) -> Option<Self> {
154        (syntax.kind() == SyntaxKind::ServiceDef).then_some(Self { syntax })
155    }
156    fn syntax(&self) -> &SyntaxNode {
157        &self.syntax
158    }
159}
160impl ServiceDef {
161    pub fn name(&self) -> Option<DottedName> {
162        support::child(&self.syntax)
163    }
164    pub fn shapes(&self) -> AstChildren<PathType> {
165        support::children(&self.syntax)
166    }
167    pub fn inline_members(&self) -> AstChildren<InterfaceMember> {
168        support::children(&self.syntax)
169    }
170    pub fn service_token(&self) -> Option<SyntaxToken> {
171        support::token(&self.syntax, SyntaxKind::ServiceKw)
172    }
173    pub fn colon_token(&self) -> Option<SyntaxToken> {
174        support::token(&self.syntax, SyntaxKind::Colon)
175    }
176    pub fn comma_token(&self) -> Option<SyntaxToken> {
177        support::token(&self.syntax, SyntaxKind::Comma)
178    }
179    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
180        support::token(&self.syntax, SyntaxKind::LBrace)
181    }
182    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
183        support::token(&self.syntax, SyntaxKind::RBrace)
184    }
185}
186/// A `SystemDef` node (`family.ungram` rule `SystemDef`).
187#[derive(Debug, Clone, PartialEq, Eq, Hash)]
188pub struct SystemDef {
189    syntax: SyntaxNode,
190}
191impl AstNode for SystemDef {
192    fn cast(syntax: SyntaxNode) -> Option<Self> {
193        (syntax.kind() == SyntaxKind::SystemDef).then_some(Self { syntax })
194    }
195    fn syntax(&self) -> &SyntaxNode {
196        &self.syntax
197    }
198}
199impl SystemDef {
200    pub fn name(&self) -> Option<Name> {
201        support::child(&self.syntax)
202    }
203    pub fn attr_block(&self) -> Option<AttrBlock> {
204        support::child(&self.syntax)
205    }
206    pub fn lines(&self) -> AstChildren<MemberLine> {
207        support::children(&self.syntax)
208    }
209    pub fn system_token(&self) -> Option<SyntaxToken> {
210        support::token(&self.syntax, SyntaxKind::SystemKw)
211    }
212    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
213        support::token(&self.syntax, SyntaxKind::LBrace)
214    }
215    pub fn comma_token(&self) -> Option<SyntaxToken> {
216        support::token(&self.syntax, SyntaxKind::Comma)
217    }
218    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
219        support::token(&self.syntax, SyntaxKind::RBrace)
220    }
221}
222/// A `ComponentDef` node (`family.ungram` rule `ComponentDef`).
223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
224pub struct ComponentDef {
225    syntax: SyntaxNode,
226}
227impl AstNode for ComponentDef {
228    fn cast(syntax: SyntaxNode) -> Option<Self> {
229        (syntax.kind() == SyntaxKind::ComponentDef).then_some(Self { syntax })
230    }
231    fn syntax(&self) -> &SyntaxNode {
232        &self.syntax
233    }
234}
235impl ComponentDef {
236    pub fn name(&self) -> Option<Name> {
237        support::child(&self.syntax)
238    }
239    pub fn attr_block(&self) -> Option<AttrBlock> {
240        support::child(&self.syntax)
241    }
242    pub fn lines(&self) -> AstChildren<ComponentLine> {
243        support::children(&self.syntax)
244    }
245    pub fn component_token(&self) -> Option<SyntaxToken> {
246        support::token(&self.syntax, SyntaxKind::ComponentKw)
247    }
248    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
249        support::token(&self.syntax, SyntaxKind::LBrace)
250    }
251    pub fn comma_token(&self) -> Option<SyntaxToken> {
252        support::token(&self.syntax, SyntaxKind::Comma)
253    }
254    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
255        support::token(&self.syntax, SyntaxKind::RBrace)
256    }
257}
258/// A `DistributionDef` node (`family.ungram` rule `DistributionDef`).
259#[derive(Debug, Clone, PartialEq, Eq, Hash)]
260pub struct DistributionDef {
261    syntax: SyntaxNode,
262}
263impl AstNode for DistributionDef {
264    fn cast(syntax: SyntaxNode) -> Option<Self> {
265        (syntax.kind() == SyntaxKind::DistributionDef).then_some(Self { syntax })
266    }
267    fn syntax(&self) -> &SyntaxNode {
268        &self.syntax
269    }
270}
271impl DistributionDef {
272    pub fn name(&self) -> Option<Name> {
273        support::child(&self.syntax)
274    }
275    pub fn attr_block(&self) -> Option<AttrBlock> {
276        support::child(&self.syntax)
277    }
278    pub fn lines(&self) -> AstChildren<MemberLine> {
279        support::children(&self.syntax)
280    }
281    pub fn distribution_token(&self) -> Option<SyntaxToken> {
282        support::token(&self.syntax, SyntaxKind::DistributionKw)
283    }
284    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
285        support::token(&self.syntax, SyntaxKind::LBrace)
286    }
287    pub fn comma_token(&self) -> Option<SyntaxToken> {
288        support::token(&self.syntax, SyntaxKind::Comma)
289    }
290    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
291        support::token(&self.syntax, SyntaxKind::RBrace)
292    }
293}
294/// A `DeploymentDef` node (`family.ungram` rule `DeploymentDef`).
295#[derive(Debug, Clone, PartialEq, Eq, Hash)]
296pub struct DeploymentDef {
297    syntax: SyntaxNode,
298}
299impl AstNode for DeploymentDef {
300    fn cast(syntax: SyntaxNode) -> Option<Self> {
301        (syntax.kind() == SyntaxKind::DeploymentDef).then_some(Self { syntax })
302    }
303    fn syntax(&self) -> &SyntaxNode {
304        &self.syntax
305    }
306}
307impl DeploymentDef {
308    pub fn name(&self) -> Option<Name> {
309        support::child(&self.syntax)
310    }
311    pub fn system(&self) -> Option<Reference> {
312        support::child(&self.syntax)
313    }
314    pub fn attr_block(&self) -> Option<AttrBlock> {
315        support::child(&self.syntax)
316    }
317    pub fn machines(&self) -> AstChildren<MachineDef> {
318        support::children(&self.syntax)
319    }
320    pub fn deployment_token(&self) -> Option<SyntaxToken> {
321        support::token(&self.syntax, SyntaxKind::DeploymentKw)
322    }
323    pub fn for_token(&self) -> Option<SyntaxToken> {
324        support::token(&self.syntax, SyntaxKind::ForKw)
325    }
326    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
327        support::token(&self.syntax, SyntaxKind::LBrace)
328    }
329    pub fn comma_token(&self) -> Option<SyntaxToken> {
330        support::token(&self.syntax, SyntaxKind::Comma)
331    }
332    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
333        support::token(&self.syntax, SyntaxKind::RBrace)
334    }
335}
336/// A `QualifiedName` node (`family.ungram` rule `QualifiedName`).
337#[derive(Debug, Clone, PartialEq, Eq, Hash)]
338pub struct QualifiedName {
339    syntax: SyntaxNode,
340}
341impl AstNode for QualifiedName {
342    fn cast(syntax: SyntaxNode) -> Option<Self> {
343        (syntax.kind() == SyntaxKind::QualifiedName).then_some(Self { syntax })
344    }
345    fn syntax(&self) -> &SyntaxNode {
346        &self.syntax
347    }
348}
349impl QualifiedName {
350    pub fn ident_token(&self) -> Option<SyntaxToken> {
351        support::token(&self.syntax, SyntaxKind::Ident)
352    }
353    pub fn boolean_token(&self) -> Option<SyntaxToken> {
354        support::token(&self.syntax, SyntaxKind::BooleanKw)
355    }
356    pub fn integer_token(&self) -> Option<SyntaxToken> {
357        support::token(&self.syntax, SyntaxKind::IntegerKw)
358    }
359    pub fn float_token(&self) -> Option<SyntaxToken> {
360        support::token(&self.syntax, SyntaxKind::FloatKw)
361    }
362    pub fn string_token(&self) -> Option<SyntaxToken> {
363        support::token(&self.syntax, SyntaxKind::StringKw)
364    }
365    pub fn bytes_token(&self) -> Option<SyntaxToken> {
366        support::token(&self.syntax, SyntaxKind::BytesKw)
367    }
368    pub fn dot_token(&self) -> Option<SyntaxToken> {
369        support::token(&self.syntax, SyntaxKind::Dot)
370    }
371}
372/// A `Name` node (`family.ungram` rule `Name`).
373#[derive(Debug, Clone, PartialEq, Eq, Hash)]
374pub struct Name {
375    syntax: SyntaxNode,
376}
377impl AstNode for Name {
378    fn cast(syntax: SyntaxNode) -> Option<Self> {
379        (syntax.kind() == SyntaxKind::Name).then_some(Self { syntax })
380    }
381    fn syntax(&self) -> &SyntaxNode {
382        &self.syntax
383    }
384}
385impl Name {
386    pub fn ident_token(&self) -> Option<SyntaxToken> {
387        support::token(&self.syntax, SyntaxKind::Ident)
388    }
389}
390/// A `TypeDef` node (`family.ungram` rule `TypeDef`).
391#[derive(Debug, Clone, PartialEq, Eq, Hash)]
392pub struct TypeDef {
393    syntax: SyntaxNode,
394}
395impl AstNode for TypeDef {
396    fn cast(syntax: SyntaxNode) -> Option<Self> {
397        (syntax.kind() == SyntaxKind::TypeDef).then_some(Self { syntax })
398    }
399    fn syntax(&self) -> &SyntaxNode {
400        &self.syntax
401    }
402}
403impl TypeDef {
404    pub fn name(&self) -> Option<Name> {
405        support::child(&self.syntax)
406    }
407    pub fn backing(&self) -> Option<Backing> {
408        support::child(&self.syntax)
409    }
410    pub fn constraint(&self) -> Option<Constraint> {
411        support::child(&self.syntax)
412    }
413    pub fn init_value(&self) -> Option<InitValue> {
414        support::child(&self.syntax)
415    }
416    pub fn internal_token(&self) -> Option<SyntaxToken> {
417        support::token(&self.syntax, SyntaxKind::InternalKw)
418    }
419    pub fn error_token(&self) -> Option<SyntaxToken> {
420        support::token(&self.syntax, SyntaxKind::ErrorKw)
421    }
422    pub fn type_token(&self) -> Option<SyntaxToken> {
423        support::token(&self.syntax, SyntaxKind::TypeKw)
424    }
425    pub fn colon_token(&self) -> Option<SyntaxToken> {
426        support::token(&self.syntax, SyntaxKind::Colon)
427    }
428}
429/// A `ConstDef` node (`family.ungram` rule `ConstDef`).
430#[derive(Debug, Clone, PartialEq, Eq, Hash)]
431pub struct ConstDef {
432    syntax: SyntaxNode,
433}
434impl AstNode for ConstDef {
435    fn cast(syntax: SyntaxNode) -> Option<Self> {
436        (syntax.kind() == SyntaxKind::ConstDef).then_some(Self { syntax })
437    }
438    fn syntax(&self) -> &SyntaxNode {
439        &self.syntax
440    }
441}
442impl ConstDef {
443    pub fn name(&self) -> Option<Name> {
444        support::child(&self.syntax)
445    }
446    pub fn type_ref(&self) -> Option<PathType> {
447        support::child(&self.syntax)
448    }
449    pub fn value(&self) -> Option<Literal> {
450        support::child(&self.syntax)
451    }
452    pub fn internal_token(&self) -> Option<SyntaxToken> {
453        support::token(&self.syntax, SyntaxKind::InternalKw)
454    }
455    pub fn error_token(&self) -> Option<SyntaxToken> {
456        support::token(&self.syntax, SyntaxKind::ErrorKw)
457    }
458    pub fn const_token(&self) -> Option<SyntaxToken> {
459        support::token(&self.syntax, SyntaxKind::ConstKw)
460    }
461    pub fn colon_token(&self) -> Option<SyntaxToken> {
462        support::token(&self.syntax, SyntaxKind::Colon)
463    }
464    pub fn eq_token(&self) -> Option<SyntaxToken> {
465        support::token(&self.syntax, SyntaxKind::Eq)
466    }
467}
468/// A `StructDef` node (`family.ungram` rule `StructDef`).
469#[derive(Debug, Clone, PartialEq, Eq, Hash)]
470pub struct StructDef {
471    syntax: SyntaxNode,
472}
473impl AstNode for StructDef {
474    fn cast(syntax: SyntaxNode) -> Option<Self> {
475        (syntax.kind() == SyntaxKind::StructDef).then_some(Self { syntax })
476    }
477    fn syntax(&self) -> &SyntaxNode {
478        &self.syntax
479    }
480}
481impl StructDef {
482    pub fn name(&self) -> Option<Name> {
483        support::child(&self.syntax)
484    }
485    pub fn members(&self) -> AstChildren<StructMember> {
486        support::children(&self.syntax)
487    }
488    pub fn internal_token(&self) -> Option<SyntaxToken> {
489        support::token(&self.syntax, SyntaxKind::InternalKw)
490    }
491    pub fn error_token(&self) -> Option<SyntaxToken> {
492        support::token(&self.syntax, SyntaxKind::ErrorKw)
493    }
494    pub fn struct_token(&self) -> Option<SyntaxToken> {
495        support::token(&self.syntax, SyntaxKind::StructKw)
496    }
497    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
498        support::token(&self.syntax, SyntaxKind::LBrace)
499    }
500    pub fn comma_token(&self) -> Option<SyntaxToken> {
501        support::token(&self.syntax, SyntaxKind::Comma)
502    }
503    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
504        support::token(&self.syntax, SyntaxKind::RBrace)
505    }
506}
507/// A `EnumDef` node (`family.ungram` rule `EnumDef`).
508#[derive(Debug, Clone, PartialEq, Eq, Hash)]
509pub struct EnumDef {
510    syntax: SyntaxNode,
511}
512impl AstNode for EnumDef {
513    fn cast(syntax: SyntaxNode) -> Option<Self> {
514        (syntax.kind() == SyntaxKind::EnumDef).then_some(Self { syntax })
515    }
516    fn syntax(&self) -> &SyntaxNode {
517        &self.syntax
518    }
519}
520impl EnumDef {
521    pub fn name(&self) -> Option<Name> {
522        support::child(&self.syntax)
523    }
524    pub fn values(&self) -> AstChildren<EnumValue> {
525        support::children(&self.syntax)
526    }
527    pub fn reserved(&self) -> AstChildren<ReservedEntry> {
528        support::children(&self.syntax)
529    }
530    pub fn internal_token(&self) -> Option<SyntaxToken> {
531        support::token(&self.syntax, SyntaxKind::InternalKw)
532    }
533    pub fn error_token(&self) -> Option<SyntaxToken> {
534        support::token(&self.syntax, SyntaxKind::ErrorKw)
535    }
536    pub fn open_token(&self) -> Option<SyntaxToken> {
537        support::token(&self.syntax, SyntaxKind::OpenKw)
538    }
539    pub fn enum_token(&self) -> Option<SyntaxToken> {
540        support::token(&self.syntax, SyntaxKind::EnumKw)
541    }
542    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
543        support::token(&self.syntax, SyntaxKind::LBrace)
544    }
545    pub fn comma_token(&self) -> Option<SyntaxToken> {
546        support::token(&self.syntax, SyntaxKind::Comma)
547    }
548    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
549        support::token(&self.syntax, SyntaxKind::RBrace)
550    }
551}
552/// A `EnumSetDef` node (`family.ungram` rule `EnumSetDef`).
553#[derive(Debug, Clone, PartialEq, Eq, Hash)]
554pub struct EnumSetDef {
555    syntax: SyntaxNode,
556}
557impl AstNode for EnumSetDef {
558    fn cast(syntax: SyntaxNode) -> Option<Self> {
559        (syntax.kind() == SyntaxKind::EnumSetDef).then_some(Self { syntax })
560    }
561    fn syntax(&self) -> &SyntaxNode {
562        &self.syntax
563    }
564}
565impl EnumSetDef {
566    pub fn name(&self) -> Option<Name> {
567        support::child(&self.syntax)
568    }
569    pub fn bits(&self) -> AstChildren<EnumSetBit> {
570        support::children(&self.syntax)
571    }
572    pub fn backing_ref(&self) -> Option<PathType> {
573        support::child(&self.syntax)
574    }
575    pub fn internal_token(&self) -> Option<SyntaxToken> {
576        support::token(&self.syntax, SyntaxKind::InternalKw)
577    }
578    pub fn error_token(&self) -> Option<SyntaxToken> {
579        support::token(&self.syntax, SyntaxKind::ErrorKw)
580    }
581    pub fn open_token(&self) -> Option<SyntaxToken> {
582        support::token(&self.syntax, SyntaxKind::OpenKw)
583    }
584    pub fn enumset_token(&self) -> Option<SyntaxToken> {
585        support::token(&self.syntax, SyntaxKind::EnumsetKw)
586    }
587    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
588        support::token(&self.syntax, SyntaxKind::LBrace)
589    }
590    pub fn comma_token(&self) -> Option<SyntaxToken> {
591        support::token(&self.syntax, SyntaxKind::Comma)
592    }
593    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
594        support::token(&self.syntax, SyntaxKind::RBrace)
595    }
596    pub fn colon_token(&self) -> Option<SyntaxToken> {
597        support::token(&self.syntax, SyntaxKind::Colon)
598    }
599}
600/// A `UnionDef` node (`family.ungram` rule `UnionDef`).
601#[derive(Debug, Clone, PartialEq, Eq, Hash)]
602pub struct UnionDef {
603    syntax: SyntaxNode,
604}
605impl AstNode for UnionDef {
606    fn cast(syntax: SyntaxNode) -> Option<Self> {
607        (syntax.kind() == SyntaxKind::UnionDef).then_some(Self { syntax })
608    }
609    fn syntax(&self) -> &SyntaxNode {
610        &self.syntax
611    }
612}
613impl UnionDef {
614    pub fn name(&self) -> Option<Name> {
615        support::child(&self.syntax)
616    }
617    pub fn arms(&self) -> AstChildren<UnionArm> {
618        support::children(&self.syntax)
619    }
620    pub fn reserved(&self) -> AstChildren<ReservedEntry> {
621        support::children(&self.syntax)
622    }
623    pub fn internal_token(&self) -> Option<SyntaxToken> {
624        support::token(&self.syntax, SyntaxKind::InternalKw)
625    }
626    pub fn error_token(&self) -> Option<SyntaxToken> {
627        support::token(&self.syntax, SyntaxKind::ErrorKw)
628    }
629    pub fn union_token(&self) -> Option<SyntaxToken> {
630        support::token(&self.syntax, SyntaxKind::UnionKw)
631    }
632    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
633        support::token(&self.syntax, SyntaxKind::LBrace)
634    }
635    pub fn comma_token(&self) -> Option<SyntaxToken> {
636        support::token(&self.syntax, SyntaxKind::Comma)
637    }
638    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
639        support::token(&self.syntax, SyntaxKind::RBrace)
640    }
641}
642/// A `Constraint` node (`family.ungram` rule `Constraint`).
643#[derive(Debug, Clone, PartialEq, Eq, Hash)]
644pub struct Constraint {
645    syntax: SyntaxNode,
646}
647impl AstNode for Constraint {
648    fn cast(syntax: SyntaxNode) -> Option<Self> {
649        (syntax.kind() == SyntaxKind::Constraint).then_some(Self { syntax })
650    }
651    fn syntax(&self) -> &SyntaxNode {
652        &self.syntax
653    }
654}
655impl Constraint {
656    pub fn len(&self) -> Option<Bound> {
657        support::child(&self.syntax)
658    }
659    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
660        support::token(&self.syntax, SyntaxKind::LBracket)
661    }
662    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
663        support::token(&self.syntax, SyntaxKind::DotDot)
664    }
665    pub fn step_token(&self) -> Option<SyntaxToken> {
666        support::token(&self.syntax, SyntaxKind::StepKw)
667    }
668    pub fn match_token(&self) -> Option<SyntaxToken> {
669        support::token(&self.syntax, SyntaxKind::MatchKw)
670    }
671    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
672        support::token(&self.syntax, SyntaxKind::RBracket)
673    }
674}
675/// A `InitValue` node (`family.ungram` rule `InitValue`).
676#[derive(Debug, Clone, PartialEq, Eq, Hash)]
677pub struct InitValue {
678    syntax: SyntaxNode,
679}
680impl AstNode for InitValue {
681    fn cast(syntax: SyntaxNode) -> Option<Self> {
682        (syntax.kind() == SyntaxKind::InitValue).then_some(Self { syntax })
683    }
684    fn syntax(&self) -> &SyntaxNode {
685        &self.syntax
686    }
687}
688impl InitValue {
689    pub fn literal(&self) -> Option<Literal> {
690        support::child(&self.syntax)
691    }
692    pub fn eq_token(&self) -> Option<SyntaxToken> {
693        support::token(&self.syntax, SyntaxKind::Eq)
694    }
695}
696/// A `PrimitiveType` node (`family.ungram` rule `PrimitiveType`).
697#[derive(Debug, Clone, PartialEq, Eq, Hash)]
698pub struct PrimitiveType {
699    syntax: SyntaxNode,
700}
701impl AstNode for PrimitiveType {
702    fn cast(syntax: SyntaxNode) -> Option<Self> {
703        (syntax.kind() == SyntaxKind::PrimitiveType).then_some(Self { syntax })
704    }
705    fn syntax(&self) -> &SyntaxNode {
706        &self.syntax
707    }
708}
709impl PrimitiveType {
710    pub fn constraint(&self) -> Option<Constraint> {
711        support::child(&self.syntax)
712    }
713    pub fn boolean_token(&self) -> Option<SyntaxToken> {
714        support::token(&self.syntax, SyntaxKind::BooleanKw)
715    }
716    pub fn integer_token(&self) -> Option<SyntaxToken> {
717        support::token(&self.syntax, SyntaxKind::IntegerKw)
718    }
719    pub fn float_token(&self) -> Option<SyntaxToken> {
720        support::token(&self.syntax, SyntaxKind::FloatKw)
721    }
722    pub fn string_token(&self) -> Option<SyntaxToken> {
723        support::token(&self.syntax, SyntaxKind::StringKw)
724    }
725    pub fn bytes_token(&self) -> Option<SyntaxToken> {
726        support::token(&self.syntax, SyntaxKind::BytesKw)
727    }
728}
729/// A `UnitExpr` node (`family.ungram` rule `UnitExpr`).
730#[derive(Debug, Clone, PartialEq, Eq, Hash)]
731pub struct UnitExpr {
732    syntax: SyntaxNode,
733}
734impl AstNode for UnitExpr {
735    fn cast(syntax: SyntaxNode) -> Option<Self> {
736        (syntax.kind() == SyntaxKind::UnitExpr).then_some(Self { syntax })
737    }
738    fn syntax(&self) -> &SyntaxNode {
739        &self.syntax
740    }
741}
742impl UnitExpr {
743    pub fn ident_token(&self) -> Option<SyntaxToken> {
744        support::token(&self.syntax, SyntaxKind::Ident)
745    }
746    pub fn slash_token(&self) -> Option<SyntaxToken> {
747        support::token(&self.syntax, SyntaxKind::Slash)
748    }
749    pub fn dot_token(&self) -> Option<SyntaxToken> {
750        support::token(&self.syntax, SyntaxKind::Dot)
751    }
752    pub fn percent_token(&self) -> Option<SyntaxToken> {
753        support::token(&self.syntax, SyntaxKind::Percent)
754    }
755}
756/// A `Literal` node (`family.ungram` rule `Literal`).
757#[derive(Debug, Clone, PartialEq, Eq, Hash)]
758pub struct Literal {
759    syntax: SyntaxNode,
760}
761impl AstNode for Literal {
762    fn cast(syntax: SyntaxNode) -> Option<Self> {
763        (syntax.kind() == SyntaxKind::Literal).then_some(Self { syntax })
764    }
765    fn syntax(&self) -> &SyntaxNode {
766        &self.syntax
767    }
768}
769impl Literal {
770    pub fn minus_token(&self) -> Option<SyntaxToken> {
771        support::token(&self.syntax, SyntaxKind::Minus)
772    }
773    pub fn int_number_token(&self) -> Option<SyntaxToken> {
774        support::token(&self.syntax, SyntaxKind::IntNumber)
775    }
776    pub fn float_number_token(&self) -> Option<SyntaxToken> {
777        support::token(&self.syntax, SyntaxKind::FloatNumber)
778    }
779    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
780        support::token(&self.syntax, SyntaxKind::String)
781    }
782    pub fn true_token(&self) -> Option<SyntaxToken> {
783        support::token(&self.syntax, SyntaxKind::TrueKw)
784    }
785    pub fn false_token(&self) -> Option<SyntaxToken> {
786        support::token(&self.syntax, SyntaxKind::FalseKw)
787    }
788    pub fn regex_token(&self) -> Option<SyntaxToken> {
789        support::token(&self.syntax, SyntaxKind::Regex)
790    }
791    pub fn ident_token(&self) -> Option<SyntaxToken> {
792        support::token(&self.syntax, SyntaxKind::Ident)
793    }
794}
795/// A `Bound` node (`family.ungram` rule `Bound`).
796#[derive(Debug, Clone, PartialEq, Eq, Hash)]
797pub struct Bound {
798    syntax: SyntaxNode,
799}
800impl AstNode for Bound {
801    fn cast(syntax: SyntaxNode) -> Option<Self> {
802        (syntax.kind() == SyntaxKind::Bound).then_some(Self { syntax })
803    }
804    fn syntax(&self) -> &SyntaxNode {
805        &self.syntax
806    }
807}
808impl Bound {
809    pub fn min(&self) -> Option<Literal> {
810        support::nth_child(&self.syntax, 0usize)
811    }
812    pub fn max(&self) -> Option<Literal> {
813        support::nth_child(&self.syntax, 1usize)
814    }
815    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
816        support::token(&self.syntax, SyntaxKind::DotDot)
817    }
818}
819/// A `PathType` node (`family.ungram` rule `PathType`).
820#[derive(Debug, Clone, PartialEq, Eq, Hash)]
821pub struct PathType {
822    syntax: SyntaxNode,
823}
824impl AstNode for PathType {
825    fn cast(syntax: SyntaxNode) -> Option<Self> {
826        (syntax.kind() == SyntaxKind::PathType).then_some(Self { syntax })
827    }
828    fn syntax(&self) -> &SyntaxNode {
829        &self.syntax
830    }
831}
832impl PathType {
833    pub fn qualified_name(&self) -> Option<QualifiedName> {
834        support::child(&self.syntax)
835    }
836}
837/// A `FieldDef` node (`family.ungram` rule `FieldDef`).
838#[derive(Debug, Clone, PartialEq, Eq, Hash)]
839pub struct FieldDef {
840    syntax: SyntaxNode,
841}
842impl AstNode for FieldDef {
843    fn cast(syntax: SyntaxNode) -> Option<Self> {
844        (syntax.kind() == SyntaxKind::FieldDef).then_some(Self { syntax })
845    }
846    fn syntax(&self) -> &SyntaxNode {
847        &self.syntax
848    }
849}
850impl FieldDef {
851    pub fn name(&self) -> Option<Name> {
852        support::child(&self.syntax)
853    }
854    pub fn field_type(&self) -> Option<FieldType> {
855        support::child(&self.syntax)
856    }
857    pub fn init_value(&self) -> Option<InitValue> {
858        support::child(&self.syntax)
859    }
860    pub fn colon_token(&self) -> Option<SyntaxToken> {
861        support::token(&self.syntax, SyntaxKind::Colon)
862    }
863}
864/// A `ReservedEntry` node (`family.ungram` rule `ReservedEntry`).
865#[derive(Debug, Clone, PartialEq, Eq, Hash)]
866pub struct ReservedEntry {
867    syntax: SyntaxNode,
868}
869impl AstNode for ReservedEntry {
870    fn cast(syntax: SyntaxNode) -> Option<Self> {
871        (syntax.kind() == SyntaxKind::ReservedEntry).then_some(Self { syntax })
872    }
873    fn syntax(&self) -> &SyntaxNode {
874        &self.syntax
875    }
876}
877impl ReservedEntry {
878    pub fn name(&self) -> Option<Name> {
879        support::child(&self.syntax)
880    }
881    pub fn literal(&self) -> Option<Literal> {
882        support::child(&self.syntax)
883    }
884    pub fn reserved_token(&self) -> Option<SyntaxToken> {
885        support::token(&self.syntax, SyntaxKind::ReservedKw)
886    }
887}
888/// A `TupleType` node (`family.ungram` rule `TupleType`).
889#[derive(Debug, Clone, PartialEq, Eq, Hash)]
890pub struct TupleType {
891    syntax: SyntaxNode,
892}
893impl AstNode for TupleType {
894    fn cast(syntax: SyntaxNode) -> Option<Self> {
895        (syntax.kind() == SyntaxKind::TupleType).then_some(Self { syntax })
896    }
897    fn syntax(&self) -> &SyntaxNode {
898        &self.syntax
899    }
900}
901impl TupleType {
902    pub fn fields(&self) -> AstChildren<TupleField> {
903        support::children(&self.syntax)
904    }
905    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
906        support::token(&self.syntax, SyntaxKind::LParen)
907    }
908    pub fn comma_token(&self) -> Option<SyntaxToken> {
909        support::token(&self.syntax, SyntaxKind::Comma)
910    }
911    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
912        support::token(&self.syntax, SyntaxKind::RParen)
913    }
914}
915/// A `ArrayType` node (`family.ungram` rule `ArrayType`).
916#[derive(Debug, Clone, PartialEq, Eq, Hash)]
917pub struct ArrayType {
918    syntax: SyntaxNode,
919}
920impl AstNode for ArrayType {
921    fn cast(syntax: SyntaxNode) -> Option<Self> {
922        (syntax.kind() == SyntaxKind::ArrayType).then_some(Self { syntax })
923    }
924    fn syntax(&self) -> &SyntaxNode {
925        &self.syntax
926    }
927}
928impl ArrayType {
929    pub fn element(&self) -> Option<FieldType> {
930        support::child(&self.syntax)
931    }
932    pub fn bound(&self) -> Option<Bound> {
933        support::child(&self.syntax)
934    }
935    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
936        support::token(&self.syntax, SyntaxKind::LBracket)
937    }
938    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
939        support::token(&self.syntax, SyntaxKind::Semicolon)
940    }
941    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
942        support::token(&self.syntax, SyntaxKind::RBracket)
943    }
944}
945/// A `MapType` node (`family.ungram` rule `MapType`).
946#[derive(Debug, Clone, PartialEq, Eq, Hash)]
947pub struct MapType {
948    syntax: SyntaxNode,
949}
950impl AstNode for MapType {
951    fn cast(syntax: SyntaxNode) -> Option<Self> {
952        (syntax.kind() == SyntaxKind::MapType).then_some(Self { syntax })
953    }
954    fn syntax(&self) -> &SyntaxNode {
955        &self.syntax
956    }
957}
958impl MapType {
959    pub fn key(&self) -> Option<FieldType> {
960        support::nth_child(&self.syntax, 0usize)
961    }
962    pub fn value(&self) -> Option<FieldType> {
963        support::nth_child(&self.syntax, 1usize)
964    }
965    pub fn bound(&self) -> Option<Bound> {
966        support::child(&self.syntax)
967    }
968    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
969        support::token(&self.syntax, SyntaxKind::LBracket)
970    }
971    pub fn colon_token(&self) -> Option<SyntaxToken> {
972        support::token(&self.syntax, SyntaxKind::Colon)
973    }
974    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
975        support::token(&self.syntax, SyntaxKind::Semicolon)
976    }
977    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
978        support::token(&self.syntax, SyntaxKind::RBracket)
979    }
980}
981/// A `OptionalType` node (`family.ungram` rule `OptionalType`).
982#[derive(Debug, Clone, PartialEq, Eq, Hash)]
983pub struct OptionalType {
984    syntax: SyntaxNode,
985}
986impl AstNode for OptionalType {
987    fn cast(syntax: SyntaxNode) -> Option<Self> {
988        (syntax.kind() == SyntaxKind::OptionalType).then_some(Self { syntax })
989    }
990    fn syntax(&self) -> &SyntaxNode {
991        &self.syntax
992    }
993}
994impl OptionalType {
995    pub fn field_type(&self) -> Option<FieldType> {
996        support::child(&self.syntax)
997    }
998    pub fn question_token(&self) -> Option<SyntaxToken> {
999        support::token(&self.syntax, SyntaxKind::Question)
1000    }
1001}
1002/// A `TupleField` node (`family.ungram` rule `TupleField`).
1003#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1004pub struct TupleField {
1005    syntax: SyntaxNode,
1006}
1007impl AstNode for TupleField {
1008    fn cast(syntax: SyntaxNode) -> Option<Self> {
1009        (syntax.kind() == SyntaxKind::TupleField).then_some(Self { syntax })
1010    }
1011    fn syntax(&self) -> &SyntaxNode {
1012        &self.syntax
1013    }
1014}
1015impl TupleField {
1016    pub fn name(&self) -> Option<Name> {
1017        support::child(&self.syntax)
1018    }
1019    pub fn field_type(&self) -> Option<FieldType> {
1020        support::child(&self.syntax)
1021    }
1022    pub fn colon_token(&self) -> Option<SyntaxToken> {
1023        support::token(&self.syntax, SyntaxKind::Colon)
1024    }
1025}
1026/// A `EnumValue` node (`family.ungram` rule `EnumValue`).
1027#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1028pub struct EnumValue {
1029    syntax: SyntaxNode,
1030}
1031impl AstNode for EnumValue {
1032    fn cast(syntax: SyntaxNode) -> Option<Self> {
1033        (syntax.kind() == SyntaxKind::EnumValue).then_some(Self { syntax })
1034    }
1035    fn syntax(&self) -> &SyntaxNode {
1036        &self.syntax
1037    }
1038}
1039impl EnumValue {
1040    pub fn name(&self) -> Option<Name> {
1041        support::child(&self.syntax)
1042    }
1043    pub fn value(&self) -> Option<Literal> {
1044        support::child(&self.syntax)
1045    }
1046    pub fn eq_token(&self) -> Option<SyntaxToken> {
1047        support::token(&self.syntax, SyntaxKind::Eq)
1048    }
1049}
1050/// A `EnumSetBit` node (`family.ungram` rule `EnumSetBit`).
1051#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1052pub struct EnumSetBit {
1053    syntax: SyntaxNode,
1054}
1055impl AstNode for EnumSetBit {
1056    fn cast(syntax: SyntaxNode) -> Option<Self> {
1057        (syntax.kind() == SyntaxKind::EnumSetBit).then_some(Self { syntax })
1058    }
1059    fn syntax(&self) -> &SyntaxNode {
1060        &self.syntax
1061    }
1062}
1063impl EnumSetBit {
1064    pub fn name(&self) -> Option<Name> {
1065        support::child(&self.syntax)
1066    }
1067    pub fn value(&self) -> Option<Literal> {
1068        support::child(&self.syntax)
1069    }
1070    pub fn eq_token(&self) -> Option<SyntaxToken> {
1071        support::token(&self.syntax, SyntaxKind::Eq)
1072    }
1073}
1074/// A `UnionArm` node (`family.ungram` rule `UnionArm`).
1075#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1076pub struct UnionArm {
1077    syntax: SyntaxNode,
1078}
1079impl AstNode for UnionArm {
1080    fn cast(syntax: SyntaxNode) -> Option<Self> {
1081        (syntax.kind() == SyntaxKind::UnionArm).then_some(Self { syntax })
1082    }
1083    fn syntax(&self) -> &SyntaxNode {
1084        &self.syntax
1085    }
1086}
1087impl UnionArm {
1088    pub fn name(&self) -> Option<Name> {
1089        support::child(&self.syntax)
1090    }
1091    pub fn type_ref(&self) -> Option<PathType> {
1092        support::child(&self.syntax)
1093    }
1094    pub fn colon_token(&self) -> Option<SyntaxToken> {
1095        support::token(&self.syntax, SyntaxKind::Colon)
1096    }
1097}
1098/// A `SignalDef` node (`family.ungram` rule `SignalDef`).
1099#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1100pub struct SignalDef {
1101    syntax: SyntaxNode,
1102}
1103impl AstNode for SignalDef {
1104    fn cast(syntax: SyntaxNode) -> Option<Self> {
1105        (syntax.kind() == SyntaxKind::SignalDef).then_some(Self { syntax })
1106    }
1107    fn syntax(&self) -> &SyntaxNode {
1108        &self.syntax
1109    }
1110}
1111impl SignalDef {
1112    pub fn name(&self) -> Option<Name> {
1113        support::child(&self.syntax)
1114    }
1115    pub fn payload(&self) -> Option<FieldType> {
1116        support::child(&self.syntax)
1117    }
1118    pub fn init_value(&self) -> Option<InitValue> {
1119        support::child(&self.syntax)
1120    }
1121    pub fn timing(&self) -> Option<Timing> {
1122        support::child(&self.syntax)
1123    }
1124    pub fn signal_token(&self) -> Option<SyntaxToken> {
1125        support::token(&self.syntax, SyntaxKind::SignalKw)
1126    }
1127    pub fn colon_token(&self) -> Option<SyntaxToken> {
1128        support::token(&self.syntax, SyntaxKind::Colon)
1129    }
1130}
1131/// A `EventDef` node (`family.ungram` rule `EventDef`).
1132#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1133pub struct EventDef {
1134    syntax: SyntaxNode,
1135}
1136impl AstNode for EventDef {
1137    fn cast(syntax: SyntaxNode) -> Option<Self> {
1138        (syntax.kind() == SyntaxKind::EventDef).then_some(Self { syntax })
1139    }
1140    fn syntax(&self) -> &SyntaxNode {
1141        &self.syntax
1142    }
1143}
1144impl EventDef {
1145    pub fn name(&self) -> Option<Name> {
1146        support::child(&self.syntax)
1147    }
1148    pub fn payload(&self) -> Option<FieldType> {
1149        support::child(&self.syntax)
1150    }
1151    pub fn timing(&self) -> Option<Timing> {
1152        support::child(&self.syntax)
1153    }
1154    pub fn event_token(&self) -> Option<SyntaxToken> {
1155        support::token(&self.syntax, SyntaxKind::EventKw)
1156    }
1157    pub fn colon_token(&self) -> Option<SyntaxToken> {
1158        support::token(&self.syntax, SyntaxKind::Colon)
1159    }
1160}
1161/// A `CommandDef` node (`family.ungram` rule `CommandDef`).
1162#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1163pub struct CommandDef {
1164    syntax: SyntaxNode,
1165}
1166impl AstNode for CommandDef {
1167    fn cast(syntax: SyntaxNode) -> Option<Self> {
1168        (syntax.kind() == SyntaxKind::CommandDef).then_some(Self { syntax })
1169    }
1170    fn syntax(&self) -> &SyntaxNode {
1171        &self.syntax
1172    }
1173}
1174impl CommandDef {
1175    pub fn name(&self) -> Option<Name> {
1176        support::child(&self.syntax)
1177    }
1178    pub fn params(&self) -> Option<ParamList> {
1179        support::child(&self.syntax)
1180    }
1181    pub fn return_type(&self) -> Option<ReturnType> {
1182        support::child(&self.syntax)
1183    }
1184    pub fn timing(&self) -> Option<Timing> {
1185        support::child(&self.syntax)
1186    }
1187    pub fn attr_block(&self) -> Option<AttrBlock> {
1188        support::child(&self.syntax)
1189    }
1190    pub fn command_token(&self) -> Option<SyntaxToken> {
1191        support::token(&self.syntax, SyntaxKind::CommandKw)
1192    }
1193    pub fn colon_token(&self) -> Option<SyntaxToken> {
1194        support::token(&self.syntax, SyntaxKind::Colon)
1195    }
1196}
1197/// A `QueryDef` node (`family.ungram` rule `QueryDef`).
1198#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1199pub struct QueryDef {
1200    syntax: SyntaxNode,
1201}
1202impl AstNode for QueryDef {
1203    fn cast(syntax: SyntaxNode) -> Option<Self> {
1204        (syntax.kind() == SyntaxKind::QueryDef).then_some(Self { syntax })
1205    }
1206    fn syntax(&self) -> &SyntaxNode {
1207        &self.syntax
1208    }
1209}
1210impl QueryDef {
1211    pub fn name(&self) -> Option<Name> {
1212        support::child(&self.syntax)
1213    }
1214    pub fn params(&self) -> Option<ParamList> {
1215        support::child(&self.syntax)
1216    }
1217    pub fn return_type(&self) -> Option<ReturnType> {
1218        support::child(&self.syntax)
1219    }
1220    pub fn timing(&self) -> Option<Timing> {
1221        support::child(&self.syntax)
1222    }
1223    pub fn attr_block(&self) -> Option<AttrBlock> {
1224        support::child(&self.syntax)
1225    }
1226    pub fn query_token(&self) -> Option<SyntaxToken> {
1227        support::token(&self.syntax, SyntaxKind::QueryKw)
1228    }
1229    pub fn colon_token(&self) -> Option<SyntaxToken> {
1230        support::token(&self.syntax, SyntaxKind::Colon)
1231    }
1232}
1233/// A `FixedDef` node (`family.ungram` rule `FixedDef`).
1234#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1235pub struct FixedDef {
1236    syntax: SyntaxNode,
1237}
1238impl AstNode for FixedDef {
1239    fn cast(syntax: SyntaxNode) -> Option<Self> {
1240        (syntax.kind() == SyntaxKind::FixedDef).then_some(Self { syntax })
1241    }
1242    fn syntax(&self) -> &SyntaxNode {
1243        &self.syntax
1244    }
1245}
1246impl FixedDef {
1247    pub fn name(&self) -> Option<Name> {
1248        support::child(&self.syntax)
1249    }
1250    pub fn payload(&self) -> Option<FieldType> {
1251        support::child(&self.syntax)
1252    }
1253    pub fn timing(&self) -> Option<Timing> {
1254        support::child(&self.syntax)
1255    }
1256    pub fn attr_block(&self) -> Option<AttrBlock> {
1257        support::child(&self.syntax)
1258    }
1259    pub fn fixed_token(&self) -> Option<SyntaxToken> {
1260        support::token(&self.syntax, SyntaxKind::FixedKw)
1261    }
1262    pub fn colon_token(&self) -> Option<SyntaxToken> {
1263        support::token(&self.syntax, SyntaxKind::Colon)
1264    }
1265}
1266/// A `Timing` node (`family.ungram` rule `Timing`).
1267#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1268pub struct Timing {
1269    syntax: SyntaxNode,
1270}
1271impl AstNode for Timing {
1272    fn cast(syntax: SyntaxNode) -> Option<Self> {
1273        (syntax.kind() == SyntaxKind::Timing).then_some(Self { syntax })
1274    }
1275    fn syntax(&self) -> &SyntaxNode {
1276        &self.syntax
1277    }
1278}
1279impl Timing {
1280    pub fn range(&self) -> Option<TimingRange> {
1281        support::child(&self.syntax)
1282    }
1283    pub fn at_token(&self) -> Option<SyntaxToken> {
1284        support::token(&self.syntax, SyntaxKind::At)
1285    }
1286    pub fn duration_token(&self) -> Option<SyntaxToken> {
1287        support::token(&self.syntax, SyntaxKind::Duration)
1288    }
1289    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
1290        support::token(&self.syntax, SyntaxKind::LBracket)
1291    }
1292    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
1293        support::token(&self.syntax, SyntaxKind::RBracket)
1294    }
1295}
1296/// A `ParamList` node (`family.ungram` rule `ParamList`).
1297#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1298pub struct ParamList {
1299    syntax: SyntaxNode,
1300}
1301impl AstNode for ParamList {
1302    fn cast(syntax: SyntaxNode) -> Option<Self> {
1303        (syntax.kind() == SyntaxKind::ParamList).then_some(Self { syntax })
1304    }
1305    fn syntax(&self) -> &SyntaxNode {
1306        &self.syntax
1307    }
1308}
1309impl ParamList {
1310    pub fn params(&self) -> AstChildren<Param> {
1311        support::children(&self.syntax)
1312    }
1313    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1314        support::token(&self.syntax, SyntaxKind::LParen)
1315    }
1316    pub fn comma_token(&self) -> Option<SyntaxToken> {
1317        support::token(&self.syntax, SyntaxKind::Comma)
1318    }
1319    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1320        support::token(&self.syntax, SyntaxKind::RParen)
1321    }
1322}
1323/// A `ReturnType` node (`family.ungram` rule `ReturnType`).
1324#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1325pub struct ReturnType {
1326    syntax: SyntaxNode,
1327}
1328impl AstNode for ReturnType {
1329    fn cast(syntax: SyntaxNode) -> Option<Self> {
1330        (syntax.kind() == SyntaxKind::ReturnType).then_some(Self { syntax })
1331    }
1332    fn syntax(&self) -> &SyntaxNode {
1333        &self.syntax
1334    }
1335}
1336impl ReturnType {
1337    pub fn type_ref(&self) -> Option<PathType> {
1338        support::child(&self.syntax)
1339    }
1340    pub fn tuple_type(&self) -> Option<TupleType> {
1341        support::child(&self.syntax)
1342    }
1343    pub fn stream_type(&self) -> Option<StreamType> {
1344        support::child(&self.syntax)
1345    }
1346    pub fn fallible_type(&self) -> Option<FallibleType> {
1347        support::child(&self.syntax)
1348    }
1349}
1350/// A `AttrBlock` node (`family.ungram` rule `AttrBlock`).
1351#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1352pub struct AttrBlock {
1353    syntax: SyntaxNode,
1354}
1355impl AstNode for AttrBlock {
1356    fn cast(syntax: SyntaxNode) -> Option<Self> {
1357        (syntax.kind() == SyntaxKind::AttrBlock).then_some(Self { syntax })
1358    }
1359    fn syntax(&self) -> &SyntaxNode {
1360        &self.syntax
1361    }
1362}
1363impl AttrBlock {
1364    pub fn attributes(&self) -> AstChildren<Attribute> {
1365        support::children(&self.syntax)
1366    }
1367    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
1368        support::token(&self.syntax, SyntaxKind::LBracket)
1369    }
1370    pub fn comma_token(&self) -> Option<SyntaxToken> {
1371        support::token(&self.syntax, SyntaxKind::Comma)
1372    }
1373    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
1374        support::token(&self.syntax, SyntaxKind::RBracket)
1375    }
1376}
1377/// A `Param` node (`family.ungram` rule `Param`).
1378#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1379pub struct Param {
1380    syntax: SyntaxNode,
1381}
1382impl AstNode for Param {
1383    fn cast(syntax: SyntaxNode) -> Option<Self> {
1384        (syntax.kind() == SyntaxKind::Param).then_some(Self { syntax })
1385    }
1386    fn syntax(&self) -> &SyntaxNode {
1387        &self.syntax
1388    }
1389}
1390impl Param {
1391    pub fn name(&self) -> Option<Name> {
1392        support::child(&self.syntax)
1393    }
1394    pub fn param_type(&self) -> Option<ParamType> {
1395        support::child(&self.syntax)
1396    }
1397    pub fn colon_token(&self) -> Option<SyntaxToken> {
1398        support::token(&self.syntax, SyntaxKind::Colon)
1399    }
1400}
1401/// A `StreamType` node (`family.ungram` rule `StreamType`).
1402#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1403pub struct StreamType {
1404    syntax: SyntaxNode,
1405}
1406impl AstNode for StreamType {
1407    fn cast(syntax: SyntaxNode) -> Option<Self> {
1408        (syntax.kind() == SyntaxKind::StreamType).then_some(Self { syntax })
1409    }
1410    fn syntax(&self) -> &SyntaxNode {
1411        &self.syntax
1412    }
1413}
1414impl StreamType {
1415    pub fn element_type(&self) -> Option<PathType> {
1416        support::child(&self.syntax)
1417    }
1418    pub fn lt_token(&self) -> Option<SyntaxToken> {
1419        support::token(&self.syntax, SyntaxKind::Lt)
1420    }
1421    pub fn string_token(&self) -> Option<SyntaxToken> {
1422        support::token(&self.syntax, SyntaxKind::StringKw)
1423    }
1424    pub fn bytes_token(&self) -> Option<SyntaxToken> {
1425        support::token(&self.syntax, SyntaxKind::BytesKw)
1426    }
1427    pub fn gt_token(&self) -> Option<SyntaxToken> {
1428        support::token(&self.syntax, SyntaxKind::Gt)
1429    }
1430}
1431/// A `FallibleType` node (`family.ungram` rule `FallibleType`).
1432#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1433pub struct FallibleType {
1434    syntax: SyntaxNode,
1435}
1436impl AstNode for FallibleType {
1437    fn cast(syntax: SyntaxNode) -> Option<Self> {
1438        (syntax.kind() == SyntaxKind::FallibleType).then_some(Self { syntax })
1439    }
1440    fn syntax(&self) -> &SyntaxNode {
1441        &self.syntax
1442    }
1443}
1444impl FallibleType {
1445    pub fn ok(&self) -> Option<PathType> {
1446        support::nth_child(&self.syntax, 0usize)
1447    }
1448    pub fn err(&self) -> Option<PathType> {
1449        support::nth_child(&self.syntax, 1usize)
1450    }
1451    pub fn pipe_token(&self) -> Option<SyntaxToken> {
1452        support::token(&self.syntax, SyntaxKind::Pipe)
1453    }
1454}
1455/// A `TimingRange` node (`family.ungram` rule `TimingRange`).
1456#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1457pub struct TimingRange {
1458    syntax: SyntaxNode,
1459}
1460impl AstNode for TimingRange {
1461    fn cast(syntax: SyntaxNode) -> Option<Self> {
1462        (syntax.kind() == SyntaxKind::TimingRange).then_some(Self { syntax })
1463    }
1464    fn syntax(&self) -> &SyntaxNode {
1465        &self.syntax
1466    }
1467}
1468impl TimingRange {
1469    pub fn duration_token(&self) -> Option<SyntaxToken> {
1470        support::token(&self.syntax, SyntaxKind::Duration)
1471    }
1472    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
1473        support::token(&self.syntax, SyntaxKind::DotDot)
1474    }
1475}
1476/// A `DottedName` node (`family.ungram` rule `DottedName`).
1477#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1478pub struct DottedName {
1479    syntax: SyntaxNode,
1480}
1481impl AstNode for DottedName {
1482    fn cast(syntax: SyntaxNode) -> Option<Self> {
1483        (syntax.kind() == SyntaxKind::DottedName).then_some(Self { syntax })
1484    }
1485    fn syntax(&self) -> &SyntaxNode {
1486        &self.syntax
1487    }
1488}
1489impl DottedName {
1490    pub fn ident_token(&self) -> Option<SyntaxToken> {
1491        support::token(&self.syntax, SyntaxKind::Ident)
1492    }
1493    pub fn dot_token(&self) -> Option<SyntaxToken> {
1494        support::token(&self.syntax, SyntaxKind::Dot)
1495    }
1496}
1497/// A `Attribute` node (`family.ungram` rule `Attribute`).
1498#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1499pub struct Attribute {
1500    syntax: SyntaxNode,
1501}
1502impl AstNode for Attribute {
1503    fn cast(syntax: SyntaxNode) -> Option<Self> {
1504        (syntax.kind() == SyntaxKind::Attribute).then_some(Self { syntax })
1505    }
1506    fn syntax(&self) -> &SyntaxNode {
1507        &self.syntax
1508    }
1509}
1510impl Attribute {
1511    pub fn key(&self) -> Option<Name> {
1512        support::child(&self.syntax)
1513    }
1514    pub fn value(&self) -> Option<AttrValue> {
1515        support::child(&self.syntax)
1516    }
1517    pub fn expr(&self) -> Option<Expr> {
1518        support::child(&self.syntax)
1519    }
1520    pub fn dot_token(&self) -> Option<SyntaxToken> {
1521        support::token(&self.syntax, SyntaxKind::Dot)
1522    }
1523    pub fn eq_token(&self) -> Option<SyntaxToken> {
1524        support::token(&self.syntax, SyntaxKind::Eq)
1525    }
1526    pub fn require_token(&self) -> Option<SyntaxToken> {
1527        support::token(&self.syntax, SyntaxKind::RequireKw)
1528    }
1529    pub fn ensure_token(&self) -> Option<SyntaxToken> {
1530        support::token(&self.syntax, SyntaxKind::EnsureKw)
1531    }
1532}
1533/// A `AttrValue` node (`family.ungram` rule `AttrValue`).
1534#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1535pub struct AttrValue {
1536    syntax: SyntaxNode,
1537}
1538impl AstNode for AttrValue {
1539    fn cast(syntax: SyntaxNode) -> Option<Self> {
1540        (syntax.kind() == SyntaxKind::AttrValue).then_some(Self { syntax })
1541    }
1542    fn syntax(&self) -> &SyntaxNode {
1543        &self.syntax
1544    }
1545}
1546impl AttrValue {
1547    pub fn literal(&self) -> Option<Literal> {
1548        support::child(&self.syntax)
1549    }
1550    pub fn values(&self) -> AstChildren<AttrValue> {
1551        support::children(&self.syntax)
1552    }
1553    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1554        support::token(&self.syntax, SyntaxKind::LParen)
1555    }
1556    pub fn comma_token(&self) -> Option<SyntaxToken> {
1557        support::token(&self.syntax, SyntaxKind::Comma)
1558    }
1559    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1560        support::token(&self.syntax, SyntaxKind::RParen)
1561    }
1562}
1563/// A `MemberLine` node (`family.ungram` rule `MemberLine`).
1564#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1565pub struct MemberLine {
1566    syntax: SyntaxNode,
1567}
1568impl AstNode for MemberLine {
1569    fn cast(syntax: SyntaxNode) -> Option<Self> {
1570        (syntax.kind() == SyntaxKind::MemberLine).then_some(Self { syntax })
1571    }
1572    fn syntax(&self) -> &SyntaxNode {
1573        &self.syntax
1574    }
1575}
1576impl MemberLine {
1577    pub fn reference(&self) -> Option<Reference> {
1578        support::child(&self.syntax)
1579    }
1580    pub fn attr_block(&self) -> Option<AttrBlock> {
1581        support::child(&self.syntax)
1582    }
1583}
1584/// A `ComponentLine` node (`family.ungram` rule `ComponentLine`).
1585#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1586pub struct ComponentLine {
1587    syntax: SyntaxNode,
1588}
1589impl AstNode for ComponentLine {
1590    fn cast(syntax: SyntaxNode) -> Option<Self> {
1591        (syntax.kind() == SyntaxKind::ComponentLine).then_some(Self { syntax })
1592    }
1593    fn syntax(&self) -> &SyntaxNode {
1594        &self.syntax
1595    }
1596}
1597impl ComponentLine {
1598    pub fn reference(&self) -> Option<Reference> {
1599        support::child(&self.syntax)
1600    }
1601    pub fn attr_block(&self) -> Option<AttrBlock> {
1602        support::child(&self.syntax)
1603    }
1604    pub fn offers_token(&self) -> Option<SyntaxToken> {
1605        support::token(&self.syntax, SyntaxKind::OffersKw)
1606    }
1607    pub fn requires_token(&self) -> Option<SyntaxToken> {
1608        support::token(&self.syntax, SyntaxKind::RequiresKw)
1609    }
1610}
1611/// A `Reference` node (`family.ungram` rule `Reference`).
1612#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1613pub struct Reference {
1614    syntax: SyntaxNode,
1615}
1616impl AstNode for Reference {
1617    fn cast(syntax: SyntaxNode) -> Option<Self> {
1618        (syntax.kind() == SyntaxKind::Reference).then_some(Self { syntax })
1619    }
1620    fn syntax(&self) -> &SyntaxNode {
1621        &self.syntax
1622    }
1623}
1624impl Reference {
1625    pub fn qualified_name(&self) -> Option<QualifiedName> {
1626        support::child(&self.syntax)
1627    }
1628}
1629/// A `MachineDef` node (`family.ungram` rule `MachineDef`).
1630#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1631pub struct MachineDef {
1632    syntax: SyntaxNode,
1633}
1634impl AstNode for MachineDef {
1635    fn cast(syntax: SyntaxNode) -> Option<Self> {
1636        (syntax.kind() == SyntaxKind::MachineDef).then_some(Self { syntax })
1637    }
1638    fn syntax(&self) -> &SyntaxNode {
1639        &self.syntax
1640    }
1641}
1642impl MachineDef {
1643    pub fn name(&self) -> Option<Name> {
1644        support::child(&self.syntax)
1645    }
1646    pub fn attr_block(&self) -> Option<AttrBlock> {
1647        support::child(&self.syntax)
1648    }
1649    pub fn lines(&self) -> AstChildren<MemberLine> {
1650        support::children(&self.syntax)
1651    }
1652    pub fn machine_token(&self) -> Option<SyntaxToken> {
1653        support::token(&self.syntax, SyntaxKind::MachineKw)
1654    }
1655    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
1656        support::token(&self.syntax, SyntaxKind::LBrace)
1657    }
1658    pub fn comma_token(&self) -> Option<SyntaxToken> {
1659        support::token(&self.syntax, SyntaxKind::Comma)
1660    }
1661    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
1662        support::token(&self.syntax, SyntaxKind::RBrace)
1663    }
1664}
1665/// A `BinaryExpr` node (`family.ungram` rule `BinaryExpr`).
1666#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1667pub struct BinaryExpr {
1668    syntax: SyntaxNode,
1669}
1670impl AstNode for BinaryExpr {
1671    fn cast(syntax: SyntaxNode) -> Option<Self> {
1672        (syntax.kind() == SyntaxKind::BinaryExpr).then_some(Self { syntax })
1673    }
1674    fn syntax(&self) -> &SyntaxNode {
1675        &self.syntax
1676    }
1677}
1678impl BinaryExpr {
1679    pub fn lhs(&self) -> Option<Expr> {
1680        support::nth_child(&self.syntax, 0usize)
1681    }
1682    pub fn rhs(&self) -> Option<Expr> {
1683        support::nth_child(&self.syntax, 1usize)
1684    }
1685    pub fn pipepipe_token(&self) -> Option<SyntaxToken> {
1686        support::token(&self.syntax, SyntaxKind::PipePipe)
1687    }
1688    pub fn ampamp_token(&self) -> Option<SyntaxToken> {
1689        support::token(&self.syntax, SyntaxKind::AmpAmp)
1690    }
1691    pub fn eqeq_token(&self) -> Option<SyntaxToken> {
1692        support::token(&self.syntax, SyntaxKind::EqEq)
1693    }
1694    pub fn neq_token(&self) -> Option<SyntaxToken> {
1695        support::token(&self.syntax, SyntaxKind::Neq)
1696    }
1697    pub fn lt_token(&self) -> Option<SyntaxToken> {
1698        support::token(&self.syntax, SyntaxKind::Lt)
1699    }
1700    pub fn le_token(&self) -> Option<SyntaxToken> {
1701        support::token(&self.syntax, SyntaxKind::Le)
1702    }
1703    pub fn gt_token(&self) -> Option<SyntaxToken> {
1704        support::token(&self.syntax, SyntaxKind::Gt)
1705    }
1706    pub fn ge_token(&self) -> Option<SyntaxToken> {
1707        support::token(&self.syntax, SyntaxKind::Ge)
1708    }
1709    pub fn plus_token(&self) -> Option<SyntaxToken> {
1710        support::token(&self.syntax, SyntaxKind::Plus)
1711    }
1712    pub fn minus_token(&self) -> Option<SyntaxToken> {
1713        support::token(&self.syntax, SyntaxKind::Minus)
1714    }
1715    pub fn star_token(&self) -> Option<SyntaxToken> {
1716        support::token(&self.syntax, SyntaxKind::Star)
1717    }
1718    pub fn slash_token(&self) -> Option<SyntaxToken> {
1719        support::token(&self.syntax, SyntaxKind::Slash)
1720    }
1721    pub fn percent_token(&self) -> Option<SyntaxToken> {
1722        support::token(&self.syntax, SyntaxKind::Percent)
1723    }
1724}
1725/// A `PrefixExpr` node (`family.ungram` rule `PrefixExpr`).
1726#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1727pub struct PrefixExpr {
1728    syntax: SyntaxNode,
1729}
1730impl AstNode for PrefixExpr {
1731    fn cast(syntax: SyntaxNode) -> Option<Self> {
1732        (syntax.kind() == SyntaxKind::PrefixExpr).then_some(Self { syntax })
1733    }
1734    fn syntax(&self) -> &SyntaxNode {
1735        &self.syntax
1736    }
1737}
1738impl PrefixExpr {
1739    pub fn operand(&self) -> Option<Expr> {
1740        support::child(&self.syntax)
1741    }
1742    pub fn bang_token(&self) -> Option<SyntaxToken> {
1743        support::token(&self.syntax, SyntaxKind::Bang)
1744    }
1745    pub fn minus_token(&self) -> Option<SyntaxToken> {
1746        support::token(&self.syntax, SyntaxKind::Minus)
1747    }
1748}
1749/// A `MemberExpr` node (`family.ungram` rule `MemberExpr`).
1750#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1751pub struct MemberExpr {
1752    syntax: SyntaxNode,
1753}
1754impl AstNode for MemberExpr {
1755    fn cast(syntax: SyntaxNode) -> Option<Self> {
1756        (syntax.kind() == SyntaxKind::MemberExpr).then_some(Self { syntax })
1757    }
1758    fn syntax(&self) -> &SyntaxNode {
1759        &self.syntax
1760    }
1761}
1762impl MemberExpr {
1763    pub fn base(&self) -> Option<Expr> {
1764        support::child(&self.syntax)
1765    }
1766    pub fn dot_token(&self) -> Option<SyntaxToken> {
1767        support::token(&self.syntax, SyntaxKind::Dot)
1768    }
1769    pub fn ident_token(&self) -> Option<SyntaxToken> {
1770        support::token(&self.syntax, SyntaxKind::Ident)
1771    }
1772}
1773/// A `PathExpr` node (`family.ungram` rule `PathExpr`).
1774#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1775pub struct PathExpr {
1776    syntax: SyntaxNode,
1777}
1778impl AstNode for PathExpr {
1779    fn cast(syntax: SyntaxNode) -> Option<Self> {
1780        (syntax.kind() == SyntaxKind::PathExpr).then_some(Self { syntax })
1781    }
1782    fn syntax(&self) -> &SyntaxNode {
1783        &self.syntax
1784    }
1785}
1786impl PathExpr {
1787    pub fn ident_token(&self) -> Option<SyntaxToken> {
1788        support::token(&self.syntax, SyntaxKind::Ident)
1789    }
1790}
1791/// A `ParenExpr` node (`family.ungram` rule `ParenExpr`).
1792#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1793pub struct ParenExpr {
1794    syntax: SyntaxNode,
1795}
1796impl AstNode for ParenExpr {
1797    fn cast(syntax: SyntaxNode) -> Option<Self> {
1798        (syntax.kind() == SyntaxKind::ParenExpr).then_some(Self { syntax })
1799    }
1800    fn syntax(&self) -> &SyntaxNode {
1801        &self.syntax
1802    }
1803}
1804impl ParenExpr {
1805    pub fn inner(&self) -> Option<Expr> {
1806        support::child(&self.syntax)
1807    }
1808    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1809        support::token(&self.syntax, SyntaxKind::LParen)
1810    }
1811    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1812        support::token(&self.syntax, SyntaxKind::RParen)
1813    }
1814}
1815/// A `LiteralExpr` node (`family.ungram` rule `LiteralExpr`).
1816#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1817pub struct LiteralExpr {
1818    syntax: SyntaxNode,
1819}
1820impl AstNode for LiteralExpr {
1821    fn cast(syntax: SyntaxNode) -> Option<Self> {
1822        (syntax.kind() == SyntaxKind::LiteralExpr).then_some(Self { syntax })
1823    }
1824    fn syntax(&self) -> &SyntaxNode {
1825        &self.syntax
1826    }
1827}
1828impl LiteralExpr {
1829    pub fn int_number_token(&self) -> Option<SyntaxToken> {
1830        support::token(&self.syntax, SyntaxKind::IntNumber)
1831    }
1832    pub fn float_number_token(&self) -> Option<SyntaxToken> {
1833        support::token(&self.syntax, SyntaxKind::FloatNumber)
1834    }
1835    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
1836        support::token(&self.syntax, SyntaxKind::String)
1837    }
1838    pub fn true_token(&self) -> Option<SyntaxToken> {
1839        support::token(&self.syntax, SyntaxKind::TrueKw)
1840    }
1841    pub fn false_token(&self) -> Option<SyntaxToken> {
1842        support::token(&self.syntax, SyntaxKind::FalseKw)
1843    }
1844    pub fn duration_token(&self) -> Option<SyntaxToken> {
1845        support::token(&self.syntax, SyntaxKind::Duration)
1846    }
1847}
1848/// An error-recovery node wrapping the tokens the parser skipped.
1849/// The one node kind with no rule in `family.ungram`.
1850#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1851pub struct ErrorNode {
1852    syntax: SyntaxNode,
1853}
1854impl AstNode for ErrorNode {
1855    fn cast(syntax: SyntaxNode) -> Option<Self> {
1856        (syntax.kind() == SyntaxKind::ErrorNode).then_some(Self { syntax })
1857    }
1858    fn syntax(&self) -> &SyntaxNode {
1859        &self.syntax
1860    }
1861}
ridl_syntax/ast/generated.rs

ridl_syntax/ast/
generated.rs
