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 enum_token(&self) -> Option<SyntaxToken> {
537        support::token(&self.syntax, SyntaxKind::EnumKw)
538    }
539    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
540        support::token(&self.syntax, SyntaxKind::LBrace)
541    }
542    pub fn comma_token(&self) -> Option<SyntaxToken> {
543        support::token(&self.syntax, SyntaxKind::Comma)
544    }
545    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
546        support::token(&self.syntax, SyntaxKind::RBrace)
547    }
548}
549/// A `EnumSetDef` node (`family.ungram` rule `EnumSetDef`).
550#[derive(Debug, Clone, PartialEq, Eq, Hash)]
551pub struct EnumSetDef {
552    syntax: SyntaxNode,
553}
554impl AstNode for EnumSetDef {
555    fn cast(syntax: SyntaxNode) -> Option<Self> {
556        (syntax.kind() == SyntaxKind::EnumSetDef).then_some(Self { syntax })
557    }
558    fn syntax(&self) -> &SyntaxNode {
559        &self.syntax
560    }
561}
562impl EnumSetDef {
563    pub fn name(&self) -> Option<Name> {
564        support::child(&self.syntax)
565    }
566    pub fn bits(&self) -> AstChildren<EnumSetBit> {
567        support::children(&self.syntax)
568    }
569    pub fn backing_ref(&self) -> Option<PathType> {
570        support::child(&self.syntax)
571    }
572    pub fn internal_token(&self) -> Option<SyntaxToken> {
573        support::token(&self.syntax, SyntaxKind::InternalKw)
574    }
575    pub fn error_token(&self) -> Option<SyntaxToken> {
576        support::token(&self.syntax, SyntaxKind::ErrorKw)
577    }
578    pub fn enumset_token(&self) -> Option<SyntaxToken> {
579        support::token(&self.syntax, SyntaxKind::EnumsetKw)
580    }
581    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
582        support::token(&self.syntax, SyntaxKind::LBrace)
583    }
584    pub fn comma_token(&self) -> Option<SyntaxToken> {
585        support::token(&self.syntax, SyntaxKind::Comma)
586    }
587    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
588        support::token(&self.syntax, SyntaxKind::RBrace)
589    }
590    pub fn colon_token(&self) -> Option<SyntaxToken> {
591        support::token(&self.syntax, SyntaxKind::Colon)
592    }
593}
594/// A `UnionDef` node (`family.ungram` rule `UnionDef`).
595#[derive(Debug, Clone, PartialEq, Eq, Hash)]
596pub struct UnionDef {
597    syntax: SyntaxNode,
598}
599impl AstNode for UnionDef {
600    fn cast(syntax: SyntaxNode) -> Option<Self> {
601        (syntax.kind() == SyntaxKind::UnionDef).then_some(Self { syntax })
602    }
603    fn syntax(&self) -> &SyntaxNode {
604        &self.syntax
605    }
606}
607impl UnionDef {
608    pub fn name(&self) -> Option<Name> {
609        support::child(&self.syntax)
610    }
611    pub fn arms(&self) -> AstChildren<UnionArm> {
612        support::children(&self.syntax)
613    }
614    pub fn reserved(&self) -> AstChildren<ReservedEntry> {
615        support::children(&self.syntax)
616    }
617    pub fn internal_token(&self) -> Option<SyntaxToken> {
618        support::token(&self.syntax, SyntaxKind::InternalKw)
619    }
620    pub fn error_token(&self) -> Option<SyntaxToken> {
621        support::token(&self.syntax, SyntaxKind::ErrorKw)
622    }
623    pub fn union_token(&self) -> Option<SyntaxToken> {
624        support::token(&self.syntax, SyntaxKind::UnionKw)
625    }
626    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
627        support::token(&self.syntax, SyntaxKind::LBrace)
628    }
629    pub fn comma_token(&self) -> Option<SyntaxToken> {
630        support::token(&self.syntax, SyntaxKind::Comma)
631    }
632    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
633        support::token(&self.syntax, SyntaxKind::RBrace)
634    }
635}
636/// A `Constraint` node (`family.ungram` rule `Constraint`).
637#[derive(Debug, Clone, PartialEq, Eq, Hash)]
638pub struct Constraint {
639    syntax: SyntaxNode,
640}
641impl AstNode for Constraint {
642    fn cast(syntax: SyntaxNode) -> Option<Self> {
643        (syntax.kind() == SyntaxKind::Constraint).then_some(Self { syntax })
644    }
645    fn syntax(&self) -> &SyntaxNode {
646        &self.syntax
647    }
648}
649impl Constraint {
650    pub fn len(&self) -> Option<Bound> {
651        support::child(&self.syntax)
652    }
653    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
654        support::token(&self.syntax, SyntaxKind::LBracket)
655    }
656    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
657        support::token(&self.syntax, SyntaxKind::DotDot)
658    }
659    pub fn step_token(&self) -> Option<SyntaxToken> {
660        support::token(&self.syntax, SyntaxKind::StepKw)
661    }
662    pub fn match_token(&self) -> Option<SyntaxToken> {
663        support::token(&self.syntax, SyntaxKind::MatchKw)
664    }
665    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
666        support::token(&self.syntax, SyntaxKind::RBracket)
667    }
668}
669/// A `InitValue` node (`family.ungram` rule `InitValue`).
670#[derive(Debug, Clone, PartialEq, Eq, Hash)]
671pub struct InitValue {
672    syntax: SyntaxNode,
673}
674impl AstNode for InitValue {
675    fn cast(syntax: SyntaxNode) -> Option<Self> {
676        (syntax.kind() == SyntaxKind::InitValue).then_some(Self { syntax })
677    }
678    fn syntax(&self) -> &SyntaxNode {
679        &self.syntax
680    }
681}
682impl InitValue {
683    pub fn literal(&self) -> Option<Literal> {
684        support::child(&self.syntax)
685    }
686    pub fn eq_token(&self) -> Option<SyntaxToken> {
687        support::token(&self.syntax, SyntaxKind::Eq)
688    }
689}
690/// A `PrimitiveType` node (`family.ungram` rule `PrimitiveType`).
691#[derive(Debug, Clone, PartialEq, Eq, Hash)]
692pub struct PrimitiveType {
693    syntax: SyntaxNode,
694}
695impl AstNode for PrimitiveType {
696    fn cast(syntax: SyntaxNode) -> Option<Self> {
697        (syntax.kind() == SyntaxKind::PrimitiveType).then_some(Self { syntax })
698    }
699    fn syntax(&self) -> &SyntaxNode {
700        &self.syntax
701    }
702}
703impl PrimitiveType {
704    pub fn constraint(&self) -> Option<Constraint> {
705        support::child(&self.syntax)
706    }
707    pub fn boolean_token(&self) -> Option<SyntaxToken> {
708        support::token(&self.syntax, SyntaxKind::BooleanKw)
709    }
710    pub fn integer_token(&self) -> Option<SyntaxToken> {
711        support::token(&self.syntax, SyntaxKind::IntegerKw)
712    }
713    pub fn float_token(&self) -> Option<SyntaxToken> {
714        support::token(&self.syntax, SyntaxKind::FloatKw)
715    }
716    pub fn string_token(&self) -> Option<SyntaxToken> {
717        support::token(&self.syntax, SyntaxKind::StringKw)
718    }
719    pub fn bytes_token(&self) -> Option<SyntaxToken> {
720        support::token(&self.syntax, SyntaxKind::BytesKw)
721    }
722}
723/// A `UnitExpr` node (`family.ungram` rule `UnitExpr`).
724#[derive(Debug, Clone, PartialEq, Eq, Hash)]
725pub struct UnitExpr {
726    syntax: SyntaxNode,
727}
728impl AstNode for UnitExpr {
729    fn cast(syntax: SyntaxNode) -> Option<Self> {
730        (syntax.kind() == SyntaxKind::UnitExpr).then_some(Self { syntax })
731    }
732    fn syntax(&self) -> &SyntaxNode {
733        &self.syntax
734    }
735}
736impl UnitExpr {
737    pub fn ident_token(&self) -> Option<SyntaxToken> {
738        support::token(&self.syntax, SyntaxKind::Ident)
739    }
740    pub fn slash_token(&self) -> Option<SyntaxToken> {
741        support::token(&self.syntax, SyntaxKind::Slash)
742    }
743    pub fn dot_token(&self) -> Option<SyntaxToken> {
744        support::token(&self.syntax, SyntaxKind::Dot)
745    }
746    pub fn percent_token(&self) -> Option<SyntaxToken> {
747        support::token(&self.syntax, SyntaxKind::Percent)
748    }
749}
750/// A `Literal` node (`family.ungram` rule `Literal`).
751#[derive(Debug, Clone, PartialEq, Eq, Hash)]
752pub struct Literal {
753    syntax: SyntaxNode,
754}
755impl AstNode for Literal {
756    fn cast(syntax: SyntaxNode) -> Option<Self> {
757        (syntax.kind() == SyntaxKind::Literal).then_some(Self { syntax })
758    }
759    fn syntax(&self) -> &SyntaxNode {
760        &self.syntax
761    }
762}
763impl Literal {
764    pub fn minus_token(&self) -> Option<SyntaxToken> {
765        support::token(&self.syntax, SyntaxKind::Minus)
766    }
767    pub fn int_number_token(&self) -> Option<SyntaxToken> {
768        support::token(&self.syntax, SyntaxKind::IntNumber)
769    }
770    pub fn float_number_token(&self) -> Option<SyntaxToken> {
771        support::token(&self.syntax, SyntaxKind::FloatNumber)
772    }
773    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
774        support::token(&self.syntax, SyntaxKind::String)
775    }
776    pub fn true_token(&self) -> Option<SyntaxToken> {
777        support::token(&self.syntax, SyntaxKind::TrueKw)
778    }
779    pub fn false_token(&self) -> Option<SyntaxToken> {
780        support::token(&self.syntax, SyntaxKind::FalseKw)
781    }
782    pub fn regex_token(&self) -> Option<SyntaxToken> {
783        support::token(&self.syntax, SyntaxKind::Regex)
784    }
785    pub fn ident_token(&self) -> Option<SyntaxToken> {
786        support::token(&self.syntax, SyntaxKind::Ident)
787    }
788}
789/// A `Bound` node (`family.ungram` rule `Bound`).
790#[derive(Debug, Clone, PartialEq, Eq, Hash)]
791pub struct Bound {
792    syntax: SyntaxNode,
793}
794impl AstNode for Bound {
795    fn cast(syntax: SyntaxNode) -> Option<Self> {
796        (syntax.kind() == SyntaxKind::Bound).then_some(Self { syntax })
797    }
798    fn syntax(&self) -> &SyntaxNode {
799        &self.syntax
800    }
801}
802impl Bound {
803    pub fn min(&self) -> Option<Literal> {
804        support::nth_child(&self.syntax, 0usize)
805    }
806    pub fn max(&self) -> Option<Literal> {
807        support::nth_child(&self.syntax, 1usize)
808    }
809    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
810        support::token(&self.syntax, SyntaxKind::DotDot)
811    }
812}
813/// A `PathType` node (`family.ungram` rule `PathType`).
814#[derive(Debug, Clone, PartialEq, Eq, Hash)]
815pub struct PathType {
816    syntax: SyntaxNode,
817}
818impl AstNode for PathType {
819    fn cast(syntax: SyntaxNode) -> Option<Self> {
820        (syntax.kind() == SyntaxKind::PathType).then_some(Self { syntax })
821    }
822    fn syntax(&self) -> &SyntaxNode {
823        &self.syntax
824    }
825}
826impl PathType {
827    pub fn qualified_name(&self) -> Option<QualifiedName> {
828        support::child(&self.syntax)
829    }
830}
831/// A `FieldDef` node (`family.ungram` rule `FieldDef`).
832#[derive(Debug, Clone, PartialEq, Eq, Hash)]
833pub struct FieldDef {
834    syntax: SyntaxNode,
835}
836impl AstNode for FieldDef {
837    fn cast(syntax: SyntaxNode) -> Option<Self> {
838        (syntax.kind() == SyntaxKind::FieldDef).then_some(Self { syntax })
839    }
840    fn syntax(&self) -> &SyntaxNode {
841        &self.syntax
842    }
843}
844impl FieldDef {
845    pub fn name(&self) -> Option<Name> {
846        support::child(&self.syntax)
847    }
848    pub fn field_type(&self) -> Option<FieldType> {
849        support::child(&self.syntax)
850    }
851    pub fn init_value(&self) -> Option<InitValue> {
852        support::child(&self.syntax)
853    }
854    pub fn colon_token(&self) -> Option<SyntaxToken> {
855        support::token(&self.syntax, SyntaxKind::Colon)
856    }
857}
858/// A `ReservedEntry` node (`family.ungram` rule `ReservedEntry`).
859#[derive(Debug, Clone, PartialEq, Eq, Hash)]
860pub struct ReservedEntry {
861    syntax: SyntaxNode,
862}
863impl AstNode for ReservedEntry {
864    fn cast(syntax: SyntaxNode) -> Option<Self> {
865        (syntax.kind() == SyntaxKind::ReservedEntry).then_some(Self { syntax })
866    }
867    fn syntax(&self) -> &SyntaxNode {
868        &self.syntax
869    }
870}
871impl ReservedEntry {
872    pub fn name(&self) -> Option<Name> {
873        support::child(&self.syntax)
874    }
875    pub fn literal(&self) -> Option<Literal> {
876        support::child(&self.syntax)
877    }
878    pub fn reserved_token(&self) -> Option<SyntaxToken> {
879        support::token(&self.syntax, SyntaxKind::ReservedKw)
880    }
881}
882/// A `TupleType` node (`family.ungram` rule `TupleType`).
883#[derive(Debug, Clone, PartialEq, Eq, Hash)]
884pub struct TupleType {
885    syntax: SyntaxNode,
886}
887impl AstNode for TupleType {
888    fn cast(syntax: SyntaxNode) -> Option<Self> {
889        (syntax.kind() == SyntaxKind::TupleType).then_some(Self { syntax })
890    }
891    fn syntax(&self) -> &SyntaxNode {
892        &self.syntax
893    }
894}
895impl TupleType {
896    pub fn fields(&self) -> AstChildren<TupleField> {
897        support::children(&self.syntax)
898    }
899    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
900        support::token(&self.syntax, SyntaxKind::LParen)
901    }
902    pub fn comma_token(&self) -> Option<SyntaxToken> {
903        support::token(&self.syntax, SyntaxKind::Comma)
904    }
905    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
906        support::token(&self.syntax, SyntaxKind::RParen)
907    }
908}
909/// A `ArrayType` node (`family.ungram` rule `ArrayType`).
910#[derive(Debug, Clone, PartialEq, Eq, Hash)]
911pub struct ArrayType {
912    syntax: SyntaxNode,
913}
914impl AstNode for ArrayType {
915    fn cast(syntax: SyntaxNode) -> Option<Self> {
916        (syntax.kind() == SyntaxKind::ArrayType).then_some(Self { syntax })
917    }
918    fn syntax(&self) -> &SyntaxNode {
919        &self.syntax
920    }
921}
922impl ArrayType {
923    pub fn element(&self) -> Option<FieldType> {
924        support::child(&self.syntax)
925    }
926    pub fn bound(&self) -> Option<Bound> {
927        support::child(&self.syntax)
928    }
929    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
930        support::token(&self.syntax, SyntaxKind::LBracket)
931    }
932    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
933        support::token(&self.syntax, SyntaxKind::Semicolon)
934    }
935    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
936        support::token(&self.syntax, SyntaxKind::RBracket)
937    }
938}
939/// A `MapType` node (`family.ungram` rule `MapType`).
940#[derive(Debug, Clone, PartialEq, Eq, Hash)]
941pub struct MapType {
942    syntax: SyntaxNode,
943}
944impl AstNode for MapType {
945    fn cast(syntax: SyntaxNode) -> Option<Self> {
946        (syntax.kind() == SyntaxKind::MapType).then_some(Self { syntax })
947    }
948    fn syntax(&self) -> &SyntaxNode {
949        &self.syntax
950    }
951}
952impl MapType {
953    pub fn key(&self) -> Option<FieldType> {
954        support::nth_child(&self.syntax, 0usize)
955    }
956    pub fn value(&self) -> Option<FieldType> {
957        support::nth_child(&self.syntax, 1usize)
958    }
959    pub fn bound(&self) -> Option<Bound> {
960        support::child(&self.syntax)
961    }
962    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
963        support::token(&self.syntax, SyntaxKind::LBracket)
964    }
965    pub fn colon_token(&self) -> Option<SyntaxToken> {
966        support::token(&self.syntax, SyntaxKind::Colon)
967    }
968    pub fn semicolon_token(&self) -> Option<SyntaxToken> {
969        support::token(&self.syntax, SyntaxKind::Semicolon)
970    }
971    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
972        support::token(&self.syntax, SyntaxKind::RBracket)
973    }
974}
975/// A `OptionalType` node (`family.ungram` rule `OptionalType`).
976#[derive(Debug, Clone, PartialEq, Eq, Hash)]
977pub struct OptionalType {
978    syntax: SyntaxNode,
979}
980impl AstNode for OptionalType {
981    fn cast(syntax: SyntaxNode) -> Option<Self> {
982        (syntax.kind() == SyntaxKind::OptionalType).then_some(Self { syntax })
983    }
984    fn syntax(&self) -> &SyntaxNode {
985        &self.syntax
986    }
987}
988impl OptionalType {
989    pub fn field_type(&self) -> Option<FieldType> {
990        support::child(&self.syntax)
991    }
992    pub fn question_token(&self) -> Option<SyntaxToken> {
993        support::token(&self.syntax, SyntaxKind::Question)
994    }
995}
996/// A `TupleField` node (`family.ungram` rule `TupleField`).
997#[derive(Debug, Clone, PartialEq, Eq, Hash)]
998pub struct TupleField {
999    syntax: SyntaxNode,
1000}
1001impl AstNode for TupleField {
1002    fn cast(syntax: SyntaxNode) -> Option<Self> {
1003        (syntax.kind() == SyntaxKind::TupleField).then_some(Self { syntax })
1004    }
1005    fn syntax(&self) -> &SyntaxNode {
1006        &self.syntax
1007    }
1008}
1009impl TupleField {
1010    pub fn name(&self) -> Option<Name> {
1011        support::child(&self.syntax)
1012    }
1013    pub fn field_type(&self) -> Option<FieldType> {
1014        support::child(&self.syntax)
1015    }
1016    pub fn colon_token(&self) -> Option<SyntaxToken> {
1017        support::token(&self.syntax, SyntaxKind::Colon)
1018    }
1019}
1020/// A `EnumValue` node (`family.ungram` rule `EnumValue`).
1021#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1022pub struct EnumValue {
1023    syntax: SyntaxNode,
1024}
1025impl AstNode for EnumValue {
1026    fn cast(syntax: SyntaxNode) -> Option<Self> {
1027        (syntax.kind() == SyntaxKind::EnumValue).then_some(Self { syntax })
1028    }
1029    fn syntax(&self) -> &SyntaxNode {
1030        &self.syntax
1031    }
1032}
1033impl EnumValue {
1034    pub fn name(&self) -> Option<Name> {
1035        support::child(&self.syntax)
1036    }
1037    pub fn value(&self) -> Option<Literal> {
1038        support::child(&self.syntax)
1039    }
1040    pub fn eq_token(&self) -> Option<SyntaxToken> {
1041        support::token(&self.syntax, SyntaxKind::Eq)
1042    }
1043}
1044/// A `EnumSetBit` node (`family.ungram` rule `EnumSetBit`).
1045#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1046pub struct EnumSetBit {
1047    syntax: SyntaxNode,
1048}
1049impl AstNode for EnumSetBit {
1050    fn cast(syntax: SyntaxNode) -> Option<Self> {
1051        (syntax.kind() == SyntaxKind::EnumSetBit).then_some(Self { syntax })
1052    }
1053    fn syntax(&self) -> &SyntaxNode {
1054        &self.syntax
1055    }
1056}
1057impl EnumSetBit {
1058    pub fn name(&self) -> Option<Name> {
1059        support::child(&self.syntax)
1060    }
1061    pub fn value(&self) -> Option<Literal> {
1062        support::child(&self.syntax)
1063    }
1064    pub fn eq_token(&self) -> Option<SyntaxToken> {
1065        support::token(&self.syntax, SyntaxKind::Eq)
1066    }
1067}
1068/// A `UnionArm` node (`family.ungram` rule `UnionArm`).
1069#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1070pub struct UnionArm {
1071    syntax: SyntaxNode,
1072}
1073impl AstNode for UnionArm {
1074    fn cast(syntax: SyntaxNode) -> Option<Self> {
1075        (syntax.kind() == SyntaxKind::UnionArm).then_some(Self { syntax })
1076    }
1077    fn syntax(&self) -> &SyntaxNode {
1078        &self.syntax
1079    }
1080}
1081impl UnionArm {
1082    pub fn name(&self) -> Option<Name> {
1083        support::child(&self.syntax)
1084    }
1085    pub fn type_ref(&self) -> Option<PathType> {
1086        support::child(&self.syntax)
1087    }
1088    pub fn colon_token(&self) -> Option<SyntaxToken> {
1089        support::token(&self.syntax, SyntaxKind::Colon)
1090    }
1091}
1092/// A `SignalDef` node (`family.ungram` rule `SignalDef`).
1093#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1094pub struct SignalDef {
1095    syntax: SyntaxNode,
1096}
1097impl AstNode for SignalDef {
1098    fn cast(syntax: SyntaxNode) -> Option<Self> {
1099        (syntax.kind() == SyntaxKind::SignalDef).then_some(Self { syntax })
1100    }
1101    fn syntax(&self) -> &SyntaxNode {
1102        &self.syntax
1103    }
1104}
1105impl SignalDef {
1106    pub fn name(&self) -> Option<Name> {
1107        support::child(&self.syntax)
1108    }
1109    pub fn payload(&self) -> Option<FieldType> {
1110        support::child(&self.syntax)
1111    }
1112    pub fn init_value(&self) -> Option<InitValue> {
1113        support::child(&self.syntax)
1114    }
1115    pub fn timing(&self) -> Option<Timing> {
1116        support::child(&self.syntax)
1117    }
1118    pub fn signal_token(&self) -> Option<SyntaxToken> {
1119        support::token(&self.syntax, SyntaxKind::SignalKw)
1120    }
1121    pub fn colon_token(&self) -> Option<SyntaxToken> {
1122        support::token(&self.syntax, SyntaxKind::Colon)
1123    }
1124}
1125/// A `EventDef` node (`family.ungram` rule `EventDef`).
1126#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1127pub struct EventDef {
1128    syntax: SyntaxNode,
1129}
1130impl AstNode for EventDef {
1131    fn cast(syntax: SyntaxNode) -> Option<Self> {
1132        (syntax.kind() == SyntaxKind::EventDef).then_some(Self { syntax })
1133    }
1134    fn syntax(&self) -> &SyntaxNode {
1135        &self.syntax
1136    }
1137}
1138impl EventDef {
1139    pub fn name(&self) -> Option<Name> {
1140        support::child(&self.syntax)
1141    }
1142    pub fn payload(&self) -> Option<FieldType> {
1143        support::child(&self.syntax)
1144    }
1145    pub fn timing(&self) -> Option<Timing> {
1146        support::child(&self.syntax)
1147    }
1148    pub fn event_token(&self) -> Option<SyntaxToken> {
1149        support::token(&self.syntax, SyntaxKind::EventKw)
1150    }
1151    pub fn colon_token(&self) -> Option<SyntaxToken> {
1152        support::token(&self.syntax, SyntaxKind::Colon)
1153    }
1154}
1155/// A `CommandDef` node (`family.ungram` rule `CommandDef`).
1156#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1157pub struct CommandDef {
1158    syntax: SyntaxNode,
1159}
1160impl AstNode for CommandDef {
1161    fn cast(syntax: SyntaxNode) -> Option<Self> {
1162        (syntax.kind() == SyntaxKind::CommandDef).then_some(Self { syntax })
1163    }
1164    fn syntax(&self) -> &SyntaxNode {
1165        &self.syntax
1166    }
1167}
1168impl CommandDef {
1169    pub fn name(&self) -> Option<Name> {
1170        support::child(&self.syntax)
1171    }
1172    pub fn params(&self) -> Option<ParamList> {
1173        support::child(&self.syntax)
1174    }
1175    pub fn return_type(&self) -> Option<ReturnType> {
1176        support::child(&self.syntax)
1177    }
1178    pub fn attr_block(&self) -> Option<AttrBlock> {
1179        support::child(&self.syntax)
1180    }
1181    pub fn timing(&self) -> Option<Timing> {
1182        support::child(&self.syntax)
1183    }
1184    pub fn command_token(&self) -> Option<SyntaxToken> {
1185        support::token(&self.syntax, SyntaxKind::CommandKw)
1186    }
1187    pub fn colon_token(&self) -> Option<SyntaxToken> {
1188        support::token(&self.syntax, SyntaxKind::Colon)
1189    }
1190}
1191/// A `QueryDef` node (`family.ungram` rule `QueryDef`).
1192#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1193pub struct QueryDef {
1194    syntax: SyntaxNode,
1195}
1196impl AstNode for QueryDef {
1197    fn cast(syntax: SyntaxNode) -> Option<Self> {
1198        (syntax.kind() == SyntaxKind::QueryDef).then_some(Self { syntax })
1199    }
1200    fn syntax(&self) -> &SyntaxNode {
1201        &self.syntax
1202    }
1203}
1204impl QueryDef {
1205    pub fn name(&self) -> Option<Name> {
1206        support::child(&self.syntax)
1207    }
1208    pub fn params(&self) -> Option<ParamList> {
1209        support::child(&self.syntax)
1210    }
1211    pub fn return_type(&self) -> Option<ReturnType> {
1212        support::child(&self.syntax)
1213    }
1214    pub fn attr_block(&self) -> Option<AttrBlock> {
1215        support::child(&self.syntax)
1216    }
1217    pub fn timing(&self) -> Option<Timing> {
1218        support::child(&self.syntax)
1219    }
1220    pub fn query_token(&self) -> Option<SyntaxToken> {
1221        support::token(&self.syntax, SyntaxKind::QueryKw)
1222    }
1223    pub fn colon_token(&self) -> Option<SyntaxToken> {
1224        support::token(&self.syntax, SyntaxKind::Colon)
1225    }
1226}
1227/// A `FixedDef` node (`family.ungram` rule `FixedDef`).
1228#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1229pub struct FixedDef {
1230    syntax: SyntaxNode,
1231}
1232impl AstNode for FixedDef {
1233    fn cast(syntax: SyntaxNode) -> Option<Self> {
1234        (syntax.kind() == SyntaxKind::FixedDef).then_some(Self { syntax })
1235    }
1236    fn syntax(&self) -> &SyntaxNode {
1237        &self.syntax
1238    }
1239}
1240impl FixedDef {
1241    pub fn name(&self) -> Option<Name> {
1242        support::child(&self.syntax)
1243    }
1244    pub fn payload(&self) -> Option<FieldType> {
1245        support::child(&self.syntax)
1246    }
1247    pub fn timing(&self) -> Option<Timing> {
1248        support::child(&self.syntax)
1249    }
1250    pub fn attr_block(&self) -> Option<AttrBlock> {
1251        support::child(&self.syntax)
1252    }
1253    pub fn fixed_token(&self) -> Option<SyntaxToken> {
1254        support::token(&self.syntax, SyntaxKind::FixedKw)
1255    }
1256    pub fn colon_token(&self) -> Option<SyntaxToken> {
1257        support::token(&self.syntax, SyntaxKind::Colon)
1258    }
1259}
1260/// A `Timing` node (`family.ungram` rule `Timing`).
1261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1262pub struct Timing {
1263    syntax: SyntaxNode,
1264}
1265impl AstNode for Timing {
1266    fn cast(syntax: SyntaxNode) -> Option<Self> {
1267        (syntax.kind() == SyntaxKind::Timing).then_some(Self { syntax })
1268    }
1269    fn syntax(&self) -> &SyntaxNode {
1270        &self.syntax
1271    }
1272}
1273impl Timing {
1274    pub fn range(&self) -> Option<TimingRange> {
1275        support::child(&self.syntax)
1276    }
1277    pub fn at_token(&self) -> Option<SyntaxToken> {
1278        support::token(&self.syntax, SyntaxKind::At)
1279    }
1280    pub fn duration_token(&self) -> Option<SyntaxToken> {
1281        support::token(&self.syntax, SyntaxKind::Duration)
1282    }
1283    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
1284        support::token(&self.syntax, SyntaxKind::LBracket)
1285    }
1286    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
1287        support::token(&self.syntax, SyntaxKind::RBracket)
1288    }
1289}
1290/// A `ParamList` node (`family.ungram` rule `ParamList`).
1291#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1292pub struct ParamList {
1293    syntax: SyntaxNode,
1294}
1295impl AstNode for ParamList {
1296    fn cast(syntax: SyntaxNode) -> Option<Self> {
1297        (syntax.kind() == SyntaxKind::ParamList).then_some(Self { syntax })
1298    }
1299    fn syntax(&self) -> &SyntaxNode {
1300        &self.syntax
1301    }
1302}
1303impl ParamList {
1304    pub fn params(&self) -> AstChildren<Param> {
1305        support::children(&self.syntax)
1306    }
1307    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1308        support::token(&self.syntax, SyntaxKind::LParen)
1309    }
1310    pub fn comma_token(&self) -> Option<SyntaxToken> {
1311        support::token(&self.syntax, SyntaxKind::Comma)
1312    }
1313    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1314        support::token(&self.syntax, SyntaxKind::RParen)
1315    }
1316}
1317/// A `ReturnType` node (`family.ungram` rule `ReturnType`).
1318#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1319pub struct ReturnType {
1320    syntax: SyntaxNode,
1321}
1322impl AstNode for ReturnType {
1323    fn cast(syntax: SyntaxNode) -> Option<Self> {
1324        (syntax.kind() == SyntaxKind::ReturnType).then_some(Self { syntax })
1325    }
1326    fn syntax(&self) -> &SyntaxNode {
1327        &self.syntax
1328    }
1329}
1330impl ReturnType {
1331    pub fn type_ref(&self) -> Option<PathType> {
1332        support::child(&self.syntax)
1333    }
1334    pub fn tuple_type(&self) -> Option<TupleType> {
1335        support::child(&self.syntax)
1336    }
1337    pub fn stream_type(&self) -> Option<StreamType> {
1338        support::child(&self.syntax)
1339    }
1340    pub fn fallible_type(&self) -> Option<FallibleType> {
1341        support::child(&self.syntax)
1342    }
1343}
1344/// A `AttrBlock` node (`family.ungram` rule `AttrBlock`).
1345#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1346pub struct AttrBlock {
1347    syntax: SyntaxNode,
1348}
1349impl AstNode for AttrBlock {
1350    fn cast(syntax: SyntaxNode) -> Option<Self> {
1351        (syntax.kind() == SyntaxKind::AttrBlock).then_some(Self { syntax })
1352    }
1353    fn syntax(&self) -> &SyntaxNode {
1354        &self.syntax
1355    }
1356}
1357impl AttrBlock {
1358    pub fn attributes(&self) -> AstChildren<Attribute> {
1359        support::children(&self.syntax)
1360    }
1361    pub fn l_bracket_token(&self) -> Option<SyntaxToken> {
1362        support::token(&self.syntax, SyntaxKind::LBracket)
1363    }
1364    pub fn comma_token(&self) -> Option<SyntaxToken> {
1365        support::token(&self.syntax, SyntaxKind::Comma)
1366    }
1367    pub fn r_bracket_token(&self) -> Option<SyntaxToken> {
1368        support::token(&self.syntax, SyntaxKind::RBracket)
1369    }
1370}
1371/// A `Param` node (`family.ungram` rule `Param`).
1372#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1373pub struct Param {
1374    syntax: SyntaxNode,
1375}
1376impl AstNode for Param {
1377    fn cast(syntax: SyntaxNode) -> Option<Self> {
1378        (syntax.kind() == SyntaxKind::Param).then_some(Self { syntax })
1379    }
1380    fn syntax(&self) -> &SyntaxNode {
1381        &self.syntax
1382    }
1383}
1384impl Param {
1385    pub fn name(&self) -> Option<Name> {
1386        support::child(&self.syntax)
1387    }
1388    pub fn param_type(&self) -> Option<ParamType> {
1389        support::child(&self.syntax)
1390    }
1391    pub fn colon_token(&self) -> Option<SyntaxToken> {
1392        support::token(&self.syntax, SyntaxKind::Colon)
1393    }
1394}
1395/// A `StreamType` node (`family.ungram` rule `StreamType`).
1396#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1397pub struct StreamType {
1398    syntax: SyntaxNode,
1399}
1400impl AstNode for StreamType {
1401    fn cast(syntax: SyntaxNode) -> Option<Self> {
1402        (syntax.kind() == SyntaxKind::StreamType).then_some(Self { syntax })
1403    }
1404    fn syntax(&self) -> &SyntaxNode {
1405        &self.syntax
1406    }
1407}
1408impl StreamType {
1409    pub fn element_type(&self) -> Option<PathType> {
1410        support::child(&self.syntax)
1411    }
1412    pub fn lt_token(&self) -> Option<SyntaxToken> {
1413        support::token(&self.syntax, SyntaxKind::Lt)
1414    }
1415    pub fn string_token(&self) -> Option<SyntaxToken> {
1416        support::token(&self.syntax, SyntaxKind::StringKw)
1417    }
1418    pub fn bytes_token(&self) -> Option<SyntaxToken> {
1419        support::token(&self.syntax, SyntaxKind::BytesKw)
1420    }
1421    pub fn gt_token(&self) -> Option<SyntaxToken> {
1422        support::token(&self.syntax, SyntaxKind::Gt)
1423    }
1424}
1425/// A `FallibleType` node (`family.ungram` rule `FallibleType`).
1426#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1427pub struct FallibleType {
1428    syntax: SyntaxNode,
1429}
1430impl AstNode for FallibleType {
1431    fn cast(syntax: SyntaxNode) -> Option<Self> {
1432        (syntax.kind() == SyntaxKind::FallibleType).then_some(Self { syntax })
1433    }
1434    fn syntax(&self) -> &SyntaxNode {
1435        &self.syntax
1436    }
1437}
1438impl FallibleType {
1439    pub fn ok(&self) -> Option<PathType> {
1440        support::nth_child(&self.syntax, 0usize)
1441    }
1442    pub fn err(&self) -> Option<PathType> {
1443        support::nth_child(&self.syntax, 1usize)
1444    }
1445    pub fn pipe_token(&self) -> Option<SyntaxToken> {
1446        support::token(&self.syntax, SyntaxKind::Pipe)
1447    }
1448}
1449/// A `TimingRange` node (`family.ungram` rule `TimingRange`).
1450#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1451pub struct TimingRange {
1452    syntax: SyntaxNode,
1453}
1454impl AstNode for TimingRange {
1455    fn cast(syntax: SyntaxNode) -> Option<Self> {
1456        (syntax.kind() == SyntaxKind::TimingRange).then_some(Self { syntax })
1457    }
1458    fn syntax(&self) -> &SyntaxNode {
1459        &self.syntax
1460    }
1461}
1462impl TimingRange {
1463    pub fn duration_token(&self) -> Option<SyntaxToken> {
1464        support::token(&self.syntax, SyntaxKind::Duration)
1465    }
1466    pub fn dotdot_token(&self) -> Option<SyntaxToken> {
1467        support::token(&self.syntax, SyntaxKind::DotDot)
1468    }
1469}
1470/// A `DottedName` node (`family.ungram` rule `DottedName`).
1471#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1472pub struct DottedName {
1473    syntax: SyntaxNode,
1474}
1475impl AstNode for DottedName {
1476    fn cast(syntax: SyntaxNode) -> Option<Self> {
1477        (syntax.kind() == SyntaxKind::DottedName).then_some(Self { syntax })
1478    }
1479    fn syntax(&self) -> &SyntaxNode {
1480        &self.syntax
1481    }
1482}
1483impl DottedName {
1484    pub fn ident_token(&self) -> Option<SyntaxToken> {
1485        support::token(&self.syntax, SyntaxKind::Ident)
1486    }
1487    pub fn dot_token(&self) -> Option<SyntaxToken> {
1488        support::token(&self.syntax, SyntaxKind::Dot)
1489    }
1490}
1491/// A `Attribute` node (`family.ungram` rule `Attribute`).
1492#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1493pub struct Attribute {
1494    syntax: SyntaxNode,
1495}
1496impl AstNode for Attribute {
1497    fn cast(syntax: SyntaxNode) -> Option<Self> {
1498        (syntax.kind() == SyntaxKind::Attribute).then_some(Self { syntax })
1499    }
1500    fn syntax(&self) -> &SyntaxNode {
1501        &self.syntax
1502    }
1503}
1504impl Attribute {
1505    pub fn key(&self) -> Option<Name> {
1506        support::child(&self.syntax)
1507    }
1508    pub fn value(&self) -> Option<AttrValue> {
1509        support::child(&self.syntax)
1510    }
1511    pub fn expr(&self) -> Option<Expr> {
1512        support::child(&self.syntax)
1513    }
1514    pub fn dot_token(&self) -> Option<SyntaxToken> {
1515        support::token(&self.syntax, SyntaxKind::Dot)
1516    }
1517    pub fn eq_token(&self) -> Option<SyntaxToken> {
1518        support::token(&self.syntax, SyntaxKind::Eq)
1519    }
1520    pub fn require_token(&self) -> Option<SyntaxToken> {
1521        support::token(&self.syntax, SyntaxKind::RequireKw)
1522    }
1523    pub fn ensure_token(&self) -> Option<SyntaxToken> {
1524        support::token(&self.syntax, SyntaxKind::EnsureKw)
1525    }
1526}
1527/// A `AttrValue` node (`family.ungram` rule `AttrValue`).
1528#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1529pub struct AttrValue {
1530    syntax: SyntaxNode,
1531}
1532impl AstNode for AttrValue {
1533    fn cast(syntax: SyntaxNode) -> Option<Self> {
1534        (syntax.kind() == SyntaxKind::AttrValue).then_some(Self { syntax })
1535    }
1536    fn syntax(&self) -> &SyntaxNode {
1537        &self.syntax
1538    }
1539}
1540impl AttrValue {
1541    pub fn literal(&self) -> Option<Literal> {
1542        support::child(&self.syntax)
1543    }
1544    pub fn values(&self) -> AstChildren<AttrValue> {
1545        support::children(&self.syntax)
1546    }
1547    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1548        support::token(&self.syntax, SyntaxKind::LParen)
1549    }
1550    pub fn comma_token(&self) -> Option<SyntaxToken> {
1551        support::token(&self.syntax, SyntaxKind::Comma)
1552    }
1553    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1554        support::token(&self.syntax, SyntaxKind::RParen)
1555    }
1556}
1557/// A `MemberLine` node (`family.ungram` rule `MemberLine`).
1558#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1559pub struct MemberLine {
1560    syntax: SyntaxNode,
1561}
1562impl AstNode for MemberLine {
1563    fn cast(syntax: SyntaxNode) -> Option<Self> {
1564        (syntax.kind() == SyntaxKind::MemberLine).then_some(Self { syntax })
1565    }
1566    fn syntax(&self) -> &SyntaxNode {
1567        &self.syntax
1568    }
1569}
1570impl MemberLine {
1571    pub fn reference(&self) -> Option<Reference> {
1572        support::child(&self.syntax)
1573    }
1574    pub fn attr_block(&self) -> Option<AttrBlock> {
1575        support::child(&self.syntax)
1576    }
1577}
1578/// A `ComponentLine` node (`family.ungram` rule `ComponentLine`).
1579#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1580pub struct ComponentLine {
1581    syntax: SyntaxNode,
1582}
1583impl AstNode for ComponentLine {
1584    fn cast(syntax: SyntaxNode) -> Option<Self> {
1585        (syntax.kind() == SyntaxKind::ComponentLine).then_some(Self { syntax })
1586    }
1587    fn syntax(&self) -> &SyntaxNode {
1588        &self.syntax
1589    }
1590}
1591impl ComponentLine {
1592    pub fn reference(&self) -> Option<Reference> {
1593        support::child(&self.syntax)
1594    }
1595    pub fn attr_block(&self) -> Option<AttrBlock> {
1596        support::child(&self.syntax)
1597    }
1598    pub fn offers_token(&self) -> Option<SyntaxToken> {
1599        support::token(&self.syntax, SyntaxKind::OffersKw)
1600    }
1601    pub fn requires_token(&self) -> Option<SyntaxToken> {
1602        support::token(&self.syntax, SyntaxKind::RequiresKw)
1603    }
1604}
1605/// A `Reference` node (`family.ungram` rule `Reference`).
1606#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1607pub struct Reference {
1608    syntax: SyntaxNode,
1609}
1610impl AstNode for Reference {
1611    fn cast(syntax: SyntaxNode) -> Option<Self> {
1612        (syntax.kind() == SyntaxKind::Reference).then_some(Self { syntax })
1613    }
1614    fn syntax(&self) -> &SyntaxNode {
1615        &self.syntax
1616    }
1617}
1618impl Reference {
1619    pub fn qualified_name(&self) -> Option<QualifiedName> {
1620        support::child(&self.syntax)
1621    }
1622}
1623/// A `MachineDef` node (`family.ungram` rule `MachineDef`).
1624#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1625pub struct MachineDef {
1626    syntax: SyntaxNode,
1627}
1628impl AstNode for MachineDef {
1629    fn cast(syntax: SyntaxNode) -> Option<Self> {
1630        (syntax.kind() == SyntaxKind::MachineDef).then_some(Self { syntax })
1631    }
1632    fn syntax(&self) -> &SyntaxNode {
1633        &self.syntax
1634    }
1635}
1636impl MachineDef {
1637    pub fn name(&self) -> Option<Name> {
1638        support::child(&self.syntax)
1639    }
1640    pub fn attr_block(&self) -> Option<AttrBlock> {
1641        support::child(&self.syntax)
1642    }
1643    pub fn lines(&self) -> AstChildren<MemberLine> {
1644        support::children(&self.syntax)
1645    }
1646    pub fn machine_token(&self) -> Option<SyntaxToken> {
1647        support::token(&self.syntax, SyntaxKind::MachineKw)
1648    }
1649    pub fn l_brace_token(&self) -> Option<SyntaxToken> {
1650        support::token(&self.syntax, SyntaxKind::LBrace)
1651    }
1652    pub fn comma_token(&self) -> Option<SyntaxToken> {
1653        support::token(&self.syntax, SyntaxKind::Comma)
1654    }
1655    pub fn r_brace_token(&self) -> Option<SyntaxToken> {
1656        support::token(&self.syntax, SyntaxKind::RBrace)
1657    }
1658}
1659/// A `BinaryExpr` node (`family.ungram` rule `BinaryExpr`).
1660#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1661pub struct BinaryExpr {
1662    syntax: SyntaxNode,
1663}
1664impl AstNode for BinaryExpr {
1665    fn cast(syntax: SyntaxNode) -> Option<Self> {
1666        (syntax.kind() == SyntaxKind::BinaryExpr).then_some(Self { syntax })
1667    }
1668    fn syntax(&self) -> &SyntaxNode {
1669        &self.syntax
1670    }
1671}
1672impl BinaryExpr {
1673    pub fn lhs(&self) -> Option<Expr> {
1674        support::nth_child(&self.syntax, 0usize)
1675    }
1676    pub fn rhs(&self) -> Option<Expr> {
1677        support::nth_child(&self.syntax, 1usize)
1678    }
1679    pub fn pipepipe_token(&self) -> Option<SyntaxToken> {
1680        support::token(&self.syntax, SyntaxKind::PipePipe)
1681    }
1682    pub fn ampamp_token(&self) -> Option<SyntaxToken> {
1683        support::token(&self.syntax, SyntaxKind::AmpAmp)
1684    }
1685    pub fn eqeq_token(&self) -> Option<SyntaxToken> {
1686        support::token(&self.syntax, SyntaxKind::EqEq)
1687    }
1688    pub fn neq_token(&self) -> Option<SyntaxToken> {
1689        support::token(&self.syntax, SyntaxKind::Neq)
1690    }
1691    pub fn lt_token(&self) -> Option<SyntaxToken> {
1692        support::token(&self.syntax, SyntaxKind::Lt)
1693    }
1694    pub fn le_token(&self) -> Option<SyntaxToken> {
1695        support::token(&self.syntax, SyntaxKind::Le)
1696    }
1697    pub fn gt_token(&self) -> Option<SyntaxToken> {
1698        support::token(&self.syntax, SyntaxKind::Gt)
1699    }
1700    pub fn ge_token(&self) -> Option<SyntaxToken> {
1701        support::token(&self.syntax, SyntaxKind::Ge)
1702    }
1703    pub fn plus_token(&self) -> Option<SyntaxToken> {
1704        support::token(&self.syntax, SyntaxKind::Plus)
1705    }
1706    pub fn minus_token(&self) -> Option<SyntaxToken> {
1707        support::token(&self.syntax, SyntaxKind::Minus)
1708    }
1709    pub fn star_token(&self) -> Option<SyntaxToken> {
1710        support::token(&self.syntax, SyntaxKind::Star)
1711    }
1712    pub fn slash_token(&self) -> Option<SyntaxToken> {
1713        support::token(&self.syntax, SyntaxKind::Slash)
1714    }
1715    pub fn percent_token(&self) -> Option<SyntaxToken> {
1716        support::token(&self.syntax, SyntaxKind::Percent)
1717    }
1718}
1719/// A `PrefixExpr` node (`family.ungram` rule `PrefixExpr`).
1720#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1721pub struct PrefixExpr {
1722    syntax: SyntaxNode,
1723}
1724impl AstNode for PrefixExpr {
1725    fn cast(syntax: SyntaxNode) -> Option<Self> {
1726        (syntax.kind() == SyntaxKind::PrefixExpr).then_some(Self { syntax })
1727    }
1728    fn syntax(&self) -> &SyntaxNode {
1729        &self.syntax
1730    }
1731}
1732impl PrefixExpr {
1733    pub fn operand(&self) -> Option<Expr> {
1734        support::child(&self.syntax)
1735    }
1736    pub fn bang_token(&self) -> Option<SyntaxToken> {
1737        support::token(&self.syntax, SyntaxKind::Bang)
1738    }
1739    pub fn minus_token(&self) -> Option<SyntaxToken> {
1740        support::token(&self.syntax, SyntaxKind::Minus)
1741    }
1742}
1743/// A `MemberExpr` node (`family.ungram` rule `MemberExpr`).
1744#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1745pub struct MemberExpr {
1746    syntax: SyntaxNode,
1747}
1748impl AstNode for MemberExpr {
1749    fn cast(syntax: SyntaxNode) -> Option<Self> {
1750        (syntax.kind() == SyntaxKind::MemberExpr).then_some(Self { syntax })
1751    }
1752    fn syntax(&self) -> &SyntaxNode {
1753        &self.syntax
1754    }
1755}
1756impl MemberExpr {
1757    pub fn base(&self) -> Option<Expr> {
1758        support::child(&self.syntax)
1759    }
1760    pub fn dot_token(&self) -> Option<SyntaxToken> {
1761        support::token(&self.syntax, SyntaxKind::Dot)
1762    }
1763    pub fn ident_token(&self) -> Option<SyntaxToken> {
1764        support::token(&self.syntax, SyntaxKind::Ident)
1765    }
1766}
1767/// A `PathExpr` node (`family.ungram` rule `PathExpr`).
1768#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1769pub struct PathExpr {
1770    syntax: SyntaxNode,
1771}
1772impl AstNode for PathExpr {
1773    fn cast(syntax: SyntaxNode) -> Option<Self> {
1774        (syntax.kind() == SyntaxKind::PathExpr).then_some(Self { syntax })
1775    }
1776    fn syntax(&self) -> &SyntaxNode {
1777        &self.syntax
1778    }
1779}
1780impl PathExpr {
1781    pub fn ident_token(&self) -> Option<SyntaxToken> {
1782        support::token(&self.syntax, SyntaxKind::Ident)
1783    }
1784}
1785/// A `ParenExpr` node (`family.ungram` rule `ParenExpr`).
1786#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1787pub struct ParenExpr {
1788    syntax: SyntaxNode,
1789}
1790impl AstNode for ParenExpr {
1791    fn cast(syntax: SyntaxNode) -> Option<Self> {
1792        (syntax.kind() == SyntaxKind::ParenExpr).then_some(Self { syntax })
1793    }
1794    fn syntax(&self) -> &SyntaxNode {
1795        &self.syntax
1796    }
1797}
1798impl ParenExpr {
1799    pub fn inner(&self) -> Option<Expr> {
1800        support::child(&self.syntax)
1801    }
1802    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
1803        support::token(&self.syntax, SyntaxKind::LParen)
1804    }
1805    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
1806        support::token(&self.syntax, SyntaxKind::RParen)
1807    }
1808}
1809/// A `LiteralExpr` node (`family.ungram` rule `LiteralExpr`).
1810#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1811pub struct LiteralExpr {
1812    syntax: SyntaxNode,
1813}
1814impl AstNode for LiteralExpr {
1815    fn cast(syntax: SyntaxNode) -> Option<Self> {
1816        (syntax.kind() == SyntaxKind::LiteralExpr).then_some(Self { syntax })
1817    }
1818    fn syntax(&self) -> &SyntaxNode {
1819        &self.syntax
1820    }
1821}
1822impl LiteralExpr {
1823    pub fn int_number_token(&self) -> Option<SyntaxToken> {
1824        support::token(&self.syntax, SyntaxKind::IntNumber)
1825    }
1826    pub fn float_number_token(&self) -> Option<SyntaxToken> {
1827        support::token(&self.syntax, SyntaxKind::FloatNumber)
1828    }
1829    pub fn string_lit_token(&self) -> Option<SyntaxToken> {
1830        support::token(&self.syntax, SyntaxKind::String)
1831    }
1832    pub fn true_token(&self) -> Option<SyntaxToken> {
1833        support::token(&self.syntax, SyntaxKind::TrueKw)
1834    }
1835    pub fn false_token(&self) -> Option<SyntaxToken> {
1836        support::token(&self.syntax, SyntaxKind::FalseKw)
1837    }
1838    pub fn duration_token(&self) -> Option<SyntaxToken> {
1839        support::token(&self.syntax, SyntaxKind::Duration)
1840    }
1841}
1842/// An error-recovery node wrapping the tokens the parser skipped
1843/// (task E1.2c). The one node kind with no rule in `family.ungram`.
1844#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1845pub struct ErrorNode {
1846    syntax: SyntaxNode,
1847}
1848impl AstNode for ErrorNode {
1849    fn cast(syntax: SyntaxNode) -> Option<Self> {
1850        (syntax.kind() == SyntaxKind::ErrorNode).then_some(Self { syntax })
1851    }
1852    fn syntax(&self) -> &SyntaxNode {
1853        &self.syntax
1854    }
1855}
ridl_syntax/ast/generated.rs

ridl_syntax/ast/
generated.rs
