dejavu_parser/dejavu/
parse_ast.rs

1use super::*;
2#[automatically_derived]
3impl YggdrasilNode for RootNode {
4    type Rule = DejavuRule;
5
6    fn get_range(&self) -> Option<Range<usize>> {
7        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
8    }
9    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
10        let _span = pair.get_span();
11        Ok(Self {
12            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
13            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
14        })
15    }
16}
17#[automatically_derived]
18impl FromStr for RootNode {
19    type Err = YggdrasilError<DejavuRule>;
20
21    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
22        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Root)?)
23    }
24}
25#[automatically_derived]
26impl YggdrasilNode for ElementNode {
27    type Rule = DejavuRule;
28
29    fn get_range(&self) -> Option<Range<usize>> {
30        match self {
31            Self::Export(s) => s.get_range(),
32            Self::For(s) => s.get_range(),
33            Self::If(s) => s.get_range(),
34            Self::Text(s) => s.get_range(),
35        }
36    }
37    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
38        let _span = pair.get_span();
39        if let Ok(s) = pair.take_tagged_one::<TemplateExportNode>(Cow::Borrowed("export")) {
40            return Ok(Self::Export(s));
41        }
42        if let Ok(s) = pair.take_tagged_one::<TemplateForNode>(Cow::Borrowed("for")) {
43            return Ok(Self::For(s));
44        }
45        if let Ok(s) = pair.take_tagged_one::<TemplateIfNode>(Cow::Borrowed("if")) {
46            return Ok(Self::If(s));
47        }
48        if let Ok(s) = pair.take_tagged_one::<TextManyNode>(Cow::Borrowed("text")) {
49            return Ok(Self::Text(s));
50        }
51        Err(YggdrasilError::invalid_node(DejavuRule::Element, _span))
52    }
53}
54#[automatically_derived]
55impl FromStr for ElementNode {
56    type Err = YggdrasilError<DejavuRule>;
57
58    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
59        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Element)?)
60    }
61}
62#[automatically_derived]
63impl YggdrasilNode for TextManyNode {
64    type Rule = DejavuRule;
65
66    fn get_range(&self) -> Option<Range<usize>> {
67        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
68    }
69    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
70        let _span = pair.get_span();
71        Ok(Self {
72            text_element: pair
73                .take_tagged_items::<TextElementNode>(Cow::Borrowed("text_element"))
74                .collect::<Result<Vec<_>, _>>()?,
75            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
76        })
77    }
78}
79#[automatically_derived]
80impl FromStr for TextManyNode {
81    type Err = YggdrasilError<DejavuRule>;
82
83    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
84        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TextMany)?)
85    }
86}
87#[automatically_derived]
88impl YggdrasilNode for TextElementNode {
89    type Rule = DejavuRule;
90
91    fn get_range(&self) -> Option<Range<usize>> {
92        match self {
93            Self::Escape(s) => s.get_range(),
94            Self::TextSpace(s) => s.get_range(),
95            Self::TextWord(s) => s.get_range(),
96        }
97    }
98    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
99        let _span = pair.get_span();
100        if let Ok(s) = pair.take_tagged_one::<TemplateENode>(Cow::Borrowed("escape")) {
101            return Ok(Self::Escape(s));
102        }
103        if let Ok(s) = pair.take_tagged_one::<TextSpaceNode>(Cow::Borrowed("text_space")) {
104            return Ok(Self::TextSpace(s));
105        }
106        if let Ok(s) = pair.take_tagged_one::<TextWordNode>(Cow::Borrowed("text_word")) {
107            return Ok(Self::TextWord(s));
108        }
109        Err(YggdrasilError::invalid_node(DejavuRule::TextElement, _span))
110    }
111}
112#[automatically_derived]
113impl FromStr for TextElementNode {
114    type Err = YggdrasilError<DejavuRule>;
115
116    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
117        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TextElement)?)
118    }
119}
120#[automatically_derived]
121impl YggdrasilNode for TemplateENode {
122    type Rule = DejavuRule;
123
124    fn get_range(&self) -> Option<Range<usize>> {
125        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
126    }
127    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
128        let _span = pair.get_span();
129        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
130    }
131}
132#[automatically_derived]
133impl FromStr for TemplateENode {
134    type Err = YggdrasilError<DejavuRule>;
135
136    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
137        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TEMPLATE_E)?)
138    }
139}
140#[automatically_derived]
141impl YggdrasilNode for TextSpaceNode {
142    type Rule = DejavuRule;
143
144    fn get_range(&self) -> Option<Range<usize>> {
145        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
146    }
147    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
148        let _span = pair.get_span();
149        Ok(Self { text: pair.get_string(), span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
150    }
151}
152#[automatically_derived]
153impl FromStr for TextSpaceNode {
154    type Err = YggdrasilError<DejavuRule>;
155
156    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
157        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TEXT_SPACE)?)
158    }
159}
160#[automatically_derived]
161impl YggdrasilNode for TextWordNode {
162    type Rule = DejavuRule;
163
164    fn get_range(&self) -> Option<Range<usize>> {
165        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
166    }
167    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
168        let _span = pair.get_span();
169        Ok(Self { text: pair.get_string(), span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
170    }
171}
172#[automatically_derived]
173impl FromStr for TextWordNode {
174    type Err = YggdrasilError<DejavuRule>;
175
176    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
177        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TEXT_WORD)?)
178    }
179}
180#[automatically_derived]
181impl YggdrasilNode for TemplateLNode {
182    type Rule = DejavuRule;
183
184    fn get_range(&self) -> Option<Range<usize>> {
185        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
186    }
187    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
188        let _span = pair.get_span();
189        Ok(Self {
190            space_control: pair.take_tagged_option::<SpaceControlNode>(Cow::Borrowed("space_control")),
191            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
192        })
193    }
194}
195#[automatically_derived]
196impl FromStr for TemplateLNode {
197    type Err = YggdrasilError<DejavuRule>;
198
199    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
200        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TEMPLATE_L)?)
201    }
202}
203#[automatically_derived]
204impl YggdrasilNode for TemplateRNode {
205    type Rule = DejavuRule;
206
207    fn get_range(&self) -> Option<Range<usize>> {
208        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
209    }
210    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
211        let _span = pair.get_span();
212        Ok(Self {
213            space_control: pair.take_tagged_option::<SpaceControlNode>(Cow::Borrowed("space_control")),
214            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
215        })
216    }
217}
218#[automatically_derived]
219impl FromStr for TemplateRNode {
220    type Err = YggdrasilError<DejavuRule>;
221
222    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
223        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TEMPLATE_R)?)
224    }
225}
226#[automatically_derived]
227impl YggdrasilNode for SpaceControlNode {
228    type Rule = DejavuRule;
229
230    fn get_range(&self) -> Option<Range<usize>> {
231        match self {
232            Self::Break0 => None,
233            Self::Break1 => None,
234            Self::Delete0 => None,
235            Self::Delete1 => None,
236            Self::Nothing => None,
237        }
238    }
239    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
240        let _span = pair.get_span();
241        if let Some(_) = pair.find_first_tag("break_0") {
242            return Ok(Self::Break0);
243        }
244        if let Some(_) = pair.find_first_tag("break_1") {
245            return Ok(Self::Break1);
246        }
247        if let Some(_) = pair.find_first_tag("delete_0") {
248            return Ok(Self::Delete0);
249        }
250        if let Some(_) = pair.find_first_tag("delete_1") {
251            return Ok(Self::Delete1);
252        }
253        if let Some(_) = pair.find_first_tag("nothing") {
254            return Ok(Self::Nothing);
255        }
256        Err(YggdrasilError::invalid_node(DejavuRule::SpaceControl, _span))
257    }
258}
259#[automatically_derived]
260impl FromStr for SpaceControlNode {
261    type Err = YggdrasilError<DejavuRule>;
262
263    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
264        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::SpaceControl)?)
265    }
266}
267#[automatically_derived]
268impl YggdrasilNode for KwEndNode {
269    type Rule = DejavuRule;
270
271    fn get_range(&self) -> Option<Range<usize>> {
272        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
273    }
274    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
275        let _span = pair.get_span();
276        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
277    }
278}
279#[automatically_derived]
280impl FromStr for KwEndNode {
281    type Err = YggdrasilError<DejavuRule>;
282
283    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
284        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_END)?)
285    }
286}
287#[automatically_derived]
288impl YggdrasilNode for TemplateExportNode {
289    type Rule = DejavuRule;
290
291    fn get_range(&self) -> Option<Range<usize>> {
292        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
293    }
294    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
295        let _span = pair.get_span();
296        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
297    }
298}
299#[automatically_derived]
300impl FromStr for TemplateExportNode {
301    type Err = YggdrasilError<DejavuRule>;
302
303    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
304        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TemplateExport)?)
305    }
306}
307#[automatically_derived]
308impl YggdrasilNode for ExportItemNode {
309    type Rule = DejavuRule;
310
311    fn get_range(&self) -> Option<Range<usize>> {
312        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
313    }
314    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
315        let _span = pair.get_span();
316        Ok(Self {
317            class: pair.take_tagged_option::<NamepathFreeNode>(Cow::Borrowed("class")),
318            language: pair.take_tagged_option::<IdentifierNode>(Cow::Borrowed("language")),
319            name: pair.take_tagged_one::<IdentifierNode>(Cow::Borrowed("name"))?,
320            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
321        })
322    }
323}
324#[automatically_derived]
325impl FromStr for ExportItemNode {
326    type Err = YggdrasilError<DejavuRule>;
327
328    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
329        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::ExportItem)?)
330    }
331}
332#[automatically_derived]
333impl YggdrasilNode for KwExportNode {
334    type Rule = DejavuRule;
335
336    fn get_range(&self) -> Option<Range<usize>> {
337        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
338    }
339    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
340        let _span = pair.get_span();
341        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
342    }
343}
344#[automatically_derived]
345impl FromStr for KwExportNode {
346    type Err = YggdrasilError<DejavuRule>;
347
348    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
349        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_EXPORT)?)
350    }
351}
352#[automatically_derived]
353impl YggdrasilNode for KwClassNode {
354    type Rule = DejavuRule;
355
356    fn get_range(&self) -> Option<Range<usize>> {
357        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
358    }
359    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
360        let _span = pair.get_span();
361        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
362    }
363}
364#[automatically_derived]
365impl FromStr for KwClassNode {
366    type Err = YggdrasilError<DejavuRule>;
367
368    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
369        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_CLASS)?)
370    }
371}
372#[automatically_derived]
373impl YggdrasilNode for KwTraitNode {
374    type Rule = DejavuRule;
375
376    fn get_range(&self) -> Option<Range<usize>> {
377        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
378    }
379    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
380        let _span = pair.get_span();
381        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
382    }
383}
384#[automatically_derived]
385impl FromStr for KwTraitNode {
386    type Err = YggdrasilError<DejavuRule>;
387
388    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
389        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_TRAIT)?)
390    }
391}
392#[automatically_derived]
393impl YggdrasilNode for KwToNode {
394    type Rule = DejavuRule;
395
396    fn get_range(&self) -> Option<Range<usize>> {
397        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
398    }
399    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
400        let _span = pair.get_span();
401        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
402    }
403}
404#[automatically_derived]
405impl FromStr for KwToNode {
406    type Err = YggdrasilError<DejavuRule>;
407
408    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
409        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_TO)?)
410    }
411}
412#[automatically_derived]
413impl YggdrasilNode for KwByNode {
414    type Rule = DejavuRule;
415
416    fn get_range(&self) -> Option<Range<usize>> {
417        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
418    }
419    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
420        let _span = pair.get_span();
421        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
422    }
423}
424#[automatically_derived]
425impl FromStr for KwByNode {
426    type Err = YggdrasilError<DejavuRule>;
427
428    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
429        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_BY)?)
430    }
431}
432#[automatically_derived]
433impl YggdrasilNode for TemplateIfNode {
434    type Rule = DejavuRule;
435
436    fn get_range(&self) -> Option<Range<usize>> {
437        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
438    }
439    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
440        let _span = pair.get_span();
441        Ok(Self {
442            if_begin: pair.take_tagged_one::<IfBeginNode>(Cow::Borrowed("if_begin"))?,
443            if_else: pair.take_tagged_option::<IfElseNode>(Cow::Borrowed("if_else")),
444            if_else_if: pair.take_tagged_items::<IfElseIfNode>(Cow::Borrowed("if_else_if")).collect::<Result<Vec<_>, _>>()?,
445            if_end: pair.take_tagged_one::<IfEndNode>(Cow::Borrowed("if_end"))?,
446            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
447        })
448    }
449}
450#[automatically_derived]
451impl FromStr for TemplateIfNode {
452    type Err = YggdrasilError<DejavuRule>;
453
454    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
455        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TemplateIf)?)
456    }
457}
458#[automatically_derived]
459impl YggdrasilNode for IfBeginNode {
460    type Rule = DejavuRule;
461
462    fn get_range(&self) -> Option<Range<usize>> {
463        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
464    }
465    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
466        let _span = pair.get_span();
467        Ok(Self {
468            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
469            expression: pair.take_tagged_one::<ExpressionNode>(Cow::Borrowed("expression"))?,
470            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
471            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
472            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
473        })
474    }
475}
476#[automatically_derived]
477impl FromStr for IfBeginNode {
478    type Err = YggdrasilError<DejavuRule>;
479
480    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
481        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::IfBegin)?)
482    }
483}
484#[automatically_derived]
485impl YggdrasilNode for IfElseNode {
486    type Rule = DejavuRule;
487
488    fn get_range(&self) -> Option<Range<usize>> {
489        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
490    }
491    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
492        let _span = pair.get_span();
493        Ok(Self {
494            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
495            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
496            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
497            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
498        })
499    }
500}
501#[automatically_derived]
502impl FromStr for IfElseNode {
503    type Err = YggdrasilError<DejavuRule>;
504
505    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
506        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::IfElse)?)
507    }
508}
509#[automatically_derived]
510impl YggdrasilNode for IfElseIfNode {
511    type Rule = DejavuRule;
512
513    fn get_range(&self) -> Option<Range<usize>> {
514        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
515    }
516    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
517        let _span = pair.get_span();
518        Ok(Self {
519            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
520            expression: pair.take_tagged_one::<ExpressionNode>(Cow::Borrowed("expression"))?,
521            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
522            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
523            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
524        })
525    }
526}
527#[automatically_derived]
528impl FromStr for IfElseIfNode {
529    type Err = YggdrasilError<DejavuRule>;
530
531    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
532        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::IfElseIf)?)
533    }
534}
535#[automatically_derived]
536impl YggdrasilNode for IfEndNode {
537    type Rule = DejavuRule;
538
539    fn get_range(&self) -> Option<Range<usize>> {
540        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
541    }
542    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
543        let _span = pair.get_span();
544        Ok(Self {
545            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
546            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
547            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
548        })
549    }
550}
551#[automatically_derived]
552impl FromStr for IfEndNode {
553    type Err = YggdrasilError<DejavuRule>;
554
555    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
556        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::IfEnd)?)
557    }
558}
559#[automatically_derived]
560impl YggdrasilNode for KwIfNode {
561    type Rule = DejavuRule;
562
563    fn get_range(&self) -> Option<Range<usize>> {
564        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
565    }
566    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
567        let _span = pair.get_span();
568        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
569    }
570}
571#[automatically_derived]
572impl FromStr for KwIfNode {
573    type Err = YggdrasilError<DejavuRule>;
574
575    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
576        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_IF)?)
577    }
578}
579#[automatically_derived]
580impl YggdrasilNode for KwElseNode {
581    type Rule = DejavuRule;
582
583    fn get_range(&self) -> Option<Range<usize>> {
584        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
585    }
586    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
587        let _span = pair.get_span();
588        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
589    }
590}
591#[automatically_derived]
592impl FromStr for KwElseNode {
593    type Err = YggdrasilError<DejavuRule>;
594
595    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
596        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_ELSE)?)
597    }
598}
599#[automatically_derived]
600impl YggdrasilNode for TemplateForNode {
601    type Rule = DejavuRule;
602
603    fn get_range(&self) -> Option<Range<usize>> {
604        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
605    }
606    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
607        let _span = pair.get_span();
608        Ok(Self {
609            for_begin: pair.take_tagged_one::<ForBeginNode>(Cow::Borrowed("for_begin"))?,
610            for_else: pair.take_tagged_option::<ForElseNode>(Cow::Borrowed("for_else")),
611            for_end: pair.take_tagged_one::<ForEndNode>(Cow::Borrowed("for_end"))?,
612            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
613        })
614    }
615}
616#[automatically_derived]
617impl FromStr for TemplateForNode {
618    type Err = YggdrasilError<DejavuRule>;
619
620    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
621        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::TemplateFor)?)
622    }
623}
624#[automatically_derived]
625impl YggdrasilNode for ForBeginNode {
626    type Rule = DejavuRule;
627
628    fn get_range(&self) -> Option<Range<usize>> {
629        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
630    }
631    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
632        let _span = pair.get_span();
633        Ok(Self {
634            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
635            kw_in: pair.take_tagged_items::<KwInNode>(Cow::Borrowed("kw_in")).collect::<Result<Vec<_>, _>>()?,
636            pattern: pair.take_tagged_one::<PatternNode>(Cow::Borrowed("pattern"))?,
637            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
638            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
639            condition: pair.take_tagged_option::<ExpressionNode>(Cow::Borrowed("condition")),
640            iterator: pair.take_tagged_one::<ExpressionNode>(Cow::Borrowed("iterator"))?,
641            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
642        })
643    }
644}
645#[automatically_derived]
646impl FromStr for ForBeginNode {
647    type Err = YggdrasilError<DejavuRule>;
648
649    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
650        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::ForBegin)?)
651    }
652}
653#[automatically_derived]
654impl YggdrasilNode for ForElseNode {
655    type Rule = DejavuRule;
656
657    fn get_range(&self) -> Option<Range<usize>> {
658        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
659    }
660    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
661        let _span = pair.get_span();
662        Ok(Self {
663            element: pair.take_tagged_items::<ElementNode>(Cow::Borrowed("element")).collect::<Result<Vec<_>, _>>()?,
664            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
665            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
666            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
667        })
668    }
669}
670#[automatically_derived]
671impl FromStr for ForElseNode {
672    type Err = YggdrasilError<DejavuRule>;
673
674    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
675        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::ForElse)?)
676    }
677}
678#[automatically_derived]
679impl YggdrasilNode for ForEndNode {
680    type Rule = DejavuRule;
681
682    fn get_range(&self) -> Option<Range<usize>> {
683        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
684    }
685    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
686        let _span = pair.get_span();
687        Ok(Self {
688            template_l: pair.take_tagged_one::<TemplateLNode>(Cow::Borrowed("template_l"))?,
689            template_r: pair.take_tagged_one::<TemplateRNode>(Cow::Borrowed("template_r"))?,
690            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
691        })
692    }
693}
694#[automatically_derived]
695impl FromStr for ForEndNode {
696    type Err = YggdrasilError<DejavuRule>;
697
698    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
699        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::ForEnd)?)
700    }
701}
702#[automatically_derived]
703impl YggdrasilNode for KwForNode {
704    type Rule = DejavuRule;
705
706    fn get_range(&self) -> Option<Range<usize>> {
707        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
708    }
709    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
710        let _span = pair.get_span();
711        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
712    }
713}
714#[automatically_derived]
715impl FromStr for KwForNode {
716    type Err = YggdrasilError<DejavuRule>;
717
718    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
719        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_FOR)?)
720    }
721}
722#[automatically_derived]
723impl YggdrasilNode for KwInNode {
724    type Rule = DejavuRule;
725
726    fn get_range(&self) -> Option<Range<usize>> {
727        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
728    }
729    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
730        let _span = pair.get_span();
731        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
732    }
733}
734#[automatically_derived]
735impl FromStr for KwInNode {
736    type Err = YggdrasilError<DejavuRule>;
737
738    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
739        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::KW_IN)?)
740    }
741}
742#[automatically_derived]
743impl YggdrasilNode for PatternNode {
744    type Rule = DejavuRule;
745
746    fn get_range(&self) -> Option<Range<usize>> {
747        match self {
748            Self::BarePattern(s) => s.get_range(),
749        }
750    }
751    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
752        let _span = pair.get_span();
753        if let Ok(s) = pair.take_tagged_one::<BarePatternNode>(Cow::Borrowed("bare_pattern")) {
754            return Ok(Self::BarePattern(s));
755        }
756        Err(YggdrasilError::invalid_node(DejavuRule::Pattern, _span))
757    }
758}
759#[automatically_derived]
760impl FromStr for PatternNode {
761    type Err = YggdrasilError<DejavuRule>;
762
763    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
764        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Pattern)?)
765    }
766}
767#[automatically_derived]
768impl YggdrasilNode for BarePatternNode {
769    type Rule = DejavuRule;
770
771    fn get_range(&self) -> Option<Range<usize>> {
772        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
773    }
774    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
775        let _span = pair.get_span();
776        Ok(Self {
777            identifier: pair.take_tagged_items::<IdentifierNode>(Cow::Borrowed("identifier")).collect::<Result<Vec<_>, _>>()?,
778            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
779        })
780    }
781}
782#[automatically_derived]
783impl FromStr for BarePatternNode {
784    type Err = YggdrasilError<DejavuRule>;
785
786    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
787        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::BarePattern)?)
788    }
789}
790#[automatically_derived]
791impl YggdrasilNode for ExpressionNode {
792    type Rule = DejavuRule;
793
794    fn get_range(&self) -> Option<Range<usize>> {
795        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
796    }
797    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
798        let _span = pair.get_span();
799        Ok(Self {
800            expression_rest: pair
801                .take_tagged_items::<ExpressionRestNode>(Cow::Borrowed("expression_rest"))
802                .collect::<Result<Vec<_>, _>>()?,
803            term: pair.take_tagged_one::<TermNode>(Cow::Borrowed("term"))?,
804            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
805        })
806    }
807}
808#[automatically_derived]
809impl FromStr for ExpressionNode {
810    type Err = YggdrasilError<DejavuRule>;
811
812    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
813        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Expression)?)
814    }
815}
816#[automatically_derived]
817impl YggdrasilNode for ExpressionRestNode {
818    type Rule = DejavuRule;
819
820    fn get_range(&self) -> Option<Range<usize>> {
821        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
822    }
823    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
824        let _span = pair.get_span();
825        Ok(Self {
826            infix: pair.take_tagged_one::<InfixNode>(Cow::Borrowed("infix"))?,
827            term: pair.take_tagged_one::<TermNode>(Cow::Borrowed("term"))?,
828            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
829        })
830    }
831}
832#[automatically_derived]
833impl FromStr for ExpressionRestNode {
834    type Err = YggdrasilError<DejavuRule>;
835
836    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
837        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::ExpressionRest)?)
838    }
839}
840#[automatically_derived]
841impl YggdrasilNode for InfixNode {
842    type Rule = DejavuRule;
843
844    fn get_range(&self) -> Option<Range<usize>> {
845        match self {
846            Self::Add => None,
847            Self::Mul => None,
848        }
849    }
850    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
851        let _span = pair.get_span();
852        if let Some(_) = pair.find_first_tag("add") {
853            return Ok(Self::Add);
854        }
855        if let Some(_) = pair.find_first_tag("mul") {
856            return Ok(Self::Mul);
857        }
858        Err(YggdrasilError::invalid_node(DejavuRule::Infix, _span))
859    }
860}
861#[automatically_derived]
862impl FromStr for InfixNode {
863    type Err = YggdrasilError<DejavuRule>;
864
865    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
866        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Infix)?)
867    }
868}
869#[automatically_derived]
870impl YggdrasilNode for TermNode {
871    type Rule = DejavuRule;
872
873    fn get_range(&self) -> Option<Range<usize>> {
874        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
875    }
876    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
877        let _span = pair.get_span();
878        Ok(Self {
879            atomic: pair.take_tagged_one::<AtomicNode>(Cow::Borrowed("atomic"))?,
880            prefix: pair.take_tagged_items::<PrefixNode>(Cow::Borrowed("prefix")).collect::<Result<Vec<_>, _>>()?,
881            suffix: pair.take_tagged_items::<SuffixNode>(Cow::Borrowed("suffix")).collect::<Result<Vec<_>, _>>()?,
882            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
883        })
884    }
885}
886#[automatically_derived]
887impl FromStr for TermNode {
888    type Err = YggdrasilError<DejavuRule>;
889
890    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
891        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Term)?)
892    }
893}
894#[automatically_derived]
895impl YggdrasilNode for PrefixNode {
896    type Rule = DejavuRule;
897
898    fn get_range(&self) -> Option<Range<usize>> {
899        match self {
900            Self::Not => None,
901        }
902    }
903    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
904        let _span = pair.get_span();
905        if let Some(_) = pair.find_first_tag("not") {
906            return Ok(Self::Not);
907        }
908        Err(YggdrasilError::invalid_node(DejavuRule::Prefix, _span))
909    }
910}
911#[automatically_derived]
912impl FromStr for PrefixNode {
913    type Err = YggdrasilError<DejavuRule>;
914
915    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
916        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Prefix)?)
917    }
918}
919#[automatically_derived]
920impl YggdrasilNode for SuffixNode {
921    type Rule = DejavuRule;
922
923    fn get_range(&self) -> Option<Range<usize>> {
924        match self {
925            Self::DotCall(s) => s.get_range(),
926            Self::Null => None,
927        }
928    }
929    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
930        let _span = pair.get_span();
931        if let Ok(s) = pair.take_tagged_one::<IdentifierNode>(Cow::Borrowed("dot_call")) {
932            return Ok(Self::DotCall(s));
933        }
934        if let Some(_) = pair.find_first_tag("null") {
935            return Ok(Self::Null);
936        }
937        Err(YggdrasilError::invalid_node(DejavuRule::Suffix, _span))
938    }
939}
940#[automatically_derived]
941impl FromStr for SuffixNode {
942    type Err = YggdrasilError<DejavuRule>;
943
944    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
945        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Suffix)?)
946    }
947}
948#[automatically_derived]
949impl YggdrasilNode for AtomicNode {
950    type Rule = DejavuRule;
951
952    fn get_range(&self) -> Option<Range<usize>> {
953        match self {
954            Self::Boolean(s) => s.get_range(),
955            Self::Identifier(s) => s.get_range(),
956            Self::Number(s) => s.get_range(),
957        }
958    }
959    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
960        let _span = pair.get_span();
961        if let Ok(s) = pair.take_tagged_one::<BooleanNode>(Cow::Borrowed("boolean")) {
962            return Ok(Self::Boolean(s));
963        }
964        if let Ok(s) = pair.take_tagged_one::<IdentifierNode>(Cow::Borrowed("identifier")) {
965            return Ok(Self::Identifier(s));
966        }
967        if let Ok(s) = pair.take_tagged_one::<NumberNode>(Cow::Borrowed("number")) {
968            return Ok(Self::Number(s));
969        }
970        Err(YggdrasilError::invalid_node(DejavuRule::Atomic, _span))
971    }
972}
973#[automatically_derived]
974impl FromStr for AtomicNode {
975    type Err = YggdrasilError<DejavuRule>;
976
977    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
978        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Atomic)?)
979    }
980}
981#[automatically_derived]
982impl YggdrasilNode for StringNode {
983    type Rule = DejavuRule;
984
985    fn get_range(&self) -> Option<Range<usize>> {
986        match self {
987            Self::DoubleQuote => None,
988            Self::SingleQuote => None,
989        }
990    }
991    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
992        let _span = pair.get_span();
993        if let Some(_) = pair.find_first_tag("double_quote") {
994            return Ok(Self::DoubleQuote);
995        }
996        if let Some(_) = pair.find_first_tag("single_quote") {
997            return Ok(Self::SingleQuote);
998        }
999        Err(YggdrasilError::invalid_node(DejavuRule::String, _span))
1000    }
1001}
1002#[automatically_derived]
1003impl FromStr for StringNode {
1004    type Err = YggdrasilError<DejavuRule>;
1005
1006    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1007        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::String)?)
1008    }
1009}
1010#[automatically_derived]
1011impl YggdrasilNode for NumberNode {
1012    type Rule = DejavuRule;
1013
1014    fn get_range(&self) -> Option<Range<usize>> {
1015        match self {
1016            Self::Bin(s) => s.get_range(),
1017            Self::Dec(s) => s.get_range(),
1018            Self::Hex(s) => s.get_range(),
1019            Self::Oct(s) => s.get_range(),
1020        }
1021    }
1022    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1023        let _span = pair.get_span();
1024        if let Ok(s) = pair.take_tagged_one::<BinNode>(Cow::Borrowed("bin")) {
1025            return Ok(Self::Bin(s));
1026        }
1027        if let Ok(s) = pair.take_tagged_one::<DigitsNode>(Cow::Borrowed("dec")) {
1028            return Ok(Self::Dec(s));
1029        }
1030        if let Ok(s) = pair.take_tagged_one::<HexNode>(Cow::Borrowed("hex")) {
1031            return Ok(Self::Hex(s));
1032        }
1033        if let Ok(s) = pair.take_tagged_one::<OctNode>(Cow::Borrowed("oct")) {
1034            return Ok(Self::Oct(s));
1035        }
1036        Err(YggdrasilError::invalid_node(DejavuRule::Number, _span))
1037    }
1038}
1039#[automatically_derived]
1040impl FromStr for NumberNode {
1041    type Err = YggdrasilError<DejavuRule>;
1042
1043    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1044        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Number)?)
1045    }
1046}
1047#[automatically_derived]
1048impl YggdrasilNode for DigitsNode {
1049    type Rule = DejavuRule;
1050
1051    fn get_range(&self) -> Option<Range<usize>> {
1052        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1053    }
1054    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1055        let _span = pair.get_span();
1056        Ok(Self { text: pair.get_string(), span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1057    }
1058}
1059#[automatically_derived]
1060impl FromStr for DigitsNode {
1061    type Err = YggdrasilError<DejavuRule>;
1062
1063    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1064        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Digits)?)
1065    }
1066}
1067#[automatically_derived]
1068impl YggdrasilNode for UnitNode {
1069    type Rule = DejavuRule;
1070
1071    fn get_range(&self) -> Option<Range<usize>> {
1072        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1073    }
1074    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1075        let _span = pair.get_span();
1076        Ok(Self {
1077            identifier: pair.take_tagged_one::<IdentifierNode>(Cow::Borrowed("identifier"))?,
1078            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
1079        })
1080    }
1081}
1082#[automatically_derived]
1083impl FromStr for UnitNode {
1084    type Err = YggdrasilError<DejavuRule>;
1085
1086    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1087        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Unit)?)
1088    }
1089}
1090#[automatically_derived]
1091impl YggdrasilNode for BinNode {
1092    type Rule = DejavuRule;
1093
1094    fn get_range(&self) -> Option<Range<usize>> {
1095        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1096    }
1097    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1098        let _span = pair.get_span();
1099        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1100    }
1101}
1102#[automatically_derived]
1103impl FromStr for BinNode {
1104    type Err = YggdrasilError<DejavuRule>;
1105
1106    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1107        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::BIN)?)
1108    }
1109}
1110#[automatically_derived]
1111impl YggdrasilNode for OctNode {
1112    type Rule = DejavuRule;
1113
1114    fn get_range(&self) -> Option<Range<usize>> {
1115        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1116    }
1117    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1118        let _span = pair.get_span();
1119        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1120    }
1121}
1122#[automatically_derived]
1123impl FromStr for OctNode {
1124    type Err = YggdrasilError<DejavuRule>;
1125
1126    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1127        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::OCT)?)
1128    }
1129}
1130#[automatically_derived]
1131impl YggdrasilNode for HexNode {
1132    type Rule = DejavuRule;
1133
1134    fn get_range(&self) -> Option<Range<usize>> {
1135        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1136    }
1137    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1138        let _span = pair.get_span();
1139        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1140    }
1141}
1142#[automatically_derived]
1143impl FromStr for HexNode {
1144    type Err = YggdrasilError<DejavuRule>;
1145
1146    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1147        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::HEX)?)
1148    }
1149}
1150#[automatically_derived]
1151impl YggdrasilNode for NamepathFreeNode {
1152    type Rule = DejavuRule;
1153
1154    fn get_range(&self) -> Option<Range<usize>> {
1155        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1156    }
1157    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1158        let _span = pair.get_span();
1159        Ok(Self {
1160            identifier: pair.take_tagged_items::<IdentifierNode>(Cow::Borrowed("identifier")).collect::<Result<Vec<_>, _>>()?,
1161            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
1162        })
1163    }
1164}
1165#[automatically_derived]
1166impl FromStr for NamepathFreeNode {
1167    type Err = YggdrasilError<DejavuRule>;
1168
1169    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1170        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::NamepathFree)?)
1171    }
1172}
1173#[automatically_derived]
1174impl YggdrasilNode for NamepathNode {
1175    type Rule = DejavuRule;
1176
1177    fn get_range(&self) -> Option<Range<usize>> {
1178        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1179    }
1180    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1181        let _span = pair.get_span();
1182        Ok(Self {
1183            identifier: pair.take_tagged_items::<IdentifierNode>(Cow::Borrowed("identifier")).collect::<Result<Vec<_>, _>>()?,
1184            span: Range { start: _span.start() as u32, end: _span.end() as u32 },
1185        })
1186    }
1187}
1188#[automatically_derived]
1189impl FromStr for NamepathNode {
1190    type Err = YggdrasilError<DejavuRule>;
1191
1192    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1193        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Namepath)?)
1194    }
1195}
1196#[automatically_derived]
1197impl YggdrasilNode for IdentifierNode {
1198    type Rule = DejavuRule;
1199
1200    fn get_range(&self) -> Option<Range<usize>> {
1201        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1202    }
1203    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1204        let _span = pair.get_span();
1205        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1206    }
1207}
1208#[automatically_derived]
1209impl FromStr for IdentifierNode {
1210    type Err = YggdrasilError<DejavuRule>;
1211
1212    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1213        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Identifier)?)
1214    }
1215}
1216#[automatically_derived]
1217impl YggdrasilNode for BooleanNode {
1218    type Rule = DejavuRule;
1219
1220    fn get_range(&self) -> Option<Range<usize>> {
1221        match self {
1222            Self::False => None,
1223            Self::True => None,
1224        }
1225    }
1226    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1227        let _span = pair.get_span();
1228        if let Some(_) = pair.find_first_tag("false") {
1229            return Ok(Self::False);
1230        }
1231        if let Some(_) = pair.find_first_tag("true") {
1232            return Ok(Self::True);
1233        }
1234        Err(YggdrasilError::invalid_node(DejavuRule::Boolean, _span))
1235    }
1236}
1237#[automatically_derived]
1238impl FromStr for BooleanNode {
1239    type Err = YggdrasilError<DejavuRule>;
1240
1241    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1242        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::Boolean)?)
1243    }
1244}
1245#[automatically_derived]
1246impl YggdrasilNode for WhiteSpaceNode {
1247    type Rule = DejavuRule;
1248
1249    fn get_range(&self) -> Option<Range<usize>> {
1250        Some(Range { start: self.span.start as usize, end: self.span.end as usize })
1251    }
1252    fn from_pair(pair: TokenPair<Self::Rule>) -> Result<Self, YggdrasilError<Self::Rule>> {
1253        let _span = pair.get_span();
1254        Ok(Self { span: Range { start: _span.start() as u32, end: _span.end() as u32 } })
1255    }
1256}
1257#[automatically_derived]
1258impl FromStr for WhiteSpaceNode {
1259    type Err = YggdrasilError<DejavuRule>;
1260
1261    fn from_str(input: &str) -> Result<Self, YggdrasilError<DejavuRule>> {
1262        Self::from_cst(DejavuParser::parse_cst(input, DejavuRule::WhiteSpace)?)
1263    }
1264}
dejavu_parser/dejavu/parse_ast.rs

dejavu_parser/dejavu/
parse_ast.rs
