1#[derive(Debug, Clone, PartialEq, Eq)]
2pub struct AccessCall<'tree> {
3 pub span: ::treesitter_types::Span,
4 pub key: AccessCallKey<'tree>,
5 pub target: AccessCallTarget<'tree>,
6}
7impl<'tree> ::treesitter_types::FromNode<'tree> for AccessCall<'tree> {
8 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
9 fn from_node(
10 node: ::tree_sitter::Node<'tree>,
11 src: &'tree [u8],
12 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
13 debug_assert_eq!(node.kind(), "access_call");
14 Ok(Self {
15 span: ::treesitter_types::Span::from(node),
16 key: {
17 let child = node
18 .child_by_field_name("key")
19 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
20 <AccessCallKey as ::treesitter_types::FromNode>::from_node(child, src)?
21 },
22 target: {
23 let child = node
24 .child_by_field_name("target")
25 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("target", node))?;
26 <AccessCallTarget as ::treesitter_types::FromNode>::from_node(child, src)?
27 },
28 })
29 }
30}
31impl ::treesitter_types::Spanned for AccessCall<'_> {
32 fn span(&self) -> ::treesitter_types::Span {
33 self.span
34 }
35}
36#[derive(Debug, Clone, PartialEq, Eq)]
37pub struct AfterBlock<'tree> {
38 pub span: ::treesitter_types::Span,
39 pub children: ::std::vec::Vec<AfterBlockChildren<'tree>>,
40}
41impl<'tree> ::treesitter_types::FromNode<'tree> for AfterBlock<'tree> {
42 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
43 fn from_node(
44 node: ::tree_sitter::Node<'tree>,
45 src: &'tree [u8],
46 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
47 debug_assert_eq!(node.kind(), "after_block");
48 Ok(Self {
49 span: ::treesitter_types::Span::from(node),
50 children: {
51 #[allow(clippy::suspicious_else_formatting)]
52 let non_field_children = {
53 let mut cursor = node.walk();
54 let mut result = ::std::vec::Vec::new();
55 if cursor.goto_first_child() {
56 loop {
57 if cursor.field_name().is_none()
58 && cursor.node().is_named()
59 && !cursor.node().is_extra()
60 {
61 result.push(cursor.node());
62 }
63 if !cursor.goto_next_sibling() {
64 break;
65 }
66 }
67 }
68 result
69 };
70 let mut items = ::std::vec::Vec::new();
71 for child in non_field_children {
72 items.push(
73 <AfterBlockChildren as ::treesitter_types::FromNode>::from_node(
74 child, src,
75 )?,
76 );
77 }
78 items
79 },
80 })
81 }
82}
83impl ::treesitter_types::Spanned for AfterBlock<'_> {
84 fn span(&self) -> ::treesitter_types::Span {
85 self.span
86 }
87}
88#[derive(Debug, Clone, PartialEq, Eq)]
89pub struct AnonymousFunction<'tree> {
90 pub span: ::treesitter_types::Span,
91 pub children: ::std::vec::Vec<StabClause<'tree>>,
92}
93impl<'tree> ::treesitter_types::FromNode<'tree> for AnonymousFunction<'tree> {
94 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
95 fn from_node(
96 node: ::tree_sitter::Node<'tree>,
97 src: &'tree [u8],
98 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
99 debug_assert_eq!(node.kind(), "anonymous_function");
100 Ok(Self {
101 span: ::treesitter_types::Span::from(node),
102 children: {
103 #[allow(clippy::suspicious_else_formatting)]
104 let non_field_children = {
105 let mut cursor = node.walk();
106 let mut result = ::std::vec::Vec::new();
107 if cursor.goto_first_child() {
108 loop {
109 if cursor.field_name().is_none()
110 && cursor.node().is_named()
111 && !cursor.node().is_extra()
112 {
113 result.push(cursor.node());
114 }
115 if !cursor.goto_next_sibling() {
116 break;
117 }
118 }
119 }
120 result
121 };
122 let mut items = ::std::vec::Vec::new();
123 for child in non_field_children {
124 items.push(<StabClause as ::treesitter_types::FromNode>::from_node(
125 child, src,
126 )?);
127 }
128 items
129 },
130 })
131 }
132}
133impl ::treesitter_types::Spanned for AnonymousFunction<'_> {
134 fn span(&self) -> ::treesitter_types::Span {
135 self.span
136 }
137}
138#[derive(Debug, Clone, PartialEq, Eq)]
139pub struct Arguments<'tree> {
140 pub span: ::treesitter_types::Span,
141 pub children: ::std::vec::Vec<ArgumentsChildren<'tree>>,
142}
143impl<'tree> ::treesitter_types::FromNode<'tree> for Arguments<'tree> {
144 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
145 fn from_node(
146 node: ::tree_sitter::Node<'tree>,
147 src: &'tree [u8],
148 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
149 debug_assert_eq!(node.kind(), "arguments");
150 Ok(Self {
151 span: ::treesitter_types::Span::from(node),
152 children: {
153 #[allow(clippy::suspicious_else_formatting)]
154 let non_field_children = {
155 let mut cursor = node.walk();
156 let mut result = ::std::vec::Vec::new();
157 if cursor.goto_first_child() {
158 loop {
159 if cursor.field_name().is_none()
160 && cursor.node().is_named()
161 && !cursor.node().is_extra()
162 {
163 result.push(cursor.node());
164 }
165 if !cursor.goto_next_sibling() {
166 break;
167 }
168 }
169 }
170 result
171 };
172 let mut items = ::std::vec::Vec::new();
173 for child in non_field_children {
174 items.push(
175 <ArgumentsChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
176 );
177 }
178 items
179 },
180 })
181 }
182}
183impl ::treesitter_types::Spanned for Arguments<'_> {
184 fn span(&self) -> ::treesitter_types::Span {
185 self.span
186 }
187}
188#[derive(Debug, Clone, PartialEq, Eq)]
189pub struct BinaryOperator<'tree> {
190 pub span: ::treesitter_types::Span,
191 pub left: BinaryOperatorLeft<'tree>,
192 pub operator: BinaryOperatorOperator,
193 pub right: BinaryOperatorRight<'tree>,
194}
195impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperator<'tree> {
196 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
197 fn from_node(
198 node: ::tree_sitter::Node<'tree>,
199 src: &'tree [u8],
200 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
201 debug_assert_eq!(node.kind(), "binary_operator");
202 Ok(Self {
203 span: ::treesitter_types::Span::from(node),
204 left: {
205 let child = node
206 .child_by_field_name("left")
207 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
208 <BinaryOperatorLeft as ::treesitter_types::FromNode>::from_node(child, src)?
209 },
210 operator: {
211 let child = node.child_by_field_name("operator").ok_or_else(|| {
212 ::treesitter_types::ParseError::missing_field("operator", node)
213 })?;
214 <BinaryOperatorOperator as ::treesitter_types::FromNode>::from_node(child, src)?
215 },
216 right: {
217 let child = node
218 .child_by_field_name("right")
219 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("right", node))?;
220 <BinaryOperatorRight as ::treesitter_types::FromNode>::from_node(child, src)?
221 },
222 })
223 }
224}
225impl ::treesitter_types::Spanned for BinaryOperator<'_> {
226 fn span(&self) -> ::treesitter_types::Span {
227 self.span
228 }
229}
230#[derive(Debug, Clone, PartialEq, Eq)]
231pub struct Bitstring<'tree> {
232 pub span: ::treesitter_types::Span,
233 pub children: ::std::vec::Vec<BitstringChildren<'tree>>,
234}
235impl<'tree> ::treesitter_types::FromNode<'tree> for Bitstring<'tree> {
236 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
237 fn from_node(
238 node: ::tree_sitter::Node<'tree>,
239 src: &'tree [u8],
240 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
241 debug_assert_eq!(node.kind(), "bitstring");
242 Ok(Self {
243 span: ::treesitter_types::Span::from(node),
244 children: {
245 #[allow(clippy::suspicious_else_formatting)]
246 let non_field_children = {
247 let mut cursor = node.walk();
248 let mut result = ::std::vec::Vec::new();
249 if cursor.goto_first_child() {
250 loop {
251 if cursor.field_name().is_none()
252 && cursor.node().is_named()
253 && !cursor.node().is_extra()
254 {
255 result.push(cursor.node());
256 }
257 if !cursor.goto_next_sibling() {
258 break;
259 }
260 }
261 }
262 result
263 };
264 let mut items = ::std::vec::Vec::new();
265 for child in non_field_children {
266 items.push(
267 <BitstringChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
268 );
269 }
270 items
271 },
272 })
273 }
274}
275impl ::treesitter_types::Spanned for Bitstring<'_> {
276 fn span(&self) -> ::treesitter_types::Span {
277 self.span
278 }
279}
280#[derive(Debug, Clone, PartialEq, Eq)]
281pub struct Block<'tree> {
282 pub span: ::treesitter_types::Span,
283 pub children: ::std::vec::Vec<BlockChildren<'tree>>,
284}
285impl<'tree> ::treesitter_types::FromNode<'tree> for Block<'tree> {
286 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
287 fn from_node(
288 node: ::tree_sitter::Node<'tree>,
289 src: &'tree [u8],
290 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
291 debug_assert_eq!(node.kind(), "block");
292 Ok(Self {
293 span: ::treesitter_types::Span::from(node),
294 children: {
295 #[allow(clippy::suspicious_else_formatting)]
296 let non_field_children = {
297 let mut cursor = node.walk();
298 let mut result = ::std::vec::Vec::new();
299 if cursor.goto_first_child() {
300 loop {
301 if cursor.field_name().is_none()
302 && cursor.node().is_named()
303 && !cursor.node().is_extra()
304 {
305 result.push(cursor.node());
306 }
307 if !cursor.goto_next_sibling() {
308 break;
309 }
310 }
311 }
312 result
313 };
314 let mut items = ::std::vec::Vec::new();
315 for child in non_field_children {
316 items.push(<BlockChildren as ::treesitter_types::FromNode>::from_node(
317 child, src,
318 )?);
319 }
320 items
321 },
322 })
323 }
324}
325impl ::treesitter_types::Spanned for Block<'_> {
326 fn span(&self) -> ::treesitter_types::Span {
327 self.span
328 }
329}
330#[derive(Debug, Clone, PartialEq, Eq)]
331pub struct Body<'tree> {
332 pub span: ::treesitter_types::Span,
333 pub children: ::std::vec::Vec<BodyChildren<'tree>>,
334}
335impl<'tree> ::treesitter_types::FromNode<'tree> for Body<'tree> {
336 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
337 fn from_node(
338 node: ::tree_sitter::Node<'tree>,
339 src: &'tree [u8],
340 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
341 debug_assert_eq!(node.kind(), "body");
342 Ok(Self {
343 span: ::treesitter_types::Span::from(node),
344 children: {
345 #[allow(clippy::suspicious_else_formatting)]
346 let non_field_children = {
347 let mut cursor = node.walk();
348 let mut result = ::std::vec::Vec::new();
349 if cursor.goto_first_child() {
350 loop {
351 if cursor.field_name().is_none()
352 && cursor.node().is_named()
353 && !cursor.node().is_extra()
354 {
355 result.push(cursor.node());
356 }
357 if !cursor.goto_next_sibling() {
358 break;
359 }
360 }
361 }
362 result
363 };
364 let mut items = ::std::vec::Vec::new();
365 for child in non_field_children {
366 items.push(<BodyChildren as ::treesitter_types::FromNode>::from_node(
367 child, src,
368 )?);
369 }
370 items
371 },
372 })
373 }
374}
375impl ::treesitter_types::Spanned for Body<'_> {
376 fn span(&self) -> ::treesitter_types::Span {
377 self.span
378 }
379}
380#[derive(Debug, Clone, PartialEq, Eq)]
381pub struct Boolean<'tree> {
382 pub span: ::treesitter_types::Span,
383 text: &'tree str,
384}
385impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
386 fn from_node(
387 node: ::tree_sitter::Node<'tree>,
388 src: &'tree [u8],
389 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
390 debug_assert_eq!(node.kind(), "boolean");
391 Ok(Self {
392 span: ::treesitter_types::Span::from(node),
393 text: node.utf8_text(src)?,
394 })
395 }
396}
397impl<'tree> ::treesitter_types::LeafNode<'tree> for Boolean<'tree> {
398 fn text(&self) -> &'tree str {
399 self.text
400 }
401}
402impl ::treesitter_types::Spanned for Boolean<'_> {
403 fn span(&self) -> ::treesitter_types::Span {
404 self.span
405 }
406}
407#[derive(Debug, Clone, PartialEq, Eq)]
408pub struct Call<'tree> {
409 pub span: ::treesitter_types::Span,
410 pub target: CallTarget<'tree>,
411 pub children: ::std::vec::Vec<CallChildren<'tree>>,
412}
413impl<'tree> ::treesitter_types::FromNode<'tree> for Call<'tree> {
414 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
415 fn from_node(
416 node: ::tree_sitter::Node<'tree>,
417 src: &'tree [u8],
418 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
419 debug_assert_eq!(node.kind(), "call");
420 Ok(Self {
421 span: ::treesitter_types::Span::from(node),
422 target: {
423 let child = node
424 .child_by_field_name("target")
425 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("target", node))?;
426 <CallTarget as ::treesitter_types::FromNode>::from_node(child, src)?
427 },
428 children: {
429 #[allow(clippy::suspicious_else_formatting)]
430 let non_field_children = {
431 let mut cursor = node.walk();
432 let mut result = ::std::vec::Vec::new();
433 if cursor.goto_first_child() {
434 loop {
435 if cursor.field_name().is_none()
436 && cursor.node().is_named()
437 && !cursor.node().is_extra()
438 {
439 result.push(cursor.node());
440 }
441 if !cursor.goto_next_sibling() {
442 break;
443 }
444 }
445 }
446 result
447 };
448 let mut items = ::std::vec::Vec::new();
449 for child in non_field_children {
450 items.push(<CallChildren as ::treesitter_types::FromNode>::from_node(
451 child, src,
452 )?);
453 }
454 items
455 },
456 })
457 }
458}
459impl ::treesitter_types::Spanned for Call<'_> {
460 fn span(&self) -> ::treesitter_types::Span {
461 self.span
462 }
463}
464#[derive(Debug, Clone, PartialEq, Eq)]
465pub struct CatchBlock<'tree> {
466 pub span: ::treesitter_types::Span,
467 pub children: ::std::vec::Vec<CatchBlockChildren<'tree>>,
468}
469impl<'tree> ::treesitter_types::FromNode<'tree> for CatchBlock<'tree> {
470 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
471 fn from_node(
472 node: ::tree_sitter::Node<'tree>,
473 src: &'tree [u8],
474 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
475 debug_assert_eq!(node.kind(), "catch_block");
476 Ok(Self {
477 span: ::treesitter_types::Span::from(node),
478 children: {
479 #[allow(clippy::suspicious_else_formatting)]
480 let non_field_children = {
481 let mut cursor = node.walk();
482 let mut result = ::std::vec::Vec::new();
483 if cursor.goto_first_child() {
484 loop {
485 if cursor.field_name().is_none()
486 && cursor.node().is_named()
487 && !cursor.node().is_extra()
488 {
489 result.push(cursor.node());
490 }
491 if !cursor.goto_next_sibling() {
492 break;
493 }
494 }
495 }
496 result
497 };
498 let mut items = ::std::vec::Vec::new();
499 for child in non_field_children {
500 items.push(
501 <CatchBlockChildren as ::treesitter_types::FromNode>::from_node(
502 child, src,
503 )?,
504 );
505 }
506 items
507 },
508 })
509 }
510}
511impl ::treesitter_types::Spanned for CatchBlock<'_> {
512 fn span(&self) -> ::treesitter_types::Span {
513 self.span
514 }
515}
516#[derive(Debug, Clone, PartialEq, Eq)]
517pub struct Charlist<'tree> {
518 pub span: ::treesitter_types::Span,
519 pub quoted_end: CharlistQuotedEnd,
520 pub quoted_start: CharlistQuotedStart,
521 pub children: ::std::vec::Vec<CharlistChildren<'tree>>,
522}
523impl<'tree> ::treesitter_types::FromNode<'tree> for Charlist<'tree> {
524 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
525 fn from_node(
526 node: ::tree_sitter::Node<'tree>,
527 src: &'tree [u8],
528 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
529 debug_assert_eq!(node.kind(), "charlist");
530 Ok(Self {
531 span: ::treesitter_types::Span::from(node),
532 quoted_end: {
533 let child = node.child_by_field_name("quoted_end").ok_or_else(|| {
534 ::treesitter_types::ParseError::missing_field("quoted_end", node)
535 })?;
536 <CharlistQuotedEnd as ::treesitter_types::FromNode>::from_node(child, src)?
537 },
538 quoted_start: {
539 let child = node.child_by_field_name("quoted_start").ok_or_else(|| {
540 ::treesitter_types::ParseError::missing_field("quoted_start", node)
541 })?;
542 <CharlistQuotedStart as ::treesitter_types::FromNode>::from_node(child, src)?
543 },
544 children: {
545 #[allow(clippy::suspicious_else_formatting)]
546 let non_field_children = {
547 let mut cursor = node.walk();
548 let mut result = ::std::vec::Vec::new();
549 if cursor.goto_first_child() {
550 loop {
551 if cursor.field_name().is_none()
552 && cursor.node().is_named()
553 && !cursor.node().is_extra()
554 {
555 result.push(cursor.node());
556 }
557 if !cursor.goto_next_sibling() {
558 break;
559 }
560 }
561 }
562 result
563 };
564 let mut items = ::std::vec::Vec::new();
565 for child in non_field_children {
566 items.push(
567 <CharlistChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
568 );
569 }
570 items
571 },
572 })
573 }
574}
575impl ::treesitter_types::Spanned for Charlist<'_> {
576 fn span(&self) -> ::treesitter_types::Span {
577 self.span
578 }
579}
580#[derive(Debug, Clone, PartialEq, Eq)]
581pub struct DoBlock<'tree> {
582 pub span: ::treesitter_types::Span,
583 pub children: ::std::vec::Vec<DoBlockChildren<'tree>>,
584}
585impl<'tree> ::treesitter_types::FromNode<'tree> for DoBlock<'tree> {
586 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
587 fn from_node(
588 node: ::tree_sitter::Node<'tree>,
589 src: &'tree [u8],
590 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
591 debug_assert_eq!(node.kind(), "do_block");
592 Ok(Self {
593 span: ::treesitter_types::Span::from(node),
594 children: {
595 #[allow(clippy::suspicious_else_formatting)]
596 let non_field_children = {
597 let mut cursor = node.walk();
598 let mut result = ::std::vec::Vec::new();
599 if cursor.goto_first_child() {
600 loop {
601 if cursor.field_name().is_none()
602 && cursor.node().is_named()
603 && !cursor.node().is_extra()
604 {
605 result.push(cursor.node());
606 }
607 if !cursor.goto_next_sibling() {
608 break;
609 }
610 }
611 }
612 result
613 };
614 let mut items = ::std::vec::Vec::new();
615 for child in non_field_children {
616 items.push(
617 <DoBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
618 );
619 }
620 items
621 },
622 })
623 }
624}
625impl ::treesitter_types::Spanned for DoBlock<'_> {
626 fn span(&self) -> ::treesitter_types::Span {
627 self.span
628 }
629}
630#[derive(Debug, Clone, PartialEq, Eq)]
631pub struct Dot<'tree> {
632 pub span: ::treesitter_types::Span,
633 pub left: DotLeft<'tree>,
634 pub operator: DotOperator,
635 pub right: ::core::option::Option<DotRight<'tree>>,
636}
637impl<'tree> ::treesitter_types::FromNode<'tree> for Dot<'tree> {
638 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
639 fn from_node(
640 node: ::tree_sitter::Node<'tree>,
641 src: &'tree [u8],
642 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
643 debug_assert_eq!(node.kind(), "dot");
644 Ok(Self {
645 span: ::treesitter_types::Span::from(node),
646 left: {
647 let child = node
648 .child_by_field_name("left")
649 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("left", node))?;
650 <DotLeft as ::treesitter_types::FromNode>::from_node(child, src)?
651 },
652 operator: {
653 let child = node.child_by_field_name("operator").ok_or_else(|| {
654 ::treesitter_types::ParseError::missing_field("operator", node)
655 })?;
656 <DotOperator as ::treesitter_types::FromNode>::from_node(child, src)?
657 },
658 right: match node.child_by_field_name("right") {
659 Some(child) => Some(<DotRight as ::treesitter_types::FromNode>::from_node(
660 child, src,
661 )?),
662 None => None,
663 },
664 })
665 }
666}
667impl ::treesitter_types::Spanned for Dot<'_> {
668 fn span(&self) -> ::treesitter_types::Span {
669 self.span
670 }
671}
672#[derive(Debug, Clone, PartialEq, Eq)]
673pub struct ElseBlock<'tree> {
674 pub span: ::treesitter_types::Span,
675 pub children: ::std::vec::Vec<ElseBlockChildren<'tree>>,
676}
677impl<'tree> ::treesitter_types::FromNode<'tree> for ElseBlock<'tree> {
678 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
679 fn from_node(
680 node: ::tree_sitter::Node<'tree>,
681 src: &'tree [u8],
682 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
683 debug_assert_eq!(node.kind(), "else_block");
684 Ok(Self {
685 span: ::treesitter_types::Span::from(node),
686 children: {
687 #[allow(clippy::suspicious_else_formatting)]
688 let non_field_children = {
689 let mut cursor = node.walk();
690 let mut result = ::std::vec::Vec::new();
691 if cursor.goto_first_child() {
692 loop {
693 if cursor.field_name().is_none()
694 && cursor.node().is_named()
695 && !cursor.node().is_extra()
696 {
697 result.push(cursor.node());
698 }
699 if !cursor.goto_next_sibling() {
700 break;
701 }
702 }
703 }
704 result
705 };
706 let mut items = ::std::vec::Vec::new();
707 for child in non_field_children {
708 items.push(
709 <ElseBlockChildren as ::treesitter_types::FromNode>::from_node(child, src)?,
710 );
711 }
712 items
713 },
714 })
715 }
716}
717impl ::treesitter_types::Spanned for ElseBlock<'_> {
718 fn span(&self) -> ::treesitter_types::Span {
719 self.span
720 }
721}
722#[derive(Debug, Clone, PartialEq, Eq)]
723pub struct Identifier<'tree> {
724 pub span: ::treesitter_types::Span,
725 text: &'tree str,
726}
727impl<'tree> ::treesitter_types::FromNode<'tree> for Identifier<'tree> {
728 fn from_node(
729 node: ::tree_sitter::Node<'tree>,
730 src: &'tree [u8],
731 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
732 debug_assert_eq!(node.kind(), "identifier");
733 Ok(Self {
734 span: ::treesitter_types::Span::from(node),
735 text: node.utf8_text(src)?,
736 })
737 }
738}
739impl<'tree> ::treesitter_types::LeafNode<'tree> for Identifier<'tree> {
740 fn text(&self) -> &'tree str {
741 self.text
742 }
743}
744impl ::treesitter_types::Spanned for Identifier<'_> {
745 fn span(&self) -> ::treesitter_types::Span {
746 self.span
747 }
748}
749#[derive(Debug, Clone, PartialEq, Eq)]
750pub struct Interpolation<'tree> {
751 pub span: ::treesitter_types::Span,
752 pub children: ::core::option::Option<InterpolationChildren<'tree>>,
753}
754impl<'tree> ::treesitter_types::FromNode<'tree> for Interpolation<'tree> {
755 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
756 fn from_node(
757 node: ::tree_sitter::Node<'tree>,
758 src: &'tree [u8],
759 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
760 debug_assert_eq!(node.kind(), "interpolation");
761 Ok(Self {
762 span: ::treesitter_types::Span::from(node),
763 children: {
764 #[allow(clippy::suspicious_else_formatting)]
765 let non_field_children = {
766 let mut cursor = node.walk();
767 let mut result = ::std::vec::Vec::new();
768 if cursor.goto_first_child() {
769 loop {
770 if cursor.field_name().is_none()
771 && cursor.node().is_named()
772 && !cursor.node().is_extra()
773 {
774 result.push(cursor.node());
775 }
776 if !cursor.goto_next_sibling() {
777 break;
778 }
779 }
780 }
781 result
782 };
783 match non_field_children.first() {
784 Some(&child) => Some(
785 <InterpolationChildren as ::treesitter_types::FromNode>::from_node(
786 child, src,
787 )?,
788 ),
789 None => None,
790 }
791 },
792 })
793 }
794}
795impl ::treesitter_types::Spanned for Interpolation<'_> {
796 fn span(&self) -> ::treesitter_types::Span {
797 self.span
798 }
799}
800#[derive(Debug, Clone, PartialEq, Eq)]
801pub struct Keywords<'tree> {
802 pub span: ::treesitter_types::Span,
803 pub children: ::std::vec::Vec<Pair<'tree>>,
804}
805impl<'tree> ::treesitter_types::FromNode<'tree> for Keywords<'tree> {
806 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
807 fn from_node(
808 node: ::tree_sitter::Node<'tree>,
809 src: &'tree [u8],
810 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
811 debug_assert_eq!(node.kind(), "keywords");
812 Ok(Self {
813 span: ::treesitter_types::Span::from(node),
814 children: {
815 #[allow(clippy::suspicious_else_formatting)]
816 let non_field_children = {
817 let mut cursor = node.walk();
818 let mut result = ::std::vec::Vec::new();
819 if cursor.goto_first_child() {
820 loop {
821 if cursor.field_name().is_none()
822 && cursor.node().is_named()
823 && !cursor.node().is_extra()
824 {
825 result.push(cursor.node());
826 }
827 if !cursor.goto_next_sibling() {
828 break;
829 }
830 }
831 }
832 result
833 };
834 let mut items = ::std::vec::Vec::new();
835 for child in non_field_children {
836 items.push(<Pair as ::treesitter_types::FromNode>::from_node(
837 child, src,
838 )?);
839 }
840 items
841 },
842 })
843 }
844}
845impl ::treesitter_types::Spanned for Keywords<'_> {
846 fn span(&self) -> ::treesitter_types::Span {
847 self.span
848 }
849}
850#[derive(Debug, Clone, PartialEq, Eq)]
851pub struct List<'tree> {
852 pub span: ::treesitter_types::Span,
853 pub children: ::std::vec::Vec<ListChildren<'tree>>,
854}
855impl<'tree> ::treesitter_types::FromNode<'tree> for List<'tree> {
856 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
857 fn from_node(
858 node: ::tree_sitter::Node<'tree>,
859 src: &'tree [u8],
860 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
861 debug_assert_eq!(node.kind(), "list");
862 Ok(Self {
863 span: ::treesitter_types::Span::from(node),
864 children: {
865 #[allow(clippy::suspicious_else_formatting)]
866 let non_field_children = {
867 let mut cursor = node.walk();
868 let mut result = ::std::vec::Vec::new();
869 if cursor.goto_first_child() {
870 loop {
871 if cursor.field_name().is_none()
872 && cursor.node().is_named()
873 && !cursor.node().is_extra()
874 {
875 result.push(cursor.node());
876 }
877 if !cursor.goto_next_sibling() {
878 break;
879 }
880 }
881 }
882 result
883 };
884 let mut items = ::std::vec::Vec::new();
885 for child in non_field_children {
886 items.push(<ListChildren as ::treesitter_types::FromNode>::from_node(
887 child, src,
888 )?);
889 }
890 items
891 },
892 })
893 }
894}
895impl ::treesitter_types::Spanned for List<'_> {
896 fn span(&self) -> ::treesitter_types::Span {
897 self.span
898 }
899}
900#[derive(Debug, Clone, PartialEq, Eq)]
901pub struct Map<'tree> {
902 pub span: ::treesitter_types::Span,
903 pub children: ::std::vec::Vec<MapChildren<'tree>>,
904}
905impl<'tree> ::treesitter_types::FromNode<'tree> for Map<'tree> {
906 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
907 fn from_node(
908 node: ::tree_sitter::Node<'tree>,
909 src: &'tree [u8],
910 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
911 debug_assert_eq!(node.kind(), "map");
912 Ok(Self {
913 span: ::treesitter_types::Span::from(node),
914 children: {
915 #[allow(clippy::suspicious_else_formatting)]
916 let non_field_children = {
917 let mut cursor = node.walk();
918 let mut result = ::std::vec::Vec::new();
919 if cursor.goto_first_child() {
920 loop {
921 if cursor.field_name().is_none()
922 && cursor.node().is_named()
923 && !cursor.node().is_extra()
924 {
925 result.push(cursor.node());
926 }
927 if !cursor.goto_next_sibling() {
928 break;
929 }
930 }
931 }
932 result
933 };
934 let mut items = ::std::vec::Vec::new();
935 for child in non_field_children {
936 items.push(<MapChildren as ::treesitter_types::FromNode>::from_node(
937 child, src,
938 )?);
939 }
940 items
941 },
942 })
943 }
944}
945impl ::treesitter_types::Spanned for Map<'_> {
946 fn span(&self) -> ::treesitter_types::Span {
947 self.span
948 }
949}
950#[derive(Debug, Clone, PartialEq, Eq)]
951pub struct MapContent<'tree> {
952 pub span: ::treesitter_types::Span,
953 pub children: ::std::vec::Vec<MapContentChildren<'tree>>,
954}
955impl<'tree> ::treesitter_types::FromNode<'tree> for MapContent<'tree> {
956 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
957 fn from_node(
958 node: ::tree_sitter::Node<'tree>,
959 src: &'tree [u8],
960 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
961 debug_assert_eq!(node.kind(), "map_content");
962 Ok(Self {
963 span: ::treesitter_types::Span::from(node),
964 children: {
965 #[allow(clippy::suspicious_else_formatting)]
966 let non_field_children = {
967 let mut cursor = node.walk();
968 let mut result = ::std::vec::Vec::new();
969 if cursor.goto_first_child() {
970 loop {
971 if cursor.field_name().is_none()
972 && cursor.node().is_named()
973 && !cursor.node().is_extra()
974 {
975 result.push(cursor.node());
976 }
977 if !cursor.goto_next_sibling() {
978 break;
979 }
980 }
981 }
982 result
983 };
984 let mut items = ::std::vec::Vec::new();
985 for child in non_field_children {
986 items.push(
987 <MapContentChildren as ::treesitter_types::FromNode>::from_node(
988 child, src,
989 )?,
990 );
991 }
992 items
993 },
994 })
995 }
996}
997impl ::treesitter_types::Spanned for MapContent<'_> {
998 fn span(&self) -> ::treesitter_types::Span {
999 self.span
1000 }
1001}
1002#[derive(Debug, Clone, PartialEq, Eq)]
1003pub struct Nil<'tree> {
1004 pub span: ::treesitter_types::Span,
1005 text: &'tree str,
1006}
1007impl<'tree> ::treesitter_types::FromNode<'tree> for Nil<'tree> {
1008 fn from_node(
1009 node: ::tree_sitter::Node<'tree>,
1010 src: &'tree [u8],
1011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1012 debug_assert_eq!(node.kind(), "nil");
1013 Ok(Self {
1014 span: ::treesitter_types::Span::from(node),
1015 text: node.utf8_text(src)?,
1016 })
1017 }
1018}
1019impl<'tree> ::treesitter_types::LeafNode<'tree> for Nil<'tree> {
1020 fn text(&self) -> &'tree str {
1021 self.text
1022 }
1023}
1024impl ::treesitter_types::Spanned for Nil<'_> {
1025 fn span(&self) -> ::treesitter_types::Span {
1026 self.span
1027 }
1028}
1029#[derive(Debug, Clone, PartialEq, Eq)]
1030pub struct OperatorIdentifier<'tree> {
1031 pub span: ::treesitter_types::Span,
1032 text: &'tree str,
1033}
1034impl<'tree> ::treesitter_types::FromNode<'tree> for OperatorIdentifier<'tree> {
1035 fn from_node(
1036 node: ::tree_sitter::Node<'tree>,
1037 src: &'tree [u8],
1038 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1039 debug_assert_eq!(node.kind(), "operator_identifier");
1040 Ok(Self {
1041 span: ::treesitter_types::Span::from(node),
1042 text: node.utf8_text(src)?,
1043 })
1044 }
1045}
1046impl<'tree> ::treesitter_types::LeafNode<'tree> for OperatorIdentifier<'tree> {
1047 fn text(&self) -> &'tree str {
1048 self.text
1049 }
1050}
1051impl ::treesitter_types::Spanned for OperatorIdentifier<'_> {
1052 fn span(&self) -> ::treesitter_types::Span {
1053 self.span
1054 }
1055}
1056#[derive(Debug, Clone, PartialEq, Eq)]
1057pub struct Pair<'tree> {
1058 pub span: ::treesitter_types::Span,
1059 pub key: PairKey<'tree>,
1060 pub value: PairValue<'tree>,
1061}
1062impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
1063 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1064 fn from_node(
1065 node: ::tree_sitter::Node<'tree>,
1066 src: &'tree [u8],
1067 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1068 debug_assert_eq!(node.kind(), "pair");
1069 Ok(Self {
1070 span: ::treesitter_types::Span::from(node),
1071 key: {
1072 let child = node
1073 .child_by_field_name("key")
1074 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
1075 <PairKey as ::treesitter_types::FromNode>::from_node(child, src)?
1076 },
1077 value: {
1078 let child = node
1079 .child_by_field_name("value")
1080 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
1081 <PairValue as ::treesitter_types::FromNode>::from_node(child, src)?
1082 },
1083 })
1084 }
1085}
1086impl ::treesitter_types::Spanned for Pair<'_> {
1087 fn span(&self) -> ::treesitter_types::Span {
1088 self.span
1089 }
1090}
1091#[derive(Debug, Clone, PartialEq, Eq)]
1092pub struct QuotedAtom<'tree> {
1093 pub span: ::treesitter_types::Span,
1094 pub quoted_end: QuotedAtomQuotedEnd,
1095 pub quoted_start: QuotedAtomQuotedStart,
1096 pub children: ::std::vec::Vec<QuotedAtomChildren<'tree>>,
1097}
1098impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedAtom<'tree> {
1099 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1100 fn from_node(
1101 node: ::tree_sitter::Node<'tree>,
1102 src: &'tree [u8],
1103 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1104 debug_assert_eq!(node.kind(), "quoted_atom");
1105 Ok(Self {
1106 span: ::treesitter_types::Span::from(node),
1107 quoted_end: {
1108 let child = node.child_by_field_name("quoted_end").ok_or_else(|| {
1109 ::treesitter_types::ParseError::missing_field("quoted_end", node)
1110 })?;
1111 <QuotedAtomQuotedEnd as ::treesitter_types::FromNode>::from_node(child, src)?
1112 },
1113 quoted_start: {
1114 let child = node.child_by_field_name("quoted_start").ok_or_else(|| {
1115 ::treesitter_types::ParseError::missing_field("quoted_start", node)
1116 })?;
1117 <QuotedAtomQuotedStart as ::treesitter_types::FromNode>::from_node(child, src)?
1118 },
1119 children: {
1120 #[allow(clippy::suspicious_else_formatting)]
1121 let non_field_children = {
1122 let mut cursor = node.walk();
1123 let mut result = ::std::vec::Vec::new();
1124 if cursor.goto_first_child() {
1125 loop {
1126 if cursor.field_name().is_none()
1127 && cursor.node().is_named()
1128 && !cursor.node().is_extra()
1129 {
1130 result.push(cursor.node());
1131 }
1132 if !cursor.goto_next_sibling() {
1133 break;
1134 }
1135 }
1136 }
1137 result
1138 };
1139 let mut items = ::std::vec::Vec::new();
1140 for child in non_field_children {
1141 items.push(
1142 <QuotedAtomChildren as ::treesitter_types::FromNode>::from_node(
1143 child, src,
1144 )?,
1145 );
1146 }
1147 items
1148 },
1149 })
1150 }
1151}
1152impl ::treesitter_types::Spanned for QuotedAtom<'_> {
1153 fn span(&self) -> ::treesitter_types::Span {
1154 self.span
1155 }
1156}
1157#[derive(Debug, Clone, PartialEq, Eq)]
1158pub struct QuotedKeyword<'tree> {
1159 pub span: ::treesitter_types::Span,
1160 pub quoted_end: QuotedKeywordQuotedEnd,
1161 pub quoted_start: QuotedKeywordQuotedStart,
1162 pub children: ::std::vec::Vec<QuotedKeywordChildren<'tree>>,
1163}
1164impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedKeyword<'tree> {
1165 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1166 fn from_node(
1167 node: ::tree_sitter::Node<'tree>,
1168 src: &'tree [u8],
1169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1170 debug_assert_eq!(node.kind(), "quoted_keyword");
1171 Ok(Self {
1172 span: ::treesitter_types::Span::from(node),
1173 quoted_end: {
1174 let child = node.child_by_field_name("quoted_end").ok_or_else(|| {
1175 ::treesitter_types::ParseError::missing_field("quoted_end", node)
1176 })?;
1177 <QuotedKeywordQuotedEnd as ::treesitter_types::FromNode>::from_node(child, src)?
1178 },
1179 quoted_start: {
1180 let child = node.child_by_field_name("quoted_start").ok_or_else(|| {
1181 ::treesitter_types::ParseError::missing_field("quoted_start", node)
1182 })?;
1183 <QuotedKeywordQuotedStart as ::treesitter_types::FromNode>::from_node(child, src)?
1184 },
1185 children: {
1186 #[allow(clippy::suspicious_else_formatting)]
1187 let non_field_children = {
1188 let mut cursor = node.walk();
1189 let mut result = ::std::vec::Vec::new();
1190 if cursor.goto_first_child() {
1191 loop {
1192 if cursor.field_name().is_none()
1193 && cursor.node().is_named()
1194 && !cursor.node().is_extra()
1195 {
1196 result.push(cursor.node());
1197 }
1198 if !cursor.goto_next_sibling() {
1199 break;
1200 }
1201 }
1202 }
1203 result
1204 };
1205 let mut items = ::std::vec::Vec::new();
1206 for child in non_field_children {
1207 items.push(
1208 <QuotedKeywordChildren as ::treesitter_types::FromNode>::from_node(
1209 child, src,
1210 )?,
1211 );
1212 }
1213 items
1214 },
1215 })
1216 }
1217}
1218impl ::treesitter_types::Spanned for QuotedKeyword<'_> {
1219 fn span(&self) -> ::treesitter_types::Span {
1220 self.span
1221 }
1222}
1223#[derive(Debug, Clone, PartialEq, Eq)]
1224pub struct RescueBlock<'tree> {
1225 pub span: ::treesitter_types::Span,
1226 pub children: ::std::vec::Vec<RescueBlockChildren<'tree>>,
1227}
1228impl<'tree> ::treesitter_types::FromNode<'tree> for RescueBlock<'tree> {
1229 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1230 fn from_node(
1231 node: ::tree_sitter::Node<'tree>,
1232 src: &'tree [u8],
1233 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1234 debug_assert_eq!(node.kind(), "rescue_block");
1235 Ok(Self {
1236 span: ::treesitter_types::Span::from(node),
1237 children: {
1238 #[allow(clippy::suspicious_else_formatting)]
1239 let non_field_children = {
1240 let mut cursor = node.walk();
1241 let mut result = ::std::vec::Vec::new();
1242 if cursor.goto_first_child() {
1243 loop {
1244 if cursor.field_name().is_none()
1245 && cursor.node().is_named()
1246 && !cursor.node().is_extra()
1247 {
1248 result.push(cursor.node());
1249 }
1250 if !cursor.goto_next_sibling() {
1251 break;
1252 }
1253 }
1254 }
1255 result
1256 };
1257 let mut items = ::std::vec::Vec::new();
1258 for child in non_field_children {
1259 items.push(
1260 <RescueBlockChildren as ::treesitter_types::FromNode>::from_node(
1261 child, src,
1262 )?,
1263 );
1264 }
1265 items
1266 },
1267 })
1268 }
1269}
1270impl ::treesitter_types::Spanned for RescueBlock<'_> {
1271 fn span(&self) -> ::treesitter_types::Span {
1272 self.span
1273 }
1274}
1275#[derive(Debug, Clone, PartialEq, Eq)]
1276pub struct Sigil<'tree> {
1277 pub span: ::treesitter_types::Span,
1278 pub quoted_end: SigilQuotedEnd,
1279 pub quoted_start: SigilQuotedStart,
1280 pub children: ::std::vec::Vec<SigilChildren<'tree>>,
1281}
1282impl<'tree> ::treesitter_types::FromNode<'tree> for Sigil<'tree> {
1283 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1284 fn from_node(
1285 node: ::tree_sitter::Node<'tree>,
1286 src: &'tree [u8],
1287 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1288 debug_assert_eq!(node.kind(), "sigil");
1289 Ok(Self {
1290 span: ::treesitter_types::Span::from(node),
1291 quoted_end: {
1292 let child = node.child_by_field_name("quoted_end").ok_or_else(|| {
1293 ::treesitter_types::ParseError::missing_field("quoted_end", node)
1294 })?;
1295 <SigilQuotedEnd as ::treesitter_types::FromNode>::from_node(child, src)?
1296 },
1297 quoted_start: {
1298 let child = node.child_by_field_name("quoted_start").ok_or_else(|| {
1299 ::treesitter_types::ParseError::missing_field("quoted_start", node)
1300 })?;
1301 <SigilQuotedStart as ::treesitter_types::FromNode>::from_node(child, src)?
1302 },
1303 children: {
1304 #[allow(clippy::suspicious_else_formatting)]
1305 let non_field_children = {
1306 let mut cursor = node.walk();
1307 let mut result = ::std::vec::Vec::new();
1308 if cursor.goto_first_child() {
1309 loop {
1310 if cursor.field_name().is_none()
1311 && cursor.node().is_named()
1312 && !cursor.node().is_extra()
1313 {
1314 result.push(cursor.node());
1315 }
1316 if !cursor.goto_next_sibling() {
1317 break;
1318 }
1319 }
1320 }
1321 result
1322 };
1323 let mut items = ::std::vec::Vec::new();
1324 for child in non_field_children {
1325 items.push(<SigilChildren as ::treesitter_types::FromNode>::from_node(
1326 child, src,
1327 )?);
1328 }
1329 items
1330 },
1331 })
1332 }
1333}
1334impl ::treesitter_types::Spanned for Sigil<'_> {
1335 fn span(&self) -> ::treesitter_types::Span {
1336 self.span
1337 }
1338}
1339#[derive(Debug, Clone, PartialEq, Eq)]
1340pub struct Source<'tree> {
1341 pub span: ::treesitter_types::Span,
1342 pub children: ::std::vec::Vec<SourceChildren<'tree>>,
1343}
1344impl<'tree> ::treesitter_types::FromNode<'tree> for Source<'tree> {
1345 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1346 fn from_node(
1347 node: ::tree_sitter::Node<'tree>,
1348 src: &'tree [u8],
1349 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1350 debug_assert_eq!(node.kind(), "source");
1351 Ok(Self {
1352 span: ::treesitter_types::Span::from(node),
1353 children: {
1354 #[allow(clippy::suspicious_else_formatting)]
1355 let non_field_children = {
1356 let mut cursor = node.walk();
1357 let mut result = ::std::vec::Vec::new();
1358 if cursor.goto_first_child() {
1359 loop {
1360 if cursor.field_name().is_none()
1361 && cursor.node().is_named()
1362 && !cursor.node().is_extra()
1363 {
1364 result.push(cursor.node());
1365 }
1366 if !cursor.goto_next_sibling() {
1367 break;
1368 }
1369 }
1370 }
1371 result
1372 };
1373 let mut items = ::std::vec::Vec::new();
1374 for child in non_field_children {
1375 items.push(<SourceChildren as ::treesitter_types::FromNode>::from_node(
1376 child, src,
1377 )?);
1378 }
1379 items
1380 },
1381 })
1382 }
1383}
1384impl ::treesitter_types::Spanned for Source<'_> {
1385 fn span(&self) -> ::treesitter_types::Span {
1386 self.span
1387 }
1388}
1389#[derive(Debug, Clone, PartialEq, Eq)]
1390pub struct StabClause<'tree> {
1391 pub span: ::treesitter_types::Span,
1392 pub left: ::core::option::Option<StabClauseLeft<'tree>>,
1393 pub operator: StabClauseOperator,
1394 pub right: ::core::option::Option<Body<'tree>>,
1395}
1396impl<'tree> ::treesitter_types::FromNode<'tree> for StabClause<'tree> {
1397 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1398 fn from_node(
1399 node: ::tree_sitter::Node<'tree>,
1400 src: &'tree [u8],
1401 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1402 debug_assert_eq!(node.kind(), "stab_clause");
1403 Ok(Self {
1404 span: ::treesitter_types::Span::from(node),
1405 left: match node.child_by_field_name("left") {
1406 Some(child) => Some(<StabClauseLeft as ::treesitter_types::FromNode>::from_node(
1407 child, src,
1408 )?),
1409 None => None,
1410 },
1411 operator: {
1412 let child = node.child_by_field_name("operator").ok_or_else(|| {
1413 ::treesitter_types::ParseError::missing_field("operator", node)
1414 })?;
1415 <StabClauseOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1416 },
1417 right: match node.child_by_field_name("right") {
1418 Some(child) => Some(<Body as ::treesitter_types::FromNode>::from_node(
1419 child, src,
1420 )?),
1421 None => None,
1422 },
1423 })
1424 }
1425}
1426impl ::treesitter_types::Spanned for StabClause<'_> {
1427 fn span(&self) -> ::treesitter_types::Span {
1428 self.span
1429 }
1430}
1431#[derive(Debug, Clone, PartialEq, Eq)]
1432pub struct String<'tree> {
1433 pub span: ::treesitter_types::Span,
1434 pub quoted_end: StringQuotedEnd,
1435 pub quoted_start: StringQuotedStart,
1436 pub children: ::std::vec::Vec<StringChildren<'tree>>,
1437}
1438impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
1439 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1440 fn from_node(
1441 node: ::tree_sitter::Node<'tree>,
1442 src: &'tree [u8],
1443 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1444 debug_assert_eq!(node.kind(), "string");
1445 Ok(Self {
1446 span: ::treesitter_types::Span::from(node),
1447 quoted_end: {
1448 let child = node.child_by_field_name("quoted_end").ok_or_else(|| {
1449 ::treesitter_types::ParseError::missing_field("quoted_end", node)
1450 })?;
1451 <StringQuotedEnd as ::treesitter_types::FromNode>::from_node(child, src)?
1452 },
1453 quoted_start: {
1454 let child = node.child_by_field_name("quoted_start").ok_or_else(|| {
1455 ::treesitter_types::ParseError::missing_field("quoted_start", node)
1456 })?;
1457 <StringQuotedStart as ::treesitter_types::FromNode>::from_node(child, src)?
1458 },
1459 children: {
1460 #[allow(clippy::suspicious_else_formatting)]
1461 let non_field_children = {
1462 let mut cursor = node.walk();
1463 let mut result = ::std::vec::Vec::new();
1464 if cursor.goto_first_child() {
1465 loop {
1466 if cursor.field_name().is_none()
1467 && cursor.node().is_named()
1468 && !cursor.node().is_extra()
1469 {
1470 result.push(cursor.node());
1471 }
1472 if !cursor.goto_next_sibling() {
1473 break;
1474 }
1475 }
1476 }
1477 result
1478 };
1479 let mut items = ::std::vec::Vec::new();
1480 for child in non_field_children {
1481 items.push(<StringChildren as ::treesitter_types::FromNode>::from_node(
1482 child, src,
1483 )?);
1484 }
1485 items
1486 },
1487 })
1488 }
1489}
1490impl ::treesitter_types::Spanned for String<'_> {
1491 fn span(&self) -> ::treesitter_types::Span {
1492 self.span
1493 }
1494}
1495#[derive(Debug, Clone, PartialEq, Eq)]
1496pub struct Struct<'tree> {
1497 pub span: ::treesitter_types::Span,
1498 pub children: StructChildren<'tree>,
1499}
1500impl<'tree> ::treesitter_types::FromNode<'tree> for Struct<'tree> {
1501 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1502 fn from_node(
1503 node: ::tree_sitter::Node<'tree>,
1504 src: &'tree [u8],
1505 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1506 debug_assert_eq!(node.kind(), "struct");
1507 Ok(Self {
1508 span: ::treesitter_types::Span::from(node),
1509 children: {
1510 #[allow(clippy::suspicious_else_formatting)]
1511 let non_field_children = {
1512 let mut cursor = node.walk();
1513 let mut result = ::std::vec::Vec::new();
1514 if cursor.goto_first_child() {
1515 loop {
1516 if cursor.field_name().is_none()
1517 && cursor.node().is_named()
1518 && !cursor.node().is_extra()
1519 {
1520 result.push(cursor.node());
1521 }
1522 if !cursor.goto_next_sibling() {
1523 break;
1524 }
1525 }
1526 }
1527 result
1528 };
1529 let child = if let Some(&c) = non_field_children.first() {
1530 c
1531 } else {
1532 let mut fallback_cursor = node.walk();
1533 let mut fallback_child = None;
1534 if fallback_cursor.goto_first_child() {
1535 loop {
1536 if fallback_cursor.field_name().is_none()
1537 && !fallback_cursor.node().is_extra()
1538 {
1539 let candidate = fallback_cursor.node();
1540 #[allow(clippy::needless_question_mark)]
1541 if (|| -> ::core::result::Result<
1542 _,
1543 ::treesitter_types::ParseError,
1544 > {
1545 let child = candidate;
1546 Ok(
1547 <StructChildren as ::treesitter_types::FromNode>::from_node(
1548 child,
1549 src,
1550 )?,
1551 )
1552 })()
1553 .is_ok()
1554 {
1555 fallback_child = Some(candidate);
1556 break;
1557 }
1558 }
1559 if !fallback_cursor.goto_next_sibling() {
1560 break;
1561 }
1562 }
1563 }
1564 if fallback_child.is_none() {
1565 let mut cursor2 = node.walk();
1566 if cursor2.goto_first_child() {
1567 loop {
1568 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1569 let candidate = cursor2.node();
1570 #[allow(clippy::needless_question_mark)]
1571 if (|| -> ::core::result::Result<
1572 _,
1573 ::treesitter_types::ParseError,
1574 > {
1575 let child = candidate;
1576 Ok(
1577 <StructChildren as ::treesitter_types::FromNode>::from_node(
1578 child,
1579 src,
1580 )?,
1581 )
1582 })()
1583 .is_ok()
1584 {
1585 fallback_child = Some(candidate);
1586 break;
1587 }
1588 }
1589 if !cursor2.goto_next_sibling() {
1590 break;
1591 }
1592 }
1593 }
1594 }
1595 fallback_child.ok_or_else(|| {
1596 ::treesitter_types::ParseError::missing_field("children", node)
1597 })?
1598 };
1599 <StructChildren as ::treesitter_types::FromNode>::from_node(child, src)?
1600 },
1601 })
1602 }
1603}
1604impl ::treesitter_types::Spanned for Struct<'_> {
1605 fn span(&self) -> ::treesitter_types::Span {
1606 self.span
1607 }
1608}
1609#[derive(Debug, Clone, PartialEq, Eq)]
1610pub struct Tuple<'tree> {
1611 pub span: ::treesitter_types::Span,
1612 pub children: ::std::vec::Vec<TupleChildren<'tree>>,
1613}
1614impl<'tree> ::treesitter_types::FromNode<'tree> for Tuple<'tree> {
1615 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1616 fn from_node(
1617 node: ::tree_sitter::Node<'tree>,
1618 src: &'tree [u8],
1619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1620 debug_assert_eq!(node.kind(), "tuple");
1621 Ok(Self {
1622 span: ::treesitter_types::Span::from(node),
1623 children: {
1624 #[allow(clippy::suspicious_else_formatting)]
1625 let non_field_children = {
1626 let mut cursor = node.walk();
1627 let mut result = ::std::vec::Vec::new();
1628 if cursor.goto_first_child() {
1629 loop {
1630 if cursor.field_name().is_none()
1631 && cursor.node().is_named()
1632 && !cursor.node().is_extra()
1633 {
1634 result.push(cursor.node());
1635 }
1636 if !cursor.goto_next_sibling() {
1637 break;
1638 }
1639 }
1640 }
1641 result
1642 };
1643 let mut items = ::std::vec::Vec::new();
1644 for child in non_field_children {
1645 items.push(<TupleChildren as ::treesitter_types::FromNode>::from_node(
1646 child, src,
1647 )?);
1648 }
1649 items
1650 },
1651 })
1652 }
1653}
1654impl ::treesitter_types::Spanned for Tuple<'_> {
1655 fn span(&self) -> ::treesitter_types::Span {
1656 self.span
1657 }
1658}
1659#[derive(Debug, Clone, PartialEq, Eq)]
1660pub struct UnaryOperator<'tree> {
1661 pub span: ::treesitter_types::Span,
1662 pub operand: ::std::vec::Vec<UnaryOperatorOperand<'tree>>,
1663 pub operator: UnaryOperatorOperator,
1664}
1665impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperator<'tree> {
1666 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1667 fn from_node(
1668 node: ::tree_sitter::Node<'tree>,
1669 src: &'tree [u8],
1670 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1671 debug_assert_eq!(node.kind(), "unary_operator");
1672 Ok(Self {
1673 span: ::treesitter_types::Span::from(node),
1674 operand: {
1675 let mut cursor = node.walk();
1676 let mut items = ::std::vec::Vec::new();
1677 for child in node.children_by_field_name("operand", &mut cursor) {
1678 items.push(
1679 <UnaryOperatorOperand as ::treesitter_types::FromNode>::from_node(
1680 child, src,
1681 )?,
1682 );
1683 }
1684 items
1685 },
1686 operator: {
1687 let child = node.child_by_field_name("operator").ok_or_else(|| {
1688 ::treesitter_types::ParseError::missing_field("operator", node)
1689 })?;
1690 <UnaryOperatorOperator as ::treesitter_types::FromNode>::from_node(child, src)?
1691 },
1692 })
1693 }
1694}
1695impl ::treesitter_types::Spanned for UnaryOperator<'_> {
1696 fn span(&self) -> ::treesitter_types::Span {
1697 self.span
1698 }
1699}
1700#[derive(Debug, Clone, PartialEq, Eq)]
1701pub struct Alias<'tree> {
1702 pub span: ::treesitter_types::Span,
1703 text: &'tree str,
1704}
1705impl<'tree> ::treesitter_types::FromNode<'tree> for Alias<'tree> {
1706 fn from_node(
1707 node: ::tree_sitter::Node<'tree>,
1708 src: &'tree [u8],
1709 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1710 debug_assert_eq!(node.kind(), "alias");
1711 Ok(Self {
1712 span: ::treesitter_types::Span::from(node),
1713 text: node.utf8_text(src)?,
1714 })
1715 }
1716}
1717impl<'tree> ::treesitter_types::LeafNode<'tree> for Alias<'tree> {
1718 fn text(&self) -> &'tree str {
1719 self.text
1720 }
1721}
1722impl ::treesitter_types::Spanned for Alias<'_> {
1723 fn span(&self) -> ::treesitter_types::Span {
1724 self.span
1725 }
1726}
1727#[derive(Debug, Clone, PartialEq, Eq)]
1728pub struct Atom<'tree> {
1729 pub span: ::treesitter_types::Span,
1730 text: &'tree str,
1731}
1732impl<'tree> ::treesitter_types::FromNode<'tree> for Atom<'tree> {
1733 fn from_node(
1734 node: ::tree_sitter::Node<'tree>,
1735 src: &'tree [u8],
1736 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1737 debug_assert_eq!(node.kind(), "atom");
1738 Ok(Self {
1739 span: ::treesitter_types::Span::from(node),
1740 text: node.utf8_text(src)?,
1741 })
1742 }
1743}
1744impl<'tree> ::treesitter_types::LeafNode<'tree> for Atom<'tree> {
1745 fn text(&self) -> &'tree str {
1746 self.text
1747 }
1748}
1749impl ::treesitter_types::Spanned for Atom<'_> {
1750 fn span(&self) -> ::treesitter_types::Span {
1751 self.span
1752 }
1753}
1754#[derive(Debug, Clone, PartialEq, Eq)]
1755pub struct Char<'tree> {
1756 pub span: ::treesitter_types::Span,
1757 text: &'tree str,
1758}
1759impl<'tree> ::treesitter_types::FromNode<'tree> for Char<'tree> {
1760 fn from_node(
1761 node: ::tree_sitter::Node<'tree>,
1762 src: &'tree [u8],
1763 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1764 debug_assert_eq!(node.kind(), "char");
1765 Ok(Self {
1766 span: ::treesitter_types::Span::from(node),
1767 text: node.utf8_text(src)?,
1768 })
1769 }
1770}
1771impl<'tree> ::treesitter_types::LeafNode<'tree> for Char<'tree> {
1772 fn text(&self) -> &'tree str {
1773 self.text
1774 }
1775}
1776impl ::treesitter_types::Spanned for Char<'_> {
1777 fn span(&self) -> ::treesitter_types::Span {
1778 self.span
1779 }
1780}
1781#[derive(Debug, Clone, PartialEq, Eq)]
1782pub struct Comment<'tree> {
1783 pub span: ::treesitter_types::Span,
1784 text: &'tree str,
1785}
1786impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
1787 fn from_node(
1788 node: ::tree_sitter::Node<'tree>,
1789 src: &'tree [u8],
1790 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1791 debug_assert_eq!(node.kind(), "comment");
1792 Ok(Self {
1793 span: ::treesitter_types::Span::from(node),
1794 text: node.utf8_text(src)?,
1795 })
1796 }
1797}
1798impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
1799 fn text(&self) -> &'tree str {
1800 self.text
1801 }
1802}
1803impl ::treesitter_types::Spanned for Comment<'_> {
1804 fn span(&self) -> ::treesitter_types::Span {
1805 self.span
1806 }
1807}
1808#[derive(Debug, Clone, PartialEq, Eq)]
1809pub struct EscapeSequence<'tree> {
1810 pub span: ::treesitter_types::Span,
1811 text: &'tree str,
1812}
1813impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
1814 fn from_node(
1815 node: ::tree_sitter::Node<'tree>,
1816 src: &'tree [u8],
1817 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1818 debug_assert_eq!(node.kind(), "escape_sequence");
1819 Ok(Self {
1820 span: ::treesitter_types::Span::from(node),
1821 text: node.utf8_text(src)?,
1822 })
1823 }
1824}
1825impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
1826 fn text(&self) -> &'tree str {
1827 self.text
1828 }
1829}
1830impl ::treesitter_types::Spanned for EscapeSequence<'_> {
1831 fn span(&self) -> ::treesitter_types::Span {
1832 self.span
1833 }
1834}
1835#[derive(Debug, Clone, PartialEq, Eq)]
1836pub struct Float<'tree> {
1837 pub span: ::treesitter_types::Span,
1838 text: &'tree str,
1839}
1840impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
1841 fn from_node(
1842 node: ::tree_sitter::Node<'tree>,
1843 src: &'tree [u8],
1844 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1845 debug_assert_eq!(node.kind(), "float");
1846 Ok(Self {
1847 span: ::treesitter_types::Span::from(node),
1848 text: node.utf8_text(src)?,
1849 })
1850 }
1851}
1852impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
1853 fn text(&self) -> &'tree str {
1854 self.text
1855 }
1856}
1857impl ::treesitter_types::Spanned for Float<'_> {
1858 fn span(&self) -> ::treesitter_types::Span {
1859 self.span
1860 }
1861}
1862#[derive(Debug, Clone, PartialEq, Eq)]
1863pub struct Integer<'tree> {
1864 pub span: ::treesitter_types::Span,
1865 text: &'tree str,
1866}
1867impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
1868 fn from_node(
1869 node: ::tree_sitter::Node<'tree>,
1870 src: &'tree [u8],
1871 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1872 debug_assert_eq!(node.kind(), "integer");
1873 Ok(Self {
1874 span: ::treesitter_types::Span::from(node),
1875 text: node.utf8_text(src)?,
1876 })
1877 }
1878}
1879impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
1880 fn text(&self) -> &'tree str {
1881 self.text
1882 }
1883}
1884impl ::treesitter_types::Spanned for Integer<'_> {
1885 fn span(&self) -> ::treesitter_types::Span {
1886 self.span
1887 }
1888}
1889#[derive(Debug, Clone, PartialEq, Eq)]
1890pub struct Keyword<'tree> {
1891 pub span: ::treesitter_types::Span,
1892 text: &'tree str,
1893}
1894impl<'tree> ::treesitter_types::FromNode<'tree> for Keyword<'tree> {
1895 fn from_node(
1896 node: ::tree_sitter::Node<'tree>,
1897 src: &'tree [u8],
1898 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1899 debug_assert_eq!(node.kind(), "keyword");
1900 Ok(Self {
1901 span: ::treesitter_types::Span::from(node),
1902 text: node.utf8_text(src)?,
1903 })
1904 }
1905}
1906impl<'tree> ::treesitter_types::LeafNode<'tree> for Keyword<'tree> {
1907 fn text(&self) -> &'tree str {
1908 self.text
1909 }
1910}
1911impl ::treesitter_types::Spanned for Keyword<'_> {
1912 fn span(&self) -> ::treesitter_types::Span {
1913 self.span
1914 }
1915}
1916#[derive(Debug, Clone, PartialEq, Eq)]
1917pub struct QuotedContent<'tree> {
1918 pub span: ::treesitter_types::Span,
1919 text: &'tree str,
1920}
1921impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedContent<'tree> {
1922 fn from_node(
1923 node: ::tree_sitter::Node<'tree>,
1924 src: &'tree [u8],
1925 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1926 debug_assert_eq!(node.kind(), "quoted_content");
1927 Ok(Self {
1928 span: ::treesitter_types::Span::from(node),
1929 text: node.utf8_text(src)?,
1930 })
1931 }
1932}
1933impl<'tree> ::treesitter_types::LeafNode<'tree> for QuotedContent<'tree> {
1934 fn text(&self) -> &'tree str {
1935 self.text
1936 }
1937}
1938impl ::treesitter_types::Spanned for QuotedContent<'_> {
1939 fn span(&self) -> ::treesitter_types::Span {
1940 self.span
1941 }
1942}
1943#[derive(Debug, Clone, PartialEq, Eq)]
1944pub struct SigilModifiers<'tree> {
1945 pub span: ::treesitter_types::Span,
1946 text: &'tree str,
1947}
1948impl<'tree> ::treesitter_types::FromNode<'tree> for SigilModifiers<'tree> {
1949 fn from_node(
1950 node: ::tree_sitter::Node<'tree>,
1951 src: &'tree [u8],
1952 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1953 debug_assert_eq!(node.kind(), "sigil_modifiers");
1954 Ok(Self {
1955 span: ::treesitter_types::Span::from(node),
1956 text: node.utf8_text(src)?,
1957 })
1958 }
1959}
1960impl<'tree> ::treesitter_types::LeafNode<'tree> for SigilModifiers<'tree> {
1961 fn text(&self) -> &'tree str {
1962 self.text
1963 }
1964}
1965impl ::treesitter_types::Spanned for SigilModifiers<'_> {
1966 fn span(&self) -> ::treesitter_types::Span {
1967 self.span
1968 }
1969}
1970#[derive(Debug, Clone, PartialEq, Eq)]
1971pub struct SigilName<'tree> {
1972 pub span: ::treesitter_types::Span,
1973 text: &'tree str,
1974}
1975impl<'tree> ::treesitter_types::FromNode<'tree> for SigilName<'tree> {
1976 fn from_node(
1977 node: ::tree_sitter::Node<'tree>,
1978 src: &'tree [u8],
1979 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1980 debug_assert_eq!(node.kind(), "sigil_name");
1981 Ok(Self {
1982 span: ::treesitter_types::Span::from(node),
1983 text: node.utf8_text(src)?,
1984 })
1985 }
1986}
1987impl<'tree> ::treesitter_types::LeafNode<'tree> for SigilName<'tree> {
1988 fn text(&self) -> &'tree str {
1989 self.text
1990 }
1991}
1992impl ::treesitter_types::Spanned for SigilName<'_> {
1993 fn span(&self) -> ::treesitter_types::Span {
1994 self.span
1995 }
1996}
1997#[derive(Debug, Clone, PartialEq, Eq)]
1998pub enum AccessCallKey<'tree> {
1999 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2000 Alias(::std::boxed::Box<Alias<'tree>>),
2001 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2002 Atom(::std::boxed::Box<Atom<'tree>>),
2003 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2004 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2005 Block(::std::boxed::Box<Block<'tree>>),
2006 Boolean(::std::boxed::Box<Boolean<'tree>>),
2007 Call(::std::boxed::Box<Call<'tree>>),
2008 Char(::std::boxed::Box<Char<'tree>>),
2009 Charlist(::std::boxed::Box<Charlist<'tree>>),
2010 Dot(::std::boxed::Box<Dot<'tree>>),
2011 Float(::std::boxed::Box<Float<'tree>>),
2012 Identifier(::std::boxed::Box<Identifier<'tree>>),
2013 Integer(::std::boxed::Box<Integer<'tree>>),
2014 List(::std::boxed::Box<List<'tree>>),
2015 Map(::std::boxed::Box<Map<'tree>>),
2016 Nil(::std::boxed::Box<Nil<'tree>>),
2017 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2018 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2019 Sigil(::std::boxed::Box<Sigil<'tree>>),
2020 String(::std::boxed::Box<String<'tree>>),
2021 Tuple(::std::boxed::Box<Tuple<'tree>>),
2022 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2023}
2024impl<'tree> ::treesitter_types::FromNode<'tree> for AccessCallKey<'tree> {
2025 #[allow(clippy::collapsible_else_if)]
2026 fn from_node(
2027 node: ::tree_sitter::Node<'tree>,
2028 src: &'tree [u8],
2029 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2030 match node.kind() {
2031 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2032 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2033 ))),
2034 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2035 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2036 ))),
2037 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2038 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2039 ))),
2040 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2041 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2042 ))),
2043 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2044 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2045 ))),
2046 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2047 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2048 ))),
2049 "block" => Ok(Self::Block(::std::boxed::Box::new(
2050 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2051 ))),
2052 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2053 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2054 ))),
2055 "call" => Ok(Self::Call(::std::boxed::Box::new(
2056 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2057 ))),
2058 "char" => Ok(Self::Char(::std::boxed::Box::new(
2059 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2060 ))),
2061 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2062 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2063 ))),
2064 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2065 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2066 ))),
2067 "float" => Ok(Self::Float(::std::boxed::Box::new(
2068 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2069 ))),
2070 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2071 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2072 ))),
2073 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2074 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2075 ))),
2076 "list" => Ok(Self::List(::std::boxed::Box::new(
2077 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2078 ))),
2079 "map" => Ok(Self::Map(::std::boxed::Box::new(
2080 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2081 ))),
2082 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2083 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2084 ))),
2085 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2086 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2087 ))),
2088 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2089 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2090 ))),
2091 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2092 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2093 ))),
2094 "string" => Ok(Self::String(::std::boxed::Box::new(
2095 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2096 ))),
2097 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2098 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2099 ))),
2100 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2101 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2102 ))),
2103 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2104 }
2105 }
2106}
2107impl ::treesitter_types::Spanned for AccessCallKey<'_> {
2108 fn span(&self) -> ::treesitter_types::Span {
2109 match self {
2110 Self::AccessCall(inner) => inner.span(),
2111 Self::Alias(inner) => inner.span(),
2112 Self::AnonymousFunction(inner) => inner.span(),
2113 Self::Atom(inner) => inner.span(),
2114 Self::BinaryOperator(inner) => inner.span(),
2115 Self::Bitstring(inner) => inner.span(),
2116 Self::Block(inner) => inner.span(),
2117 Self::Boolean(inner) => inner.span(),
2118 Self::Call(inner) => inner.span(),
2119 Self::Char(inner) => inner.span(),
2120 Self::Charlist(inner) => inner.span(),
2121 Self::Dot(inner) => inner.span(),
2122 Self::Float(inner) => inner.span(),
2123 Self::Identifier(inner) => inner.span(),
2124 Self::Integer(inner) => inner.span(),
2125 Self::List(inner) => inner.span(),
2126 Self::Map(inner) => inner.span(),
2127 Self::Nil(inner) => inner.span(),
2128 Self::OperatorIdentifier(inner) => inner.span(),
2129 Self::QuotedAtom(inner) => inner.span(),
2130 Self::Sigil(inner) => inner.span(),
2131 Self::String(inner) => inner.span(),
2132 Self::Tuple(inner) => inner.span(),
2133 Self::UnaryOperator(inner) => inner.span(),
2134 }
2135 }
2136}
2137#[derive(Debug, Clone, PartialEq, Eq)]
2138pub enum AccessCallTarget<'tree> {
2139 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2140 Alias(::std::boxed::Box<Alias<'tree>>),
2141 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2142 Atom(::std::boxed::Box<Atom<'tree>>),
2143 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2144 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2145 Block(::std::boxed::Box<Block<'tree>>),
2146 Boolean(::std::boxed::Box<Boolean<'tree>>),
2147 Call(::std::boxed::Box<Call<'tree>>),
2148 Char(::std::boxed::Box<Char<'tree>>),
2149 Charlist(::std::boxed::Box<Charlist<'tree>>),
2150 Dot(::std::boxed::Box<Dot<'tree>>),
2151 Float(::std::boxed::Box<Float<'tree>>),
2152 Identifier(::std::boxed::Box<Identifier<'tree>>),
2153 Integer(::std::boxed::Box<Integer<'tree>>),
2154 List(::std::boxed::Box<List<'tree>>),
2155 Map(::std::boxed::Box<Map<'tree>>),
2156 Nil(::std::boxed::Box<Nil<'tree>>),
2157 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2158 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2159 Sigil(::std::boxed::Box<Sigil<'tree>>),
2160 String(::std::boxed::Box<String<'tree>>),
2161 Tuple(::std::boxed::Box<Tuple<'tree>>),
2162 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2163}
2164impl<'tree> ::treesitter_types::FromNode<'tree> for AccessCallTarget<'tree> {
2165 #[allow(clippy::collapsible_else_if)]
2166 fn from_node(
2167 node: ::tree_sitter::Node<'tree>,
2168 src: &'tree [u8],
2169 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2170 match node.kind() {
2171 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2172 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2173 ))),
2174 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2175 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2176 ))),
2177 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2178 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2179 ))),
2180 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2181 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2182 ))),
2183 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2184 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2185 ))),
2186 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2187 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2188 ))),
2189 "block" => Ok(Self::Block(::std::boxed::Box::new(
2190 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2191 ))),
2192 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2193 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2194 ))),
2195 "call" => Ok(Self::Call(::std::boxed::Box::new(
2196 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2197 ))),
2198 "char" => Ok(Self::Char(::std::boxed::Box::new(
2199 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2200 ))),
2201 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2202 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2203 ))),
2204 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2205 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2206 ))),
2207 "float" => Ok(Self::Float(::std::boxed::Box::new(
2208 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2209 ))),
2210 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2211 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2212 ))),
2213 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2214 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2215 ))),
2216 "list" => Ok(Self::List(::std::boxed::Box::new(
2217 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2218 ))),
2219 "map" => Ok(Self::Map(::std::boxed::Box::new(
2220 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2221 ))),
2222 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2223 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2224 ))),
2225 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2226 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2227 ))),
2228 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2229 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2230 ))),
2231 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2232 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2233 ))),
2234 "string" => Ok(Self::String(::std::boxed::Box::new(
2235 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2236 ))),
2237 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2238 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2239 ))),
2240 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2241 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2242 ))),
2243 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2244 }
2245 }
2246}
2247impl ::treesitter_types::Spanned for AccessCallTarget<'_> {
2248 fn span(&self) -> ::treesitter_types::Span {
2249 match self {
2250 Self::AccessCall(inner) => inner.span(),
2251 Self::Alias(inner) => inner.span(),
2252 Self::AnonymousFunction(inner) => inner.span(),
2253 Self::Atom(inner) => inner.span(),
2254 Self::BinaryOperator(inner) => inner.span(),
2255 Self::Bitstring(inner) => inner.span(),
2256 Self::Block(inner) => inner.span(),
2257 Self::Boolean(inner) => inner.span(),
2258 Self::Call(inner) => inner.span(),
2259 Self::Char(inner) => inner.span(),
2260 Self::Charlist(inner) => inner.span(),
2261 Self::Dot(inner) => inner.span(),
2262 Self::Float(inner) => inner.span(),
2263 Self::Identifier(inner) => inner.span(),
2264 Self::Integer(inner) => inner.span(),
2265 Self::List(inner) => inner.span(),
2266 Self::Map(inner) => inner.span(),
2267 Self::Nil(inner) => inner.span(),
2268 Self::OperatorIdentifier(inner) => inner.span(),
2269 Self::QuotedAtom(inner) => inner.span(),
2270 Self::Sigil(inner) => inner.span(),
2271 Self::String(inner) => inner.span(),
2272 Self::Tuple(inner) => inner.span(),
2273 Self::UnaryOperator(inner) => inner.span(),
2274 }
2275 }
2276}
2277#[derive(Debug, Clone, PartialEq, Eq)]
2278pub enum AfterBlockChildren<'tree> {
2279 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2280 Alias(::std::boxed::Box<Alias<'tree>>),
2281 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2282 Atom(::std::boxed::Box<Atom<'tree>>),
2283 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2284 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2285 Block(::std::boxed::Box<Block<'tree>>),
2286 Boolean(::std::boxed::Box<Boolean<'tree>>),
2287 Call(::std::boxed::Box<Call<'tree>>),
2288 Char(::std::boxed::Box<Char<'tree>>),
2289 Charlist(::std::boxed::Box<Charlist<'tree>>),
2290 Dot(::std::boxed::Box<Dot<'tree>>),
2291 Float(::std::boxed::Box<Float<'tree>>),
2292 Identifier(::std::boxed::Box<Identifier<'tree>>),
2293 Integer(::std::boxed::Box<Integer<'tree>>),
2294 List(::std::boxed::Box<List<'tree>>),
2295 Map(::std::boxed::Box<Map<'tree>>),
2296 Nil(::std::boxed::Box<Nil<'tree>>),
2297 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2298 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2299 Sigil(::std::boxed::Box<Sigil<'tree>>),
2300 StabClause(::std::boxed::Box<StabClause<'tree>>),
2301 String(::std::boxed::Box<String<'tree>>),
2302 Tuple(::std::boxed::Box<Tuple<'tree>>),
2303 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2304}
2305impl<'tree> ::treesitter_types::FromNode<'tree> for AfterBlockChildren<'tree> {
2306 #[allow(clippy::collapsible_else_if)]
2307 fn from_node(
2308 node: ::tree_sitter::Node<'tree>,
2309 src: &'tree [u8],
2310 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2311 match node.kind() {
2312 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2313 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2314 ))),
2315 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2316 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2317 ))),
2318 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2319 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2320 ))),
2321 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2322 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2323 ))),
2324 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2325 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2326 ))),
2327 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2328 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2329 ))),
2330 "block" => Ok(Self::Block(::std::boxed::Box::new(
2331 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2332 ))),
2333 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2334 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2335 ))),
2336 "call" => Ok(Self::Call(::std::boxed::Box::new(
2337 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2338 ))),
2339 "char" => Ok(Self::Char(::std::boxed::Box::new(
2340 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2341 ))),
2342 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2343 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2344 ))),
2345 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2346 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2347 ))),
2348 "float" => Ok(Self::Float(::std::boxed::Box::new(
2349 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2350 ))),
2351 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2352 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2353 ))),
2354 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2355 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2356 ))),
2357 "list" => Ok(Self::List(::std::boxed::Box::new(
2358 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2359 ))),
2360 "map" => Ok(Self::Map(::std::boxed::Box::new(
2361 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2362 ))),
2363 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2364 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2365 ))),
2366 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2367 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2368 ))),
2369 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2370 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2371 ))),
2372 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2373 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2374 ))),
2375 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
2376 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
2377 ))),
2378 "string" => Ok(Self::String(::std::boxed::Box::new(
2379 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2380 ))),
2381 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2382 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2383 ))),
2384 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2385 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2386 ))),
2387 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2388 }
2389 }
2390}
2391impl ::treesitter_types::Spanned for AfterBlockChildren<'_> {
2392 fn span(&self) -> ::treesitter_types::Span {
2393 match self {
2394 Self::AccessCall(inner) => inner.span(),
2395 Self::Alias(inner) => inner.span(),
2396 Self::AnonymousFunction(inner) => inner.span(),
2397 Self::Atom(inner) => inner.span(),
2398 Self::BinaryOperator(inner) => inner.span(),
2399 Self::Bitstring(inner) => inner.span(),
2400 Self::Block(inner) => inner.span(),
2401 Self::Boolean(inner) => inner.span(),
2402 Self::Call(inner) => inner.span(),
2403 Self::Char(inner) => inner.span(),
2404 Self::Charlist(inner) => inner.span(),
2405 Self::Dot(inner) => inner.span(),
2406 Self::Float(inner) => inner.span(),
2407 Self::Identifier(inner) => inner.span(),
2408 Self::Integer(inner) => inner.span(),
2409 Self::List(inner) => inner.span(),
2410 Self::Map(inner) => inner.span(),
2411 Self::Nil(inner) => inner.span(),
2412 Self::OperatorIdentifier(inner) => inner.span(),
2413 Self::QuotedAtom(inner) => inner.span(),
2414 Self::Sigil(inner) => inner.span(),
2415 Self::StabClause(inner) => inner.span(),
2416 Self::String(inner) => inner.span(),
2417 Self::Tuple(inner) => inner.span(),
2418 Self::UnaryOperator(inner) => inner.span(),
2419 }
2420 }
2421}
2422#[derive(Debug, Clone, PartialEq, Eq)]
2423pub enum ArgumentsChildren<'tree> {
2424 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2425 Alias(::std::boxed::Box<Alias<'tree>>),
2426 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2427 Atom(::std::boxed::Box<Atom<'tree>>),
2428 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2429 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2430 Block(::std::boxed::Box<Block<'tree>>),
2431 Boolean(::std::boxed::Box<Boolean<'tree>>),
2432 Call(::std::boxed::Box<Call<'tree>>),
2433 Char(::std::boxed::Box<Char<'tree>>),
2434 Charlist(::std::boxed::Box<Charlist<'tree>>),
2435 Dot(::std::boxed::Box<Dot<'tree>>),
2436 Float(::std::boxed::Box<Float<'tree>>),
2437 Identifier(::std::boxed::Box<Identifier<'tree>>),
2438 Integer(::std::boxed::Box<Integer<'tree>>),
2439 Keywords(::std::boxed::Box<Keywords<'tree>>),
2440 List(::std::boxed::Box<List<'tree>>),
2441 Map(::std::boxed::Box<Map<'tree>>),
2442 Nil(::std::boxed::Box<Nil<'tree>>),
2443 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2444 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2445 Sigil(::std::boxed::Box<Sigil<'tree>>),
2446 String(::std::boxed::Box<String<'tree>>),
2447 Tuple(::std::boxed::Box<Tuple<'tree>>),
2448 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2449}
2450impl<'tree> ::treesitter_types::FromNode<'tree> for ArgumentsChildren<'tree> {
2451 #[allow(clippy::collapsible_else_if)]
2452 fn from_node(
2453 node: ::tree_sitter::Node<'tree>,
2454 src: &'tree [u8],
2455 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2456 match node.kind() {
2457 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2458 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2459 ))),
2460 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2461 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2462 ))),
2463 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2464 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2465 ))),
2466 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2467 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2468 ))),
2469 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2470 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2471 ))),
2472 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2473 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2474 ))),
2475 "block" => Ok(Self::Block(::std::boxed::Box::new(
2476 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2477 ))),
2478 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2479 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2480 ))),
2481 "call" => Ok(Self::Call(::std::boxed::Box::new(
2482 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2483 ))),
2484 "char" => Ok(Self::Char(::std::boxed::Box::new(
2485 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2486 ))),
2487 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2488 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2489 ))),
2490 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2491 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2492 ))),
2493 "float" => Ok(Self::Float(::std::boxed::Box::new(
2494 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2495 ))),
2496 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2497 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2498 ))),
2499 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2500 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2501 ))),
2502 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
2503 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
2504 ))),
2505 "list" => Ok(Self::List(::std::boxed::Box::new(
2506 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2507 ))),
2508 "map" => Ok(Self::Map(::std::boxed::Box::new(
2509 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2510 ))),
2511 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2512 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2513 ))),
2514 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2515 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2516 ))),
2517 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2518 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2519 ))),
2520 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2521 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2522 ))),
2523 "string" => Ok(Self::String(::std::boxed::Box::new(
2524 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2525 ))),
2526 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2527 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2528 ))),
2529 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2530 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2531 ))),
2532 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2533 }
2534 }
2535}
2536impl ::treesitter_types::Spanned for ArgumentsChildren<'_> {
2537 fn span(&self) -> ::treesitter_types::Span {
2538 match self {
2539 Self::AccessCall(inner) => inner.span(),
2540 Self::Alias(inner) => inner.span(),
2541 Self::AnonymousFunction(inner) => inner.span(),
2542 Self::Atom(inner) => inner.span(),
2543 Self::BinaryOperator(inner) => inner.span(),
2544 Self::Bitstring(inner) => inner.span(),
2545 Self::Block(inner) => inner.span(),
2546 Self::Boolean(inner) => inner.span(),
2547 Self::Call(inner) => inner.span(),
2548 Self::Char(inner) => inner.span(),
2549 Self::Charlist(inner) => inner.span(),
2550 Self::Dot(inner) => inner.span(),
2551 Self::Float(inner) => inner.span(),
2552 Self::Identifier(inner) => inner.span(),
2553 Self::Integer(inner) => inner.span(),
2554 Self::Keywords(inner) => inner.span(),
2555 Self::List(inner) => inner.span(),
2556 Self::Map(inner) => inner.span(),
2557 Self::Nil(inner) => inner.span(),
2558 Self::OperatorIdentifier(inner) => inner.span(),
2559 Self::QuotedAtom(inner) => inner.span(),
2560 Self::Sigil(inner) => inner.span(),
2561 Self::String(inner) => inner.span(),
2562 Self::Tuple(inner) => inner.span(),
2563 Self::UnaryOperator(inner) => inner.span(),
2564 }
2565 }
2566}
2567#[derive(Debug, Clone, PartialEq, Eq)]
2568pub enum BinaryOperatorLeft<'tree> {
2569 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2570 Alias(::std::boxed::Box<Alias<'tree>>),
2571 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2572 Arguments(::std::boxed::Box<Arguments<'tree>>),
2573 Atom(::std::boxed::Box<Atom<'tree>>),
2574 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2575 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2576 Block(::std::boxed::Box<Block<'tree>>),
2577 Boolean(::std::boxed::Box<Boolean<'tree>>),
2578 Call(::std::boxed::Box<Call<'tree>>),
2579 Char(::std::boxed::Box<Char<'tree>>),
2580 Charlist(::std::boxed::Box<Charlist<'tree>>),
2581 Dot(::std::boxed::Box<Dot<'tree>>),
2582 Float(::std::boxed::Box<Float<'tree>>),
2583 Identifier(::std::boxed::Box<Identifier<'tree>>),
2584 Integer(::std::boxed::Box<Integer<'tree>>),
2585 List(::std::boxed::Box<List<'tree>>),
2586 Map(::std::boxed::Box<Map<'tree>>),
2587 Nil(::std::boxed::Box<Nil<'tree>>),
2588 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2589 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2590 Sigil(::std::boxed::Box<Sigil<'tree>>),
2591 String(::std::boxed::Box<String<'tree>>),
2592 Tuple(::std::boxed::Box<Tuple<'tree>>),
2593 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2594}
2595impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperatorLeft<'tree> {
2596 #[allow(clippy::collapsible_else_if)]
2597 fn from_node(
2598 node: ::tree_sitter::Node<'tree>,
2599 src: &'tree [u8],
2600 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2601 match node.kind() {
2602 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2603 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2604 ))),
2605 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2606 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2607 ))),
2608 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2609 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2610 ))),
2611 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
2612 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
2613 ))),
2614 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2615 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2616 ))),
2617 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2618 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2619 ))),
2620 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2621 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2622 ))),
2623 "block" => Ok(Self::Block(::std::boxed::Box::new(
2624 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2625 ))),
2626 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2627 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2628 ))),
2629 "call" => Ok(Self::Call(::std::boxed::Box::new(
2630 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2631 ))),
2632 "char" => Ok(Self::Char(::std::boxed::Box::new(
2633 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2634 ))),
2635 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2636 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2637 ))),
2638 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2639 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2640 ))),
2641 "float" => Ok(Self::Float(::std::boxed::Box::new(
2642 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2643 ))),
2644 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2645 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2646 ))),
2647 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2648 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2649 ))),
2650 "list" => Ok(Self::List(::std::boxed::Box::new(
2651 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2652 ))),
2653 "map" => Ok(Self::Map(::std::boxed::Box::new(
2654 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2655 ))),
2656 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2657 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2658 ))),
2659 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2660 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2661 ))),
2662 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2663 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2664 ))),
2665 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2666 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2667 ))),
2668 "string" => Ok(Self::String(::std::boxed::Box::new(
2669 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2670 ))),
2671 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2672 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2673 ))),
2674 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2675 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2676 ))),
2677 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2678 }
2679 }
2680}
2681impl ::treesitter_types::Spanned for BinaryOperatorLeft<'_> {
2682 fn span(&self) -> ::treesitter_types::Span {
2683 match self {
2684 Self::AccessCall(inner) => inner.span(),
2685 Self::Alias(inner) => inner.span(),
2686 Self::AnonymousFunction(inner) => inner.span(),
2687 Self::Arguments(inner) => inner.span(),
2688 Self::Atom(inner) => inner.span(),
2689 Self::BinaryOperator(inner) => inner.span(),
2690 Self::Bitstring(inner) => inner.span(),
2691 Self::Block(inner) => inner.span(),
2692 Self::Boolean(inner) => inner.span(),
2693 Self::Call(inner) => inner.span(),
2694 Self::Char(inner) => inner.span(),
2695 Self::Charlist(inner) => inner.span(),
2696 Self::Dot(inner) => inner.span(),
2697 Self::Float(inner) => inner.span(),
2698 Self::Identifier(inner) => inner.span(),
2699 Self::Integer(inner) => inner.span(),
2700 Self::List(inner) => inner.span(),
2701 Self::Map(inner) => inner.span(),
2702 Self::Nil(inner) => inner.span(),
2703 Self::OperatorIdentifier(inner) => inner.span(),
2704 Self::QuotedAtom(inner) => inner.span(),
2705 Self::Sigil(inner) => inner.span(),
2706 Self::String(inner) => inner.span(),
2707 Self::Tuple(inner) => inner.span(),
2708 Self::UnaryOperator(inner) => inner.span(),
2709 }
2710 }
2711}
2712#[derive(Debug, Clone, PartialEq, Eq)]
2713pub enum BinaryOperatorOperator {
2714 NotEq(::treesitter_types::Span),
2715 BangEqEq(::treesitter_types::Span),
2716 AmpAmp(::treesitter_types::Span),
2717 AmpAmpAmp(::treesitter_types::Span),
2718 Star(::treesitter_types::Span),
2719 StarStar(::treesitter_types::Span),
2720 Plus(::treesitter_types::Span),
2721 PlusPlus(::treesitter_types::Span),
2722 PlusPlusPlus(::treesitter_types::Span),
2723 Minus(::treesitter_types::Span),
2724 MinusMinus(::treesitter_types::Span),
2725 MinusMinusMinus(::treesitter_types::Span),
2726 DotDot(::treesitter_types::Span),
2727 Slash(::treesitter_types::Span),
2728 SlashSlash(::treesitter_types::Span),
2729 DoubleColon(::treesitter_types::Span),
2730 Lt(::treesitter_types::Span),
2731 LArrow(::treesitter_types::Span),
2732 LtLtLt(::treesitter_types::Span),
2733 LtLtTilde(::treesitter_types::Span),
2734 LtEq(::treesitter_types::Span),
2735 LtGt(::treesitter_types::Span),
2736 LtPipeGt(::treesitter_types::Span),
2737 LtTilde(::treesitter_types::Span),
2738 LtTildeGt(::treesitter_types::Span),
2739 Eq(::treesitter_types::Span),
2740 EqEq(::treesitter_types::Span),
2741 EqEqEq(::treesitter_types::Span),
2742 FatArrow(::treesitter_types::Span),
2743 EqTilde(::treesitter_types::Span),
2744 Gt(::treesitter_types::Span),
2745 GtEq(::treesitter_types::Span),
2746 GtGtGt(::treesitter_types::Span),
2747 BackslashBackslash(::treesitter_types::Span),
2748 CaretCaretCaret(::treesitter_types::Span),
2749 And(::treesitter_types::Span),
2750 In(::treesitter_types::Span),
2751 NOTXIN(::treesitter_types::Span),
2752 Or(::treesitter_types::Span),
2753 When(::treesitter_types::Span),
2754 Pipe(::treesitter_types::Span),
2755 PipeGt(::treesitter_types::Span),
2756 PipePipe(::treesitter_types::Span),
2757 PipePipePipe(::treesitter_types::Span),
2758 TildeGt(::treesitter_types::Span),
2759 TildeGtGt(::treesitter_types::Span),
2760}
2761impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperatorOperator {
2762 #[allow(clippy::collapsible_else_if)]
2763 fn from_node(
2764 node: ::tree_sitter::Node<'tree>,
2765 _src: &'tree [u8],
2766 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2767 match node.kind() {
2768 "!=" => Ok(Self::NotEq(::treesitter_types::Span::from(node))),
2769 "!==" => Ok(Self::BangEqEq(::treesitter_types::Span::from(node))),
2770 "&&" => Ok(Self::AmpAmp(::treesitter_types::Span::from(node))),
2771 "&&&" => Ok(Self::AmpAmpAmp(::treesitter_types::Span::from(node))),
2772 "*" => Ok(Self::Star(::treesitter_types::Span::from(node))),
2773 "**" => Ok(Self::StarStar(::treesitter_types::Span::from(node))),
2774 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
2775 "++" => Ok(Self::PlusPlus(::treesitter_types::Span::from(node))),
2776 "+++" => Ok(Self::PlusPlusPlus(::treesitter_types::Span::from(node))),
2777 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
2778 "--" => Ok(Self::MinusMinus(::treesitter_types::Span::from(node))),
2779 "---" => Ok(Self::MinusMinusMinus(::treesitter_types::Span::from(node))),
2780 ".." => Ok(Self::DotDot(::treesitter_types::Span::from(node))),
2781 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
2782 "//" => Ok(Self::SlashSlash(::treesitter_types::Span::from(node))),
2783 "::" => Ok(Self::DoubleColon(::treesitter_types::Span::from(node))),
2784 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
2785 "<-" => Ok(Self::LArrow(::treesitter_types::Span::from(node))),
2786 "<<<" => Ok(Self::LtLtLt(::treesitter_types::Span::from(node))),
2787 "<<~" => Ok(Self::LtLtTilde(::treesitter_types::Span::from(node))),
2788 "<=" => Ok(Self::LtEq(::treesitter_types::Span::from(node))),
2789 "<>" => Ok(Self::LtGt(::treesitter_types::Span::from(node))),
2790 "<|>" => Ok(Self::LtPipeGt(::treesitter_types::Span::from(node))),
2791 "<~" => Ok(Self::LtTilde(::treesitter_types::Span::from(node))),
2792 "<~>" => Ok(Self::LtTildeGt(::treesitter_types::Span::from(node))),
2793 "=" => Ok(Self::Eq(::treesitter_types::Span::from(node))),
2794 "==" => Ok(Self::EqEq(::treesitter_types::Span::from(node))),
2795 "===" => Ok(Self::EqEqEq(::treesitter_types::Span::from(node))),
2796 "=>" => Ok(Self::FatArrow(::treesitter_types::Span::from(node))),
2797 "=~" => Ok(Self::EqTilde(::treesitter_types::Span::from(node))),
2798 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
2799 ">=" => Ok(Self::GtEq(::treesitter_types::Span::from(node))),
2800 ">>>" => Ok(Self::GtGtGt(::treesitter_types::Span::from(node))),
2801 "\\\\" => Ok(Self::BackslashBackslash(::treesitter_types::Span::from(
2802 node,
2803 ))),
2804 "^^^" => Ok(Self::CaretCaretCaret(::treesitter_types::Span::from(node))),
2805 "and" => Ok(Self::And(::treesitter_types::Span::from(node))),
2806 "in" => Ok(Self::In(::treesitter_types::Span::from(node))),
2807 "not in" => Ok(Self::NOTXIN(::treesitter_types::Span::from(node))),
2808 "or" => Ok(Self::Or(::treesitter_types::Span::from(node))),
2809 "when" => Ok(Self::When(::treesitter_types::Span::from(node))),
2810 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
2811 "|>" => Ok(Self::PipeGt(::treesitter_types::Span::from(node))),
2812 "||" => Ok(Self::PipePipe(::treesitter_types::Span::from(node))),
2813 "|||" => Ok(Self::PipePipePipe(::treesitter_types::Span::from(node))),
2814 "~>" => Ok(Self::TildeGt(::treesitter_types::Span::from(node))),
2815 "~>>" => Ok(Self::TildeGtGt(::treesitter_types::Span::from(node))),
2816 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2817 }
2818 }
2819}
2820impl ::treesitter_types::Spanned for BinaryOperatorOperator {
2821 fn span(&self) -> ::treesitter_types::Span {
2822 match self {
2823 Self::NotEq(span) => *span,
2824 Self::BangEqEq(span) => *span,
2825 Self::AmpAmp(span) => *span,
2826 Self::AmpAmpAmp(span) => *span,
2827 Self::Star(span) => *span,
2828 Self::StarStar(span) => *span,
2829 Self::Plus(span) => *span,
2830 Self::PlusPlus(span) => *span,
2831 Self::PlusPlusPlus(span) => *span,
2832 Self::Minus(span) => *span,
2833 Self::MinusMinus(span) => *span,
2834 Self::MinusMinusMinus(span) => *span,
2835 Self::DotDot(span) => *span,
2836 Self::Slash(span) => *span,
2837 Self::SlashSlash(span) => *span,
2838 Self::DoubleColon(span) => *span,
2839 Self::Lt(span) => *span,
2840 Self::LArrow(span) => *span,
2841 Self::LtLtLt(span) => *span,
2842 Self::LtLtTilde(span) => *span,
2843 Self::LtEq(span) => *span,
2844 Self::LtGt(span) => *span,
2845 Self::LtPipeGt(span) => *span,
2846 Self::LtTilde(span) => *span,
2847 Self::LtTildeGt(span) => *span,
2848 Self::Eq(span) => *span,
2849 Self::EqEq(span) => *span,
2850 Self::EqEqEq(span) => *span,
2851 Self::FatArrow(span) => *span,
2852 Self::EqTilde(span) => *span,
2853 Self::Gt(span) => *span,
2854 Self::GtEq(span) => *span,
2855 Self::GtGtGt(span) => *span,
2856 Self::BackslashBackslash(span) => *span,
2857 Self::CaretCaretCaret(span) => *span,
2858 Self::And(span) => *span,
2859 Self::In(span) => *span,
2860 Self::NOTXIN(span) => *span,
2861 Self::Or(span) => *span,
2862 Self::When(span) => *span,
2863 Self::Pipe(span) => *span,
2864 Self::PipeGt(span) => *span,
2865 Self::PipePipe(span) => *span,
2866 Self::PipePipePipe(span) => *span,
2867 Self::TildeGt(span) => *span,
2868 Self::TildeGtGt(span) => *span,
2869 }
2870 }
2871}
2872#[derive(Debug, Clone, PartialEq, Eq)]
2873pub enum BinaryOperatorRight<'tree> {
2874 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
2875 Alias(::std::boxed::Box<Alias<'tree>>),
2876 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
2877 Atom(::std::boxed::Box<Atom<'tree>>),
2878 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
2879 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
2880 Block(::std::boxed::Box<Block<'tree>>),
2881 Boolean(::std::boxed::Box<Boolean<'tree>>),
2882 Call(::std::boxed::Box<Call<'tree>>),
2883 Char(::std::boxed::Box<Char<'tree>>),
2884 Charlist(::std::boxed::Box<Charlist<'tree>>),
2885 Dot(::std::boxed::Box<Dot<'tree>>),
2886 Float(::std::boxed::Box<Float<'tree>>),
2887 Identifier(::std::boxed::Box<Identifier<'tree>>),
2888 Integer(::std::boxed::Box<Integer<'tree>>),
2889 Keywords(::std::boxed::Box<Keywords<'tree>>),
2890 List(::std::boxed::Box<List<'tree>>),
2891 Map(::std::boxed::Box<Map<'tree>>),
2892 Nil(::std::boxed::Box<Nil<'tree>>),
2893 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
2894 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
2895 Sigil(::std::boxed::Box<Sigil<'tree>>),
2896 String(::std::boxed::Box<String<'tree>>),
2897 Tuple(::std::boxed::Box<Tuple<'tree>>),
2898 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
2899}
2900impl<'tree> ::treesitter_types::FromNode<'tree> for BinaryOperatorRight<'tree> {
2901 #[allow(clippy::collapsible_else_if)]
2902 fn from_node(
2903 node: ::tree_sitter::Node<'tree>,
2904 src: &'tree [u8],
2905 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2906 match node.kind() {
2907 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
2908 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
2909 ))),
2910 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
2911 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
2912 ))),
2913 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
2914 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
2915 ))),
2916 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
2917 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
2918 ))),
2919 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
2920 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2921 ))),
2922 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
2923 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
2924 ))),
2925 "block" => Ok(Self::Block(::std::boxed::Box::new(
2926 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
2927 ))),
2928 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
2929 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
2930 ))),
2931 "call" => Ok(Self::Call(::std::boxed::Box::new(
2932 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
2933 ))),
2934 "char" => Ok(Self::Char(::std::boxed::Box::new(
2935 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
2936 ))),
2937 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
2938 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
2939 ))),
2940 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
2941 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
2942 ))),
2943 "float" => Ok(Self::Float(::std::boxed::Box::new(
2944 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
2945 ))),
2946 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
2947 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2948 ))),
2949 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
2950 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
2951 ))),
2952 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
2953 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
2954 ))),
2955 "list" => Ok(Self::List(::std::boxed::Box::new(
2956 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
2957 ))),
2958 "map" => Ok(Self::Map(::std::boxed::Box::new(
2959 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
2960 ))),
2961 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
2962 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
2963 ))),
2964 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
2965 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
2966 ))),
2967 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
2968 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
2969 ))),
2970 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
2971 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
2972 ))),
2973 "string" => Ok(Self::String(::std::boxed::Box::new(
2974 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
2975 ))),
2976 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
2977 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
2978 ))),
2979 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
2980 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
2981 ))),
2982 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2983 }
2984 }
2985}
2986impl ::treesitter_types::Spanned for BinaryOperatorRight<'_> {
2987 fn span(&self) -> ::treesitter_types::Span {
2988 match self {
2989 Self::AccessCall(inner) => inner.span(),
2990 Self::Alias(inner) => inner.span(),
2991 Self::AnonymousFunction(inner) => inner.span(),
2992 Self::Atom(inner) => inner.span(),
2993 Self::BinaryOperator(inner) => inner.span(),
2994 Self::Bitstring(inner) => inner.span(),
2995 Self::Block(inner) => inner.span(),
2996 Self::Boolean(inner) => inner.span(),
2997 Self::Call(inner) => inner.span(),
2998 Self::Char(inner) => inner.span(),
2999 Self::Charlist(inner) => inner.span(),
3000 Self::Dot(inner) => inner.span(),
3001 Self::Float(inner) => inner.span(),
3002 Self::Identifier(inner) => inner.span(),
3003 Self::Integer(inner) => inner.span(),
3004 Self::Keywords(inner) => inner.span(),
3005 Self::List(inner) => inner.span(),
3006 Self::Map(inner) => inner.span(),
3007 Self::Nil(inner) => inner.span(),
3008 Self::OperatorIdentifier(inner) => inner.span(),
3009 Self::QuotedAtom(inner) => inner.span(),
3010 Self::Sigil(inner) => inner.span(),
3011 Self::String(inner) => inner.span(),
3012 Self::Tuple(inner) => inner.span(),
3013 Self::UnaryOperator(inner) => inner.span(),
3014 }
3015 }
3016}
3017#[derive(Debug, Clone, PartialEq, Eq)]
3018pub enum BitstringChildren<'tree> {
3019 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3020 Alias(::std::boxed::Box<Alias<'tree>>),
3021 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3022 Atom(::std::boxed::Box<Atom<'tree>>),
3023 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3024 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3025 Block(::std::boxed::Box<Block<'tree>>),
3026 Boolean(::std::boxed::Box<Boolean<'tree>>),
3027 Call(::std::boxed::Box<Call<'tree>>),
3028 Char(::std::boxed::Box<Char<'tree>>),
3029 Charlist(::std::boxed::Box<Charlist<'tree>>),
3030 Dot(::std::boxed::Box<Dot<'tree>>),
3031 Float(::std::boxed::Box<Float<'tree>>),
3032 Identifier(::std::boxed::Box<Identifier<'tree>>),
3033 Integer(::std::boxed::Box<Integer<'tree>>),
3034 Keywords(::std::boxed::Box<Keywords<'tree>>),
3035 List(::std::boxed::Box<List<'tree>>),
3036 Map(::std::boxed::Box<Map<'tree>>),
3037 Nil(::std::boxed::Box<Nil<'tree>>),
3038 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3039 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3040 Sigil(::std::boxed::Box<Sigil<'tree>>),
3041 String(::std::boxed::Box<String<'tree>>),
3042 Tuple(::std::boxed::Box<Tuple<'tree>>),
3043 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3044}
3045impl<'tree> ::treesitter_types::FromNode<'tree> for BitstringChildren<'tree> {
3046 #[allow(clippy::collapsible_else_if)]
3047 fn from_node(
3048 node: ::tree_sitter::Node<'tree>,
3049 src: &'tree [u8],
3050 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3051 match node.kind() {
3052 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3053 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3054 ))),
3055 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3056 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3057 ))),
3058 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3059 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3060 ))),
3061 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3062 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3063 ))),
3064 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3065 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3066 ))),
3067 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3068 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3069 ))),
3070 "block" => Ok(Self::Block(::std::boxed::Box::new(
3071 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3072 ))),
3073 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3074 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3075 ))),
3076 "call" => Ok(Self::Call(::std::boxed::Box::new(
3077 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3078 ))),
3079 "char" => Ok(Self::Char(::std::boxed::Box::new(
3080 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3081 ))),
3082 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3083 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3084 ))),
3085 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3086 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3087 ))),
3088 "float" => Ok(Self::Float(::std::boxed::Box::new(
3089 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3090 ))),
3091 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3092 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3093 ))),
3094 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3095 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3096 ))),
3097 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
3098 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
3099 ))),
3100 "list" => Ok(Self::List(::std::boxed::Box::new(
3101 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3102 ))),
3103 "map" => Ok(Self::Map(::std::boxed::Box::new(
3104 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3105 ))),
3106 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3107 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
3108 ))),
3109 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
3110 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3111 ))),
3112 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
3113 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
3114 ))),
3115 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
3116 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
3117 ))),
3118 "string" => Ok(Self::String(::std::boxed::Box::new(
3119 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
3120 ))),
3121 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
3122 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
3123 ))),
3124 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
3125 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3126 ))),
3127 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3128 }
3129 }
3130}
3131impl ::treesitter_types::Spanned for BitstringChildren<'_> {
3132 fn span(&self) -> ::treesitter_types::Span {
3133 match self {
3134 Self::AccessCall(inner) => inner.span(),
3135 Self::Alias(inner) => inner.span(),
3136 Self::AnonymousFunction(inner) => inner.span(),
3137 Self::Atom(inner) => inner.span(),
3138 Self::BinaryOperator(inner) => inner.span(),
3139 Self::Bitstring(inner) => inner.span(),
3140 Self::Block(inner) => inner.span(),
3141 Self::Boolean(inner) => inner.span(),
3142 Self::Call(inner) => inner.span(),
3143 Self::Char(inner) => inner.span(),
3144 Self::Charlist(inner) => inner.span(),
3145 Self::Dot(inner) => inner.span(),
3146 Self::Float(inner) => inner.span(),
3147 Self::Identifier(inner) => inner.span(),
3148 Self::Integer(inner) => inner.span(),
3149 Self::Keywords(inner) => inner.span(),
3150 Self::List(inner) => inner.span(),
3151 Self::Map(inner) => inner.span(),
3152 Self::Nil(inner) => inner.span(),
3153 Self::OperatorIdentifier(inner) => inner.span(),
3154 Self::QuotedAtom(inner) => inner.span(),
3155 Self::Sigil(inner) => inner.span(),
3156 Self::String(inner) => inner.span(),
3157 Self::Tuple(inner) => inner.span(),
3158 Self::UnaryOperator(inner) => inner.span(),
3159 }
3160 }
3161}
3162#[derive(Debug, Clone, PartialEq, Eq)]
3163pub enum BlockChildren<'tree> {
3164 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3165 Alias(::std::boxed::Box<Alias<'tree>>),
3166 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3167 Atom(::std::boxed::Box<Atom<'tree>>),
3168 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3169 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3170 Block(::std::boxed::Box<Block<'tree>>),
3171 Boolean(::std::boxed::Box<Boolean<'tree>>),
3172 Call(::std::boxed::Box<Call<'tree>>),
3173 Char(::std::boxed::Box<Char<'tree>>),
3174 Charlist(::std::boxed::Box<Charlist<'tree>>),
3175 Dot(::std::boxed::Box<Dot<'tree>>),
3176 Float(::std::boxed::Box<Float<'tree>>),
3177 Identifier(::std::boxed::Box<Identifier<'tree>>),
3178 Integer(::std::boxed::Box<Integer<'tree>>),
3179 List(::std::boxed::Box<List<'tree>>),
3180 Map(::std::boxed::Box<Map<'tree>>),
3181 Nil(::std::boxed::Box<Nil<'tree>>),
3182 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3183 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3184 Sigil(::std::boxed::Box<Sigil<'tree>>),
3185 StabClause(::std::boxed::Box<StabClause<'tree>>),
3186 String(::std::boxed::Box<String<'tree>>),
3187 Tuple(::std::boxed::Box<Tuple<'tree>>),
3188 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3189}
3190impl<'tree> ::treesitter_types::FromNode<'tree> for BlockChildren<'tree> {
3191 #[allow(clippy::collapsible_else_if)]
3192 fn from_node(
3193 node: ::tree_sitter::Node<'tree>,
3194 src: &'tree [u8],
3195 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3196 match node.kind() {
3197 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3198 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3199 ))),
3200 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3201 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3202 ))),
3203 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3204 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3205 ))),
3206 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3207 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3208 ))),
3209 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3210 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3211 ))),
3212 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3213 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3214 ))),
3215 "block" => Ok(Self::Block(::std::boxed::Box::new(
3216 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3217 ))),
3218 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3219 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3220 ))),
3221 "call" => Ok(Self::Call(::std::boxed::Box::new(
3222 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3223 ))),
3224 "char" => Ok(Self::Char(::std::boxed::Box::new(
3225 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3226 ))),
3227 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3228 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3229 ))),
3230 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3231 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3232 ))),
3233 "float" => Ok(Self::Float(::std::boxed::Box::new(
3234 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3235 ))),
3236 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3237 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3238 ))),
3239 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3240 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3241 ))),
3242 "list" => Ok(Self::List(::std::boxed::Box::new(
3243 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3244 ))),
3245 "map" => Ok(Self::Map(::std::boxed::Box::new(
3246 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3247 ))),
3248 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3249 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
3250 ))),
3251 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
3252 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3253 ))),
3254 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
3255 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
3256 ))),
3257 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
3258 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
3259 ))),
3260 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
3261 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
3262 ))),
3263 "string" => Ok(Self::String(::std::boxed::Box::new(
3264 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
3265 ))),
3266 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
3267 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
3268 ))),
3269 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
3270 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3271 ))),
3272 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3273 }
3274 }
3275}
3276impl ::treesitter_types::Spanned for BlockChildren<'_> {
3277 fn span(&self) -> ::treesitter_types::Span {
3278 match self {
3279 Self::AccessCall(inner) => inner.span(),
3280 Self::Alias(inner) => inner.span(),
3281 Self::AnonymousFunction(inner) => inner.span(),
3282 Self::Atom(inner) => inner.span(),
3283 Self::BinaryOperator(inner) => inner.span(),
3284 Self::Bitstring(inner) => inner.span(),
3285 Self::Block(inner) => inner.span(),
3286 Self::Boolean(inner) => inner.span(),
3287 Self::Call(inner) => inner.span(),
3288 Self::Char(inner) => inner.span(),
3289 Self::Charlist(inner) => inner.span(),
3290 Self::Dot(inner) => inner.span(),
3291 Self::Float(inner) => inner.span(),
3292 Self::Identifier(inner) => inner.span(),
3293 Self::Integer(inner) => inner.span(),
3294 Self::List(inner) => inner.span(),
3295 Self::Map(inner) => inner.span(),
3296 Self::Nil(inner) => inner.span(),
3297 Self::OperatorIdentifier(inner) => inner.span(),
3298 Self::QuotedAtom(inner) => inner.span(),
3299 Self::Sigil(inner) => inner.span(),
3300 Self::StabClause(inner) => inner.span(),
3301 Self::String(inner) => inner.span(),
3302 Self::Tuple(inner) => inner.span(),
3303 Self::UnaryOperator(inner) => inner.span(),
3304 }
3305 }
3306}
3307#[derive(Debug, Clone, PartialEq, Eq)]
3308pub enum BodyChildren<'tree> {
3309 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3310 Alias(::std::boxed::Box<Alias<'tree>>),
3311 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3312 Atom(::std::boxed::Box<Atom<'tree>>),
3313 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3314 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3315 Block(::std::boxed::Box<Block<'tree>>),
3316 Boolean(::std::boxed::Box<Boolean<'tree>>),
3317 Call(::std::boxed::Box<Call<'tree>>),
3318 Char(::std::boxed::Box<Char<'tree>>),
3319 Charlist(::std::boxed::Box<Charlist<'tree>>),
3320 Dot(::std::boxed::Box<Dot<'tree>>),
3321 Float(::std::boxed::Box<Float<'tree>>),
3322 Identifier(::std::boxed::Box<Identifier<'tree>>),
3323 Integer(::std::boxed::Box<Integer<'tree>>),
3324 List(::std::boxed::Box<List<'tree>>),
3325 Map(::std::boxed::Box<Map<'tree>>),
3326 Nil(::std::boxed::Box<Nil<'tree>>),
3327 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3328 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3329 Sigil(::std::boxed::Box<Sigil<'tree>>),
3330 String(::std::boxed::Box<String<'tree>>),
3331 Tuple(::std::boxed::Box<Tuple<'tree>>),
3332 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3333}
3334impl<'tree> ::treesitter_types::FromNode<'tree> for BodyChildren<'tree> {
3335 #[allow(clippy::collapsible_else_if)]
3336 fn from_node(
3337 node: ::tree_sitter::Node<'tree>,
3338 src: &'tree [u8],
3339 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3340 match node.kind() {
3341 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3342 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3343 ))),
3344 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3345 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3346 ))),
3347 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3348 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3349 ))),
3350 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3351 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3352 ))),
3353 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3354 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3355 ))),
3356 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3357 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3358 ))),
3359 "block" => Ok(Self::Block(::std::boxed::Box::new(
3360 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3361 ))),
3362 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3363 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3364 ))),
3365 "call" => Ok(Self::Call(::std::boxed::Box::new(
3366 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3367 ))),
3368 "char" => Ok(Self::Char(::std::boxed::Box::new(
3369 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3370 ))),
3371 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3372 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3373 ))),
3374 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3375 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3376 ))),
3377 "float" => Ok(Self::Float(::std::boxed::Box::new(
3378 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3379 ))),
3380 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3381 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3382 ))),
3383 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3384 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3385 ))),
3386 "list" => Ok(Self::List(::std::boxed::Box::new(
3387 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3388 ))),
3389 "map" => Ok(Self::Map(::std::boxed::Box::new(
3390 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3391 ))),
3392 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3393 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
3394 ))),
3395 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
3396 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3397 ))),
3398 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
3399 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
3400 ))),
3401 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
3402 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
3403 ))),
3404 "string" => Ok(Self::String(::std::boxed::Box::new(
3405 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
3406 ))),
3407 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
3408 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
3409 ))),
3410 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
3411 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3412 ))),
3413 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3414 }
3415 }
3416}
3417impl ::treesitter_types::Spanned for BodyChildren<'_> {
3418 fn span(&self) -> ::treesitter_types::Span {
3419 match self {
3420 Self::AccessCall(inner) => inner.span(),
3421 Self::Alias(inner) => inner.span(),
3422 Self::AnonymousFunction(inner) => inner.span(),
3423 Self::Atom(inner) => inner.span(),
3424 Self::BinaryOperator(inner) => inner.span(),
3425 Self::Bitstring(inner) => inner.span(),
3426 Self::Block(inner) => inner.span(),
3427 Self::Boolean(inner) => inner.span(),
3428 Self::Call(inner) => inner.span(),
3429 Self::Char(inner) => inner.span(),
3430 Self::Charlist(inner) => inner.span(),
3431 Self::Dot(inner) => inner.span(),
3432 Self::Float(inner) => inner.span(),
3433 Self::Identifier(inner) => inner.span(),
3434 Self::Integer(inner) => inner.span(),
3435 Self::List(inner) => inner.span(),
3436 Self::Map(inner) => inner.span(),
3437 Self::Nil(inner) => inner.span(),
3438 Self::OperatorIdentifier(inner) => inner.span(),
3439 Self::QuotedAtom(inner) => inner.span(),
3440 Self::Sigil(inner) => inner.span(),
3441 Self::String(inner) => inner.span(),
3442 Self::Tuple(inner) => inner.span(),
3443 Self::UnaryOperator(inner) => inner.span(),
3444 }
3445 }
3446}
3447#[derive(Debug, Clone, PartialEq, Eq)]
3448pub enum CallTarget<'tree> {
3449 Call(::std::boxed::Box<Call<'tree>>),
3450 Dot(::std::boxed::Box<Dot<'tree>>),
3451 Identifier(::std::boxed::Box<Identifier<'tree>>),
3452}
3453impl<'tree> ::treesitter_types::FromNode<'tree> for CallTarget<'tree> {
3454 #[allow(clippy::collapsible_else_if)]
3455 fn from_node(
3456 node: ::tree_sitter::Node<'tree>,
3457 src: &'tree [u8],
3458 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3459 match node.kind() {
3460 "call" => Ok(Self::Call(::std::boxed::Box::new(
3461 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3462 ))),
3463 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3464 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3465 ))),
3466 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3467 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3468 ))),
3469 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3470 }
3471 }
3472}
3473impl ::treesitter_types::Spanned for CallTarget<'_> {
3474 fn span(&self) -> ::treesitter_types::Span {
3475 match self {
3476 Self::Call(inner) => inner.span(),
3477 Self::Dot(inner) => inner.span(),
3478 Self::Identifier(inner) => inner.span(),
3479 }
3480 }
3481}
3482#[derive(Debug, Clone, PartialEq, Eq)]
3483pub enum CallChildren<'tree> {
3484 Arguments(::std::boxed::Box<Arguments<'tree>>),
3485 DoBlock(::std::boxed::Box<DoBlock<'tree>>),
3486}
3487impl<'tree> ::treesitter_types::FromNode<'tree> for CallChildren<'tree> {
3488 #[allow(clippy::collapsible_else_if)]
3489 fn from_node(
3490 node: ::tree_sitter::Node<'tree>,
3491 src: &'tree [u8],
3492 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3493 match node.kind() {
3494 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
3495 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
3496 ))),
3497 "do_block" => Ok(Self::DoBlock(::std::boxed::Box::new(
3498 <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
3499 ))),
3500 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3501 }
3502 }
3503}
3504impl ::treesitter_types::Spanned for CallChildren<'_> {
3505 fn span(&self) -> ::treesitter_types::Span {
3506 match self {
3507 Self::Arguments(inner) => inner.span(),
3508 Self::DoBlock(inner) => inner.span(),
3509 }
3510 }
3511}
3512#[derive(Debug, Clone, PartialEq, Eq)]
3513pub enum CatchBlockChildren<'tree> {
3514 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3515 Alias(::std::boxed::Box<Alias<'tree>>),
3516 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3517 Atom(::std::boxed::Box<Atom<'tree>>),
3518 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3519 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3520 Block(::std::boxed::Box<Block<'tree>>),
3521 Boolean(::std::boxed::Box<Boolean<'tree>>),
3522 Call(::std::boxed::Box<Call<'tree>>),
3523 Char(::std::boxed::Box<Char<'tree>>),
3524 Charlist(::std::boxed::Box<Charlist<'tree>>),
3525 Dot(::std::boxed::Box<Dot<'tree>>),
3526 Float(::std::boxed::Box<Float<'tree>>),
3527 Identifier(::std::boxed::Box<Identifier<'tree>>),
3528 Integer(::std::boxed::Box<Integer<'tree>>),
3529 List(::std::boxed::Box<List<'tree>>),
3530 Map(::std::boxed::Box<Map<'tree>>),
3531 Nil(::std::boxed::Box<Nil<'tree>>),
3532 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3533 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3534 Sigil(::std::boxed::Box<Sigil<'tree>>),
3535 StabClause(::std::boxed::Box<StabClause<'tree>>),
3536 String(::std::boxed::Box<String<'tree>>),
3537 Tuple(::std::boxed::Box<Tuple<'tree>>),
3538 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3539}
3540impl<'tree> ::treesitter_types::FromNode<'tree> for CatchBlockChildren<'tree> {
3541 #[allow(clippy::collapsible_else_if)]
3542 fn from_node(
3543 node: ::tree_sitter::Node<'tree>,
3544 src: &'tree [u8],
3545 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3546 match node.kind() {
3547 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3548 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3549 ))),
3550 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3551 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3552 ))),
3553 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3554 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3555 ))),
3556 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3557 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3558 ))),
3559 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3560 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3561 ))),
3562 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3563 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3564 ))),
3565 "block" => Ok(Self::Block(::std::boxed::Box::new(
3566 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3567 ))),
3568 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3569 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3570 ))),
3571 "call" => Ok(Self::Call(::std::boxed::Box::new(
3572 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3573 ))),
3574 "char" => Ok(Self::Char(::std::boxed::Box::new(
3575 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3576 ))),
3577 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3578 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3579 ))),
3580 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3581 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3582 ))),
3583 "float" => Ok(Self::Float(::std::boxed::Box::new(
3584 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3585 ))),
3586 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3587 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3588 ))),
3589 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3590 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3591 ))),
3592 "list" => Ok(Self::List(::std::boxed::Box::new(
3593 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3594 ))),
3595 "map" => Ok(Self::Map(::std::boxed::Box::new(
3596 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3597 ))),
3598 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3599 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
3600 ))),
3601 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
3602 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3603 ))),
3604 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
3605 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
3606 ))),
3607 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
3608 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
3609 ))),
3610 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
3611 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
3612 ))),
3613 "string" => Ok(Self::String(::std::boxed::Box::new(
3614 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
3615 ))),
3616 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
3617 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
3618 ))),
3619 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
3620 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3621 ))),
3622 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3623 }
3624 }
3625}
3626impl ::treesitter_types::Spanned for CatchBlockChildren<'_> {
3627 fn span(&self) -> ::treesitter_types::Span {
3628 match self {
3629 Self::AccessCall(inner) => inner.span(),
3630 Self::Alias(inner) => inner.span(),
3631 Self::AnonymousFunction(inner) => inner.span(),
3632 Self::Atom(inner) => inner.span(),
3633 Self::BinaryOperator(inner) => inner.span(),
3634 Self::Bitstring(inner) => inner.span(),
3635 Self::Block(inner) => inner.span(),
3636 Self::Boolean(inner) => inner.span(),
3637 Self::Call(inner) => inner.span(),
3638 Self::Char(inner) => inner.span(),
3639 Self::Charlist(inner) => inner.span(),
3640 Self::Dot(inner) => inner.span(),
3641 Self::Float(inner) => inner.span(),
3642 Self::Identifier(inner) => inner.span(),
3643 Self::Integer(inner) => inner.span(),
3644 Self::List(inner) => inner.span(),
3645 Self::Map(inner) => inner.span(),
3646 Self::Nil(inner) => inner.span(),
3647 Self::OperatorIdentifier(inner) => inner.span(),
3648 Self::QuotedAtom(inner) => inner.span(),
3649 Self::Sigil(inner) => inner.span(),
3650 Self::StabClause(inner) => inner.span(),
3651 Self::String(inner) => inner.span(),
3652 Self::Tuple(inner) => inner.span(),
3653 Self::UnaryOperator(inner) => inner.span(),
3654 }
3655 }
3656}
3657#[derive(Debug, Clone, PartialEq, Eq)]
3658pub enum CharlistQuotedEnd {
3659 SingleQuote(::treesitter_types::Span),
3660 SQuoteSQuoteSQuote(::treesitter_types::Span),
3661}
3662impl<'tree> ::treesitter_types::FromNode<'tree> for CharlistQuotedEnd {
3663 #[allow(clippy::collapsible_else_if)]
3664 fn from_node(
3665 node: ::tree_sitter::Node<'tree>,
3666 _src: &'tree [u8],
3667 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3668 match node.kind() {
3669 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
3670 "'''" => Ok(Self::SQuoteSQuoteSQuote(::treesitter_types::Span::from(
3671 node,
3672 ))),
3673 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3674 }
3675 }
3676}
3677impl ::treesitter_types::Spanned for CharlistQuotedEnd {
3678 fn span(&self) -> ::treesitter_types::Span {
3679 match self {
3680 Self::SingleQuote(span) => *span,
3681 Self::SQuoteSQuoteSQuote(span) => *span,
3682 }
3683 }
3684}
3685#[derive(Debug, Clone, PartialEq, Eq)]
3686pub enum CharlistQuotedStart {
3687 SingleQuote(::treesitter_types::Span),
3688 SQuoteSQuoteSQuote(::treesitter_types::Span),
3689}
3690impl<'tree> ::treesitter_types::FromNode<'tree> for CharlistQuotedStart {
3691 #[allow(clippy::collapsible_else_if)]
3692 fn from_node(
3693 node: ::tree_sitter::Node<'tree>,
3694 _src: &'tree [u8],
3695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3696 match node.kind() {
3697 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
3698 "'''" => Ok(Self::SQuoteSQuoteSQuote(::treesitter_types::Span::from(
3699 node,
3700 ))),
3701 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3702 }
3703 }
3704}
3705impl ::treesitter_types::Spanned for CharlistQuotedStart {
3706 fn span(&self) -> ::treesitter_types::Span {
3707 match self {
3708 Self::SingleQuote(span) => *span,
3709 Self::SQuoteSQuoteSQuote(span) => *span,
3710 }
3711 }
3712}
3713#[derive(Debug, Clone, PartialEq, Eq)]
3714pub enum CharlistChildren<'tree> {
3715 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
3716 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
3717 QuotedContent(::std::boxed::Box<QuotedContent<'tree>>),
3718}
3719impl<'tree> ::treesitter_types::FromNode<'tree> for CharlistChildren<'tree> {
3720 #[allow(clippy::collapsible_else_if)]
3721 fn from_node(
3722 node: ::tree_sitter::Node<'tree>,
3723 src: &'tree [u8],
3724 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3725 match node.kind() {
3726 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
3727 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
3728 ))),
3729 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
3730 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
3731 ))),
3732 "quoted_content" => Ok(Self::QuotedContent(::std::boxed::Box::new(
3733 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)?,
3734 ))),
3735 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3736 }
3737 }
3738}
3739impl ::treesitter_types::Spanned for CharlistChildren<'_> {
3740 fn span(&self) -> ::treesitter_types::Span {
3741 match self {
3742 Self::EscapeSequence(inner) => inner.span(),
3743 Self::Interpolation(inner) => inner.span(),
3744 Self::QuotedContent(inner) => inner.span(),
3745 }
3746 }
3747}
3748#[derive(Debug, Clone, PartialEq, Eq)]
3749pub enum DoBlockChildren<'tree> {
3750 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3751 AfterBlock(::std::boxed::Box<AfterBlock<'tree>>),
3752 Alias(::std::boxed::Box<Alias<'tree>>),
3753 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3754 Atom(::std::boxed::Box<Atom<'tree>>),
3755 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3756 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3757 Block(::std::boxed::Box<Block<'tree>>),
3758 Boolean(::std::boxed::Box<Boolean<'tree>>),
3759 Call(::std::boxed::Box<Call<'tree>>),
3760 CatchBlock(::std::boxed::Box<CatchBlock<'tree>>),
3761 Char(::std::boxed::Box<Char<'tree>>),
3762 Charlist(::std::boxed::Box<Charlist<'tree>>),
3763 Dot(::std::boxed::Box<Dot<'tree>>),
3764 ElseBlock(::std::boxed::Box<ElseBlock<'tree>>),
3765 Float(::std::boxed::Box<Float<'tree>>),
3766 Identifier(::std::boxed::Box<Identifier<'tree>>),
3767 Integer(::std::boxed::Box<Integer<'tree>>),
3768 List(::std::boxed::Box<List<'tree>>),
3769 Map(::std::boxed::Box<Map<'tree>>),
3770 Nil(::std::boxed::Box<Nil<'tree>>),
3771 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3772 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3773 RescueBlock(::std::boxed::Box<RescueBlock<'tree>>),
3774 Sigil(::std::boxed::Box<Sigil<'tree>>),
3775 StabClause(::std::boxed::Box<StabClause<'tree>>),
3776 String(::std::boxed::Box<String<'tree>>),
3777 Tuple(::std::boxed::Box<Tuple<'tree>>),
3778 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3779}
3780impl<'tree> ::treesitter_types::FromNode<'tree> for DoBlockChildren<'tree> {
3781 #[allow(clippy::collapsible_else_if)]
3782 fn from_node(
3783 node: ::tree_sitter::Node<'tree>,
3784 src: &'tree [u8],
3785 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3786 match node.kind() {
3787 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3788 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3789 ))),
3790 "after_block" => Ok(Self::AfterBlock(::std::boxed::Box::new(
3791 <AfterBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
3792 ))),
3793 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3794 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3795 ))),
3796 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3797 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3798 ))),
3799 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3800 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3801 ))),
3802 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3803 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3804 ))),
3805 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3806 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3807 ))),
3808 "block" => Ok(Self::Block(::std::boxed::Box::new(
3809 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3810 ))),
3811 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3812 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3813 ))),
3814 "call" => Ok(Self::Call(::std::boxed::Box::new(
3815 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3816 ))),
3817 "catch_block" => Ok(Self::CatchBlock(::std::boxed::Box::new(
3818 <CatchBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
3819 ))),
3820 "char" => Ok(Self::Char(::std::boxed::Box::new(
3821 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3822 ))),
3823 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3824 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3825 ))),
3826 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3827 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3828 ))),
3829 "else_block" => Ok(Self::ElseBlock(::std::boxed::Box::new(
3830 <ElseBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
3831 ))),
3832 "float" => Ok(Self::Float(::std::boxed::Box::new(
3833 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3834 ))),
3835 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3836 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3837 ))),
3838 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3839 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3840 ))),
3841 "list" => Ok(Self::List(::std::boxed::Box::new(
3842 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3843 ))),
3844 "map" => Ok(Self::Map(::std::boxed::Box::new(
3845 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3846 ))),
3847 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3848 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
3849 ))),
3850 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
3851 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3852 ))),
3853 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
3854 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
3855 ))),
3856 "rescue_block" => Ok(Self::RescueBlock(::std::boxed::Box::new(
3857 <RescueBlock as ::treesitter_types::FromNode>::from_node(node, src)?,
3858 ))),
3859 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
3860 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
3861 ))),
3862 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
3863 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
3864 ))),
3865 "string" => Ok(Self::String(::std::boxed::Box::new(
3866 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
3867 ))),
3868 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
3869 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
3870 ))),
3871 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
3872 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3873 ))),
3874 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
3875 }
3876 }
3877}
3878impl ::treesitter_types::Spanned for DoBlockChildren<'_> {
3879 fn span(&self) -> ::treesitter_types::Span {
3880 match self {
3881 Self::AccessCall(inner) => inner.span(),
3882 Self::AfterBlock(inner) => inner.span(),
3883 Self::Alias(inner) => inner.span(),
3884 Self::AnonymousFunction(inner) => inner.span(),
3885 Self::Atom(inner) => inner.span(),
3886 Self::BinaryOperator(inner) => inner.span(),
3887 Self::Bitstring(inner) => inner.span(),
3888 Self::Block(inner) => inner.span(),
3889 Self::Boolean(inner) => inner.span(),
3890 Self::Call(inner) => inner.span(),
3891 Self::CatchBlock(inner) => inner.span(),
3892 Self::Char(inner) => inner.span(),
3893 Self::Charlist(inner) => inner.span(),
3894 Self::Dot(inner) => inner.span(),
3895 Self::ElseBlock(inner) => inner.span(),
3896 Self::Float(inner) => inner.span(),
3897 Self::Identifier(inner) => inner.span(),
3898 Self::Integer(inner) => inner.span(),
3899 Self::List(inner) => inner.span(),
3900 Self::Map(inner) => inner.span(),
3901 Self::Nil(inner) => inner.span(),
3902 Self::OperatorIdentifier(inner) => inner.span(),
3903 Self::QuotedAtom(inner) => inner.span(),
3904 Self::RescueBlock(inner) => inner.span(),
3905 Self::Sigil(inner) => inner.span(),
3906 Self::StabClause(inner) => inner.span(),
3907 Self::String(inner) => inner.span(),
3908 Self::Tuple(inner) => inner.span(),
3909 Self::UnaryOperator(inner) => inner.span(),
3910 }
3911 }
3912}
3913#[derive(Debug, Clone, PartialEq, Eq)]
3914pub enum DotLeft<'tree> {
3915 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
3916 Alias(::std::boxed::Box<Alias<'tree>>),
3917 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
3918 Atom(::std::boxed::Box<Atom<'tree>>),
3919 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
3920 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
3921 Block(::std::boxed::Box<Block<'tree>>),
3922 Boolean(::std::boxed::Box<Boolean<'tree>>),
3923 Call(::std::boxed::Box<Call<'tree>>),
3924 Char(::std::boxed::Box<Char<'tree>>),
3925 Charlist(::std::boxed::Box<Charlist<'tree>>),
3926 Dot(::std::boxed::Box<Dot<'tree>>),
3927 Float(::std::boxed::Box<Float<'tree>>),
3928 Identifier(::std::boxed::Box<Identifier<'tree>>),
3929 Integer(::std::boxed::Box<Integer<'tree>>),
3930 List(::std::boxed::Box<List<'tree>>),
3931 Map(::std::boxed::Box<Map<'tree>>),
3932 Nil(::std::boxed::Box<Nil<'tree>>),
3933 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
3934 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
3935 Sigil(::std::boxed::Box<Sigil<'tree>>),
3936 String(::std::boxed::Box<String<'tree>>),
3937 Tuple(::std::boxed::Box<Tuple<'tree>>),
3938 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
3939}
3940impl<'tree> ::treesitter_types::FromNode<'tree> for DotLeft<'tree> {
3941 #[allow(clippy::collapsible_else_if)]
3942 fn from_node(
3943 node: ::tree_sitter::Node<'tree>,
3944 src: &'tree [u8],
3945 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
3946 match node.kind() {
3947 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
3948 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
3949 ))),
3950 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
3951 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
3952 ))),
3953 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
3954 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
3955 ))),
3956 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
3957 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
3958 ))),
3959 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
3960 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
3961 ))),
3962 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
3963 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
3964 ))),
3965 "block" => Ok(Self::Block(::std::boxed::Box::new(
3966 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
3967 ))),
3968 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
3969 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
3970 ))),
3971 "call" => Ok(Self::Call(::std::boxed::Box::new(
3972 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
3973 ))),
3974 "char" => Ok(Self::Char(::std::boxed::Box::new(
3975 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
3976 ))),
3977 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
3978 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
3979 ))),
3980 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
3981 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
3982 ))),
3983 "float" => Ok(Self::Float(::std::boxed::Box::new(
3984 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
3985 ))),
3986 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
3987 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
3988 ))),
3989 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
3990 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
3991 ))),
3992 "list" => Ok(Self::List(::std::boxed::Box::new(
3993 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
3994 ))),
3995 "map" => Ok(Self::Map(::std::boxed::Box::new(
3996 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
3997 ))),
3998 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
3999 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4000 ))),
4001 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4002 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4003 ))),
4004 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4005 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4006 ))),
4007 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4008 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4009 ))),
4010 "string" => Ok(Self::String(::std::boxed::Box::new(
4011 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4012 ))),
4013 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4014 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4015 ))),
4016 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4017 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4018 ))),
4019 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4020 }
4021 }
4022}
4023impl ::treesitter_types::Spanned for DotLeft<'_> {
4024 fn span(&self) -> ::treesitter_types::Span {
4025 match self {
4026 Self::AccessCall(inner) => inner.span(),
4027 Self::Alias(inner) => inner.span(),
4028 Self::AnonymousFunction(inner) => inner.span(),
4029 Self::Atom(inner) => inner.span(),
4030 Self::BinaryOperator(inner) => inner.span(),
4031 Self::Bitstring(inner) => inner.span(),
4032 Self::Block(inner) => inner.span(),
4033 Self::Boolean(inner) => inner.span(),
4034 Self::Call(inner) => inner.span(),
4035 Self::Char(inner) => inner.span(),
4036 Self::Charlist(inner) => inner.span(),
4037 Self::Dot(inner) => inner.span(),
4038 Self::Float(inner) => inner.span(),
4039 Self::Identifier(inner) => inner.span(),
4040 Self::Integer(inner) => inner.span(),
4041 Self::List(inner) => inner.span(),
4042 Self::Map(inner) => inner.span(),
4043 Self::Nil(inner) => inner.span(),
4044 Self::OperatorIdentifier(inner) => inner.span(),
4045 Self::QuotedAtom(inner) => inner.span(),
4046 Self::Sigil(inner) => inner.span(),
4047 Self::String(inner) => inner.span(),
4048 Self::Tuple(inner) => inner.span(),
4049 Self::UnaryOperator(inner) => inner.span(),
4050 }
4051 }
4052}
4053#[derive(Debug, Clone, PartialEq, Eq)]
4054pub enum DotOperator {
4055 Dot(::treesitter_types::Span),
4056}
4057impl<'tree> ::treesitter_types::FromNode<'tree> for DotOperator {
4058 #[allow(clippy::collapsible_else_if)]
4059 fn from_node(
4060 node: ::tree_sitter::Node<'tree>,
4061 _src: &'tree [u8],
4062 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4063 match node.kind() {
4064 "." => Ok(Self::Dot(::treesitter_types::Span::from(node))),
4065 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4066 }
4067 }
4068}
4069impl ::treesitter_types::Spanned for DotOperator {
4070 fn span(&self) -> ::treesitter_types::Span {
4071 match self {
4072 Self::Dot(span) => *span,
4073 }
4074 }
4075}
4076#[derive(Debug, Clone, PartialEq, Eq)]
4077pub enum DotRight<'tree> {
4078 Alias(::std::boxed::Box<Alias<'tree>>),
4079 Charlist(::std::boxed::Box<Charlist<'tree>>),
4080 Identifier(::std::boxed::Box<Identifier<'tree>>),
4081 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4082 String(::std::boxed::Box<String<'tree>>),
4083 Tuple(::std::boxed::Box<Tuple<'tree>>),
4084}
4085impl<'tree> ::treesitter_types::FromNode<'tree> for DotRight<'tree> {
4086 #[allow(clippy::collapsible_else_if)]
4087 fn from_node(
4088 node: ::tree_sitter::Node<'tree>,
4089 src: &'tree [u8],
4090 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4091 match node.kind() {
4092 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4093 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4094 ))),
4095 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4096 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4097 ))),
4098 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4099 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4100 ))),
4101 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4102 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4103 ))),
4104 "string" => Ok(Self::String(::std::boxed::Box::new(
4105 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4106 ))),
4107 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4108 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4109 ))),
4110 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4111 }
4112 }
4113}
4114impl ::treesitter_types::Spanned for DotRight<'_> {
4115 fn span(&self) -> ::treesitter_types::Span {
4116 match self {
4117 Self::Alias(inner) => inner.span(),
4118 Self::Charlist(inner) => inner.span(),
4119 Self::Identifier(inner) => inner.span(),
4120 Self::OperatorIdentifier(inner) => inner.span(),
4121 Self::String(inner) => inner.span(),
4122 Self::Tuple(inner) => inner.span(),
4123 }
4124 }
4125}
4126#[derive(Debug, Clone, PartialEq, Eq)]
4127pub enum ElseBlockChildren<'tree> {
4128 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
4129 Alias(::std::boxed::Box<Alias<'tree>>),
4130 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
4131 Atom(::std::boxed::Box<Atom<'tree>>),
4132 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
4133 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
4134 Block(::std::boxed::Box<Block<'tree>>),
4135 Boolean(::std::boxed::Box<Boolean<'tree>>),
4136 Call(::std::boxed::Box<Call<'tree>>),
4137 Char(::std::boxed::Box<Char<'tree>>),
4138 Charlist(::std::boxed::Box<Charlist<'tree>>),
4139 Dot(::std::boxed::Box<Dot<'tree>>),
4140 Float(::std::boxed::Box<Float<'tree>>),
4141 Identifier(::std::boxed::Box<Identifier<'tree>>),
4142 Integer(::std::boxed::Box<Integer<'tree>>),
4143 List(::std::boxed::Box<List<'tree>>),
4144 Map(::std::boxed::Box<Map<'tree>>),
4145 Nil(::std::boxed::Box<Nil<'tree>>),
4146 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4147 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
4148 Sigil(::std::boxed::Box<Sigil<'tree>>),
4149 StabClause(::std::boxed::Box<StabClause<'tree>>),
4150 String(::std::boxed::Box<String<'tree>>),
4151 Tuple(::std::boxed::Box<Tuple<'tree>>),
4152 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
4153}
4154impl<'tree> ::treesitter_types::FromNode<'tree> for ElseBlockChildren<'tree> {
4155 #[allow(clippy::collapsible_else_if)]
4156 fn from_node(
4157 node: ::tree_sitter::Node<'tree>,
4158 src: &'tree [u8],
4159 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4160 match node.kind() {
4161 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
4162 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
4163 ))),
4164 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4165 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4166 ))),
4167 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
4168 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
4169 ))),
4170 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
4171 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
4172 ))),
4173 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
4174 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4175 ))),
4176 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
4177 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
4178 ))),
4179 "block" => Ok(Self::Block(::std::boxed::Box::new(
4180 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
4181 ))),
4182 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
4183 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
4184 ))),
4185 "call" => Ok(Self::Call(::std::boxed::Box::new(
4186 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
4187 ))),
4188 "char" => Ok(Self::Char(::std::boxed::Box::new(
4189 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
4190 ))),
4191 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4192 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4193 ))),
4194 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
4195 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
4196 ))),
4197 "float" => Ok(Self::Float(::std::boxed::Box::new(
4198 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
4199 ))),
4200 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4201 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4202 ))),
4203 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
4204 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
4205 ))),
4206 "list" => Ok(Self::List(::std::boxed::Box::new(
4207 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
4208 ))),
4209 "map" => Ok(Self::Map(::std::boxed::Box::new(
4210 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
4211 ))),
4212 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
4213 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4214 ))),
4215 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4216 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4217 ))),
4218 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4219 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4220 ))),
4221 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4222 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4223 ))),
4224 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
4225 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
4226 ))),
4227 "string" => Ok(Self::String(::std::boxed::Box::new(
4228 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4229 ))),
4230 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4231 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4232 ))),
4233 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4234 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4235 ))),
4236 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4237 }
4238 }
4239}
4240impl ::treesitter_types::Spanned for ElseBlockChildren<'_> {
4241 fn span(&self) -> ::treesitter_types::Span {
4242 match self {
4243 Self::AccessCall(inner) => inner.span(),
4244 Self::Alias(inner) => inner.span(),
4245 Self::AnonymousFunction(inner) => inner.span(),
4246 Self::Atom(inner) => inner.span(),
4247 Self::BinaryOperator(inner) => inner.span(),
4248 Self::Bitstring(inner) => inner.span(),
4249 Self::Block(inner) => inner.span(),
4250 Self::Boolean(inner) => inner.span(),
4251 Self::Call(inner) => inner.span(),
4252 Self::Char(inner) => inner.span(),
4253 Self::Charlist(inner) => inner.span(),
4254 Self::Dot(inner) => inner.span(),
4255 Self::Float(inner) => inner.span(),
4256 Self::Identifier(inner) => inner.span(),
4257 Self::Integer(inner) => inner.span(),
4258 Self::List(inner) => inner.span(),
4259 Self::Map(inner) => inner.span(),
4260 Self::Nil(inner) => inner.span(),
4261 Self::OperatorIdentifier(inner) => inner.span(),
4262 Self::QuotedAtom(inner) => inner.span(),
4263 Self::Sigil(inner) => inner.span(),
4264 Self::StabClause(inner) => inner.span(),
4265 Self::String(inner) => inner.span(),
4266 Self::Tuple(inner) => inner.span(),
4267 Self::UnaryOperator(inner) => inner.span(),
4268 }
4269 }
4270}
4271#[derive(Debug, Clone, PartialEq, Eq)]
4272pub enum InterpolationChildren<'tree> {
4273 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
4274 Alias(::std::boxed::Box<Alias<'tree>>),
4275 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
4276 Atom(::std::boxed::Box<Atom<'tree>>),
4277 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
4278 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
4279 Block(::std::boxed::Box<Block<'tree>>),
4280 Boolean(::std::boxed::Box<Boolean<'tree>>),
4281 Call(::std::boxed::Box<Call<'tree>>),
4282 Char(::std::boxed::Box<Char<'tree>>),
4283 Charlist(::std::boxed::Box<Charlist<'tree>>),
4284 Dot(::std::boxed::Box<Dot<'tree>>),
4285 Float(::std::boxed::Box<Float<'tree>>),
4286 Identifier(::std::boxed::Box<Identifier<'tree>>),
4287 Integer(::std::boxed::Box<Integer<'tree>>),
4288 List(::std::boxed::Box<List<'tree>>),
4289 Map(::std::boxed::Box<Map<'tree>>),
4290 Nil(::std::boxed::Box<Nil<'tree>>),
4291 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4292 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
4293 Sigil(::std::boxed::Box<Sigil<'tree>>),
4294 String(::std::boxed::Box<String<'tree>>),
4295 Tuple(::std::boxed::Box<Tuple<'tree>>),
4296 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
4297}
4298impl<'tree> ::treesitter_types::FromNode<'tree> for InterpolationChildren<'tree> {
4299 #[allow(clippy::collapsible_else_if)]
4300 fn from_node(
4301 node: ::tree_sitter::Node<'tree>,
4302 src: &'tree [u8],
4303 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4304 match node.kind() {
4305 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
4306 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
4307 ))),
4308 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4309 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4310 ))),
4311 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
4312 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
4313 ))),
4314 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
4315 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
4316 ))),
4317 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
4318 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4319 ))),
4320 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
4321 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
4322 ))),
4323 "block" => Ok(Self::Block(::std::boxed::Box::new(
4324 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
4325 ))),
4326 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
4327 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
4328 ))),
4329 "call" => Ok(Self::Call(::std::boxed::Box::new(
4330 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
4331 ))),
4332 "char" => Ok(Self::Char(::std::boxed::Box::new(
4333 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
4334 ))),
4335 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4336 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4337 ))),
4338 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
4339 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
4340 ))),
4341 "float" => Ok(Self::Float(::std::boxed::Box::new(
4342 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
4343 ))),
4344 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4345 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4346 ))),
4347 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
4348 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
4349 ))),
4350 "list" => Ok(Self::List(::std::boxed::Box::new(
4351 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
4352 ))),
4353 "map" => Ok(Self::Map(::std::boxed::Box::new(
4354 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
4355 ))),
4356 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
4357 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4358 ))),
4359 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4360 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4361 ))),
4362 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4363 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4364 ))),
4365 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4366 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4367 ))),
4368 "string" => Ok(Self::String(::std::boxed::Box::new(
4369 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4370 ))),
4371 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4372 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4373 ))),
4374 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4375 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4376 ))),
4377 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4378 }
4379 }
4380}
4381impl ::treesitter_types::Spanned for InterpolationChildren<'_> {
4382 fn span(&self) -> ::treesitter_types::Span {
4383 match self {
4384 Self::AccessCall(inner) => inner.span(),
4385 Self::Alias(inner) => inner.span(),
4386 Self::AnonymousFunction(inner) => inner.span(),
4387 Self::Atom(inner) => inner.span(),
4388 Self::BinaryOperator(inner) => inner.span(),
4389 Self::Bitstring(inner) => inner.span(),
4390 Self::Block(inner) => inner.span(),
4391 Self::Boolean(inner) => inner.span(),
4392 Self::Call(inner) => inner.span(),
4393 Self::Char(inner) => inner.span(),
4394 Self::Charlist(inner) => inner.span(),
4395 Self::Dot(inner) => inner.span(),
4396 Self::Float(inner) => inner.span(),
4397 Self::Identifier(inner) => inner.span(),
4398 Self::Integer(inner) => inner.span(),
4399 Self::List(inner) => inner.span(),
4400 Self::Map(inner) => inner.span(),
4401 Self::Nil(inner) => inner.span(),
4402 Self::OperatorIdentifier(inner) => inner.span(),
4403 Self::QuotedAtom(inner) => inner.span(),
4404 Self::Sigil(inner) => inner.span(),
4405 Self::String(inner) => inner.span(),
4406 Self::Tuple(inner) => inner.span(),
4407 Self::UnaryOperator(inner) => inner.span(),
4408 }
4409 }
4410}
4411#[derive(Debug, Clone, PartialEq, Eq)]
4412pub enum ListChildren<'tree> {
4413 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
4414 Alias(::std::boxed::Box<Alias<'tree>>),
4415 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
4416 Atom(::std::boxed::Box<Atom<'tree>>),
4417 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
4418 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
4419 Block(::std::boxed::Box<Block<'tree>>),
4420 Boolean(::std::boxed::Box<Boolean<'tree>>),
4421 Call(::std::boxed::Box<Call<'tree>>),
4422 Char(::std::boxed::Box<Char<'tree>>),
4423 Charlist(::std::boxed::Box<Charlist<'tree>>),
4424 Dot(::std::boxed::Box<Dot<'tree>>),
4425 Float(::std::boxed::Box<Float<'tree>>),
4426 Identifier(::std::boxed::Box<Identifier<'tree>>),
4427 Integer(::std::boxed::Box<Integer<'tree>>),
4428 Keywords(::std::boxed::Box<Keywords<'tree>>),
4429 List(::std::boxed::Box<List<'tree>>),
4430 Map(::std::boxed::Box<Map<'tree>>),
4431 Nil(::std::boxed::Box<Nil<'tree>>),
4432 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4433 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
4434 Sigil(::std::boxed::Box<Sigil<'tree>>),
4435 String(::std::boxed::Box<String<'tree>>),
4436 Tuple(::std::boxed::Box<Tuple<'tree>>),
4437 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
4438}
4439impl<'tree> ::treesitter_types::FromNode<'tree> for ListChildren<'tree> {
4440 #[allow(clippy::collapsible_else_if)]
4441 fn from_node(
4442 node: ::tree_sitter::Node<'tree>,
4443 src: &'tree [u8],
4444 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4445 match node.kind() {
4446 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
4447 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
4448 ))),
4449 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4450 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4451 ))),
4452 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
4453 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
4454 ))),
4455 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
4456 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
4457 ))),
4458 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
4459 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4460 ))),
4461 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
4462 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
4463 ))),
4464 "block" => Ok(Self::Block(::std::boxed::Box::new(
4465 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
4466 ))),
4467 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
4468 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
4469 ))),
4470 "call" => Ok(Self::Call(::std::boxed::Box::new(
4471 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
4472 ))),
4473 "char" => Ok(Self::Char(::std::boxed::Box::new(
4474 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
4475 ))),
4476 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4477 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4478 ))),
4479 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
4480 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
4481 ))),
4482 "float" => Ok(Self::Float(::std::boxed::Box::new(
4483 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
4484 ))),
4485 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4486 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4487 ))),
4488 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
4489 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
4490 ))),
4491 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
4492 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
4493 ))),
4494 "list" => Ok(Self::List(::std::boxed::Box::new(
4495 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
4496 ))),
4497 "map" => Ok(Self::Map(::std::boxed::Box::new(
4498 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
4499 ))),
4500 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
4501 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4502 ))),
4503 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4504 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4505 ))),
4506 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4507 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4508 ))),
4509 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4510 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4511 ))),
4512 "string" => Ok(Self::String(::std::boxed::Box::new(
4513 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4514 ))),
4515 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4516 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4517 ))),
4518 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4519 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4520 ))),
4521 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4522 }
4523 }
4524}
4525impl ::treesitter_types::Spanned for ListChildren<'_> {
4526 fn span(&self) -> ::treesitter_types::Span {
4527 match self {
4528 Self::AccessCall(inner) => inner.span(),
4529 Self::Alias(inner) => inner.span(),
4530 Self::AnonymousFunction(inner) => inner.span(),
4531 Self::Atom(inner) => inner.span(),
4532 Self::BinaryOperator(inner) => inner.span(),
4533 Self::Bitstring(inner) => inner.span(),
4534 Self::Block(inner) => inner.span(),
4535 Self::Boolean(inner) => inner.span(),
4536 Self::Call(inner) => inner.span(),
4537 Self::Char(inner) => inner.span(),
4538 Self::Charlist(inner) => inner.span(),
4539 Self::Dot(inner) => inner.span(),
4540 Self::Float(inner) => inner.span(),
4541 Self::Identifier(inner) => inner.span(),
4542 Self::Integer(inner) => inner.span(),
4543 Self::Keywords(inner) => inner.span(),
4544 Self::List(inner) => inner.span(),
4545 Self::Map(inner) => inner.span(),
4546 Self::Nil(inner) => inner.span(),
4547 Self::OperatorIdentifier(inner) => inner.span(),
4548 Self::QuotedAtom(inner) => inner.span(),
4549 Self::Sigil(inner) => inner.span(),
4550 Self::String(inner) => inner.span(),
4551 Self::Tuple(inner) => inner.span(),
4552 Self::UnaryOperator(inner) => inner.span(),
4553 }
4554 }
4555}
4556#[derive(Debug, Clone, PartialEq, Eq)]
4557pub enum MapChildren<'tree> {
4558 MapContent(::std::boxed::Box<MapContent<'tree>>),
4559 Struct(::std::boxed::Box<Struct<'tree>>),
4560}
4561impl<'tree> ::treesitter_types::FromNode<'tree> for MapChildren<'tree> {
4562 #[allow(clippy::collapsible_else_if)]
4563 fn from_node(
4564 node: ::tree_sitter::Node<'tree>,
4565 src: &'tree [u8],
4566 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4567 match node.kind() {
4568 "map_content" => Ok(Self::MapContent(::std::boxed::Box::new(
4569 <MapContent as ::treesitter_types::FromNode>::from_node(node, src)?,
4570 ))),
4571 "struct" => Ok(Self::Struct(::std::boxed::Box::new(
4572 <Struct as ::treesitter_types::FromNode>::from_node(node, src)?,
4573 ))),
4574 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4575 }
4576 }
4577}
4578impl ::treesitter_types::Spanned for MapChildren<'_> {
4579 fn span(&self) -> ::treesitter_types::Span {
4580 match self {
4581 Self::MapContent(inner) => inner.span(),
4582 Self::Struct(inner) => inner.span(),
4583 }
4584 }
4585}
4586#[derive(Debug, Clone, PartialEq, Eq)]
4587pub enum MapContentChildren<'tree> {
4588 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
4589 Alias(::std::boxed::Box<Alias<'tree>>),
4590 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
4591 Atom(::std::boxed::Box<Atom<'tree>>),
4592 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
4593 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
4594 Block(::std::boxed::Box<Block<'tree>>),
4595 Boolean(::std::boxed::Box<Boolean<'tree>>),
4596 Call(::std::boxed::Box<Call<'tree>>),
4597 Char(::std::boxed::Box<Char<'tree>>),
4598 Charlist(::std::boxed::Box<Charlist<'tree>>),
4599 Dot(::std::boxed::Box<Dot<'tree>>),
4600 Float(::std::boxed::Box<Float<'tree>>),
4601 Identifier(::std::boxed::Box<Identifier<'tree>>),
4602 Integer(::std::boxed::Box<Integer<'tree>>),
4603 Keywords(::std::boxed::Box<Keywords<'tree>>),
4604 List(::std::boxed::Box<List<'tree>>),
4605 Map(::std::boxed::Box<Map<'tree>>),
4606 Nil(::std::boxed::Box<Nil<'tree>>),
4607 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4608 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
4609 Sigil(::std::boxed::Box<Sigil<'tree>>),
4610 String(::std::boxed::Box<String<'tree>>),
4611 Tuple(::std::boxed::Box<Tuple<'tree>>),
4612 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
4613}
4614impl<'tree> ::treesitter_types::FromNode<'tree> for MapContentChildren<'tree> {
4615 #[allow(clippy::collapsible_else_if)]
4616 fn from_node(
4617 node: ::tree_sitter::Node<'tree>,
4618 src: &'tree [u8],
4619 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4620 match node.kind() {
4621 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
4622 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
4623 ))),
4624 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4625 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4626 ))),
4627 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
4628 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
4629 ))),
4630 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
4631 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
4632 ))),
4633 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
4634 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4635 ))),
4636 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
4637 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
4638 ))),
4639 "block" => Ok(Self::Block(::std::boxed::Box::new(
4640 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
4641 ))),
4642 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
4643 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
4644 ))),
4645 "call" => Ok(Self::Call(::std::boxed::Box::new(
4646 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
4647 ))),
4648 "char" => Ok(Self::Char(::std::boxed::Box::new(
4649 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
4650 ))),
4651 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4652 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4653 ))),
4654 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
4655 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
4656 ))),
4657 "float" => Ok(Self::Float(::std::boxed::Box::new(
4658 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
4659 ))),
4660 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4661 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4662 ))),
4663 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
4664 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
4665 ))),
4666 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
4667 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
4668 ))),
4669 "list" => Ok(Self::List(::std::boxed::Box::new(
4670 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
4671 ))),
4672 "map" => Ok(Self::Map(::std::boxed::Box::new(
4673 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
4674 ))),
4675 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
4676 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4677 ))),
4678 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4679 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4680 ))),
4681 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4682 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4683 ))),
4684 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4685 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4686 ))),
4687 "string" => Ok(Self::String(::std::boxed::Box::new(
4688 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4689 ))),
4690 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4691 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4692 ))),
4693 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4694 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4695 ))),
4696 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4697 }
4698 }
4699}
4700impl ::treesitter_types::Spanned for MapContentChildren<'_> {
4701 fn span(&self) -> ::treesitter_types::Span {
4702 match self {
4703 Self::AccessCall(inner) => inner.span(),
4704 Self::Alias(inner) => inner.span(),
4705 Self::AnonymousFunction(inner) => inner.span(),
4706 Self::Atom(inner) => inner.span(),
4707 Self::BinaryOperator(inner) => inner.span(),
4708 Self::Bitstring(inner) => inner.span(),
4709 Self::Block(inner) => inner.span(),
4710 Self::Boolean(inner) => inner.span(),
4711 Self::Call(inner) => inner.span(),
4712 Self::Char(inner) => inner.span(),
4713 Self::Charlist(inner) => inner.span(),
4714 Self::Dot(inner) => inner.span(),
4715 Self::Float(inner) => inner.span(),
4716 Self::Identifier(inner) => inner.span(),
4717 Self::Integer(inner) => inner.span(),
4718 Self::Keywords(inner) => inner.span(),
4719 Self::List(inner) => inner.span(),
4720 Self::Map(inner) => inner.span(),
4721 Self::Nil(inner) => inner.span(),
4722 Self::OperatorIdentifier(inner) => inner.span(),
4723 Self::QuotedAtom(inner) => inner.span(),
4724 Self::Sigil(inner) => inner.span(),
4725 Self::String(inner) => inner.span(),
4726 Self::Tuple(inner) => inner.span(),
4727 Self::UnaryOperator(inner) => inner.span(),
4728 }
4729 }
4730}
4731#[derive(Debug, Clone, PartialEq, Eq)]
4732pub enum PairKey<'tree> {
4733 Keyword(::std::boxed::Box<Keyword<'tree>>),
4734 QuotedKeyword(::std::boxed::Box<QuotedKeyword<'tree>>),
4735}
4736impl<'tree> ::treesitter_types::FromNode<'tree> for PairKey<'tree> {
4737 #[allow(clippy::collapsible_else_if)]
4738 fn from_node(
4739 node: ::tree_sitter::Node<'tree>,
4740 src: &'tree [u8],
4741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4742 match node.kind() {
4743 "keyword" => Ok(Self::Keyword(::std::boxed::Box::new(
4744 <Keyword as ::treesitter_types::FromNode>::from_node(node, src)?,
4745 ))),
4746 "quoted_keyword" => Ok(Self::QuotedKeyword(::std::boxed::Box::new(
4747 <QuotedKeyword as ::treesitter_types::FromNode>::from_node(node, src)?,
4748 ))),
4749 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4750 }
4751 }
4752}
4753impl ::treesitter_types::Spanned for PairKey<'_> {
4754 fn span(&self) -> ::treesitter_types::Span {
4755 match self {
4756 Self::Keyword(inner) => inner.span(),
4757 Self::QuotedKeyword(inner) => inner.span(),
4758 }
4759 }
4760}
4761#[derive(Debug, Clone, PartialEq, Eq)]
4762pub enum PairValue<'tree> {
4763 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
4764 Alias(::std::boxed::Box<Alias<'tree>>),
4765 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
4766 Atom(::std::boxed::Box<Atom<'tree>>),
4767 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
4768 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
4769 Block(::std::boxed::Box<Block<'tree>>),
4770 Boolean(::std::boxed::Box<Boolean<'tree>>),
4771 Call(::std::boxed::Box<Call<'tree>>),
4772 Char(::std::boxed::Box<Char<'tree>>),
4773 Charlist(::std::boxed::Box<Charlist<'tree>>),
4774 Dot(::std::boxed::Box<Dot<'tree>>),
4775 Float(::std::boxed::Box<Float<'tree>>),
4776 Identifier(::std::boxed::Box<Identifier<'tree>>),
4777 Integer(::std::boxed::Box<Integer<'tree>>),
4778 List(::std::boxed::Box<List<'tree>>),
4779 Map(::std::boxed::Box<Map<'tree>>),
4780 Nil(::std::boxed::Box<Nil<'tree>>),
4781 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
4782 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
4783 Sigil(::std::boxed::Box<Sigil<'tree>>),
4784 String(::std::boxed::Box<String<'tree>>),
4785 Tuple(::std::boxed::Box<Tuple<'tree>>),
4786 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
4787}
4788impl<'tree> ::treesitter_types::FromNode<'tree> for PairValue<'tree> {
4789 #[allow(clippy::collapsible_else_if)]
4790 fn from_node(
4791 node: ::tree_sitter::Node<'tree>,
4792 src: &'tree [u8],
4793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4794 match node.kind() {
4795 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
4796 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
4797 ))),
4798 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
4799 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
4800 ))),
4801 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
4802 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
4803 ))),
4804 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
4805 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
4806 ))),
4807 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
4808 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4809 ))),
4810 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
4811 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
4812 ))),
4813 "block" => Ok(Self::Block(::std::boxed::Box::new(
4814 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
4815 ))),
4816 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
4817 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
4818 ))),
4819 "call" => Ok(Self::Call(::std::boxed::Box::new(
4820 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
4821 ))),
4822 "char" => Ok(Self::Char(::std::boxed::Box::new(
4823 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
4824 ))),
4825 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
4826 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
4827 ))),
4828 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
4829 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
4830 ))),
4831 "float" => Ok(Self::Float(::std::boxed::Box::new(
4832 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
4833 ))),
4834 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
4835 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4836 ))),
4837 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
4838 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
4839 ))),
4840 "list" => Ok(Self::List(::std::boxed::Box::new(
4841 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
4842 ))),
4843 "map" => Ok(Self::Map(::std::boxed::Box::new(
4844 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
4845 ))),
4846 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
4847 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
4848 ))),
4849 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
4850 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
4851 ))),
4852 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
4853 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
4854 ))),
4855 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
4856 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
4857 ))),
4858 "string" => Ok(Self::String(::std::boxed::Box::new(
4859 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
4860 ))),
4861 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
4862 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
4863 ))),
4864 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
4865 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
4866 ))),
4867 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4868 }
4869 }
4870}
4871impl ::treesitter_types::Spanned for PairValue<'_> {
4872 fn span(&self) -> ::treesitter_types::Span {
4873 match self {
4874 Self::AccessCall(inner) => inner.span(),
4875 Self::Alias(inner) => inner.span(),
4876 Self::AnonymousFunction(inner) => inner.span(),
4877 Self::Atom(inner) => inner.span(),
4878 Self::BinaryOperator(inner) => inner.span(),
4879 Self::Bitstring(inner) => inner.span(),
4880 Self::Block(inner) => inner.span(),
4881 Self::Boolean(inner) => inner.span(),
4882 Self::Call(inner) => inner.span(),
4883 Self::Char(inner) => inner.span(),
4884 Self::Charlist(inner) => inner.span(),
4885 Self::Dot(inner) => inner.span(),
4886 Self::Float(inner) => inner.span(),
4887 Self::Identifier(inner) => inner.span(),
4888 Self::Integer(inner) => inner.span(),
4889 Self::List(inner) => inner.span(),
4890 Self::Map(inner) => inner.span(),
4891 Self::Nil(inner) => inner.span(),
4892 Self::OperatorIdentifier(inner) => inner.span(),
4893 Self::QuotedAtom(inner) => inner.span(),
4894 Self::Sigil(inner) => inner.span(),
4895 Self::String(inner) => inner.span(),
4896 Self::Tuple(inner) => inner.span(),
4897 Self::UnaryOperator(inner) => inner.span(),
4898 }
4899 }
4900}
4901#[derive(Debug, Clone, PartialEq, Eq)]
4902pub enum QuotedAtomQuotedEnd {
4903 DoubleQuote(::treesitter_types::Span),
4904 SingleQuote(::treesitter_types::Span),
4905}
4906impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedAtomQuotedEnd {
4907 #[allow(clippy::collapsible_else_if)]
4908 fn from_node(
4909 node: ::tree_sitter::Node<'tree>,
4910 _src: &'tree [u8],
4911 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4912 match node.kind() {
4913 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
4914 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
4915 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4916 }
4917 }
4918}
4919impl ::treesitter_types::Spanned for QuotedAtomQuotedEnd {
4920 fn span(&self) -> ::treesitter_types::Span {
4921 match self {
4922 Self::DoubleQuote(span) => *span,
4923 Self::SingleQuote(span) => *span,
4924 }
4925 }
4926}
4927#[derive(Debug, Clone, PartialEq, Eq)]
4928pub enum QuotedAtomQuotedStart {
4929 DoubleQuote(::treesitter_types::Span),
4930 SingleQuote(::treesitter_types::Span),
4931}
4932impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedAtomQuotedStart {
4933 #[allow(clippy::collapsible_else_if)]
4934 fn from_node(
4935 node: ::tree_sitter::Node<'tree>,
4936 _src: &'tree [u8],
4937 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4938 match node.kind() {
4939 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
4940 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
4941 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4942 }
4943 }
4944}
4945impl ::treesitter_types::Spanned for QuotedAtomQuotedStart {
4946 fn span(&self) -> ::treesitter_types::Span {
4947 match self {
4948 Self::DoubleQuote(span) => *span,
4949 Self::SingleQuote(span) => *span,
4950 }
4951 }
4952}
4953#[derive(Debug, Clone, PartialEq, Eq)]
4954pub enum QuotedAtomChildren<'tree> {
4955 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
4956 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
4957 QuotedContent(::std::boxed::Box<QuotedContent<'tree>>),
4958}
4959impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedAtomChildren<'tree> {
4960 #[allow(clippy::collapsible_else_if)]
4961 fn from_node(
4962 node: ::tree_sitter::Node<'tree>,
4963 src: &'tree [u8],
4964 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4965 match node.kind() {
4966 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
4967 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
4968 ))),
4969 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
4970 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
4971 ))),
4972 "quoted_content" => Ok(Self::QuotedContent(::std::boxed::Box::new(
4973 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)?,
4974 ))),
4975 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
4976 }
4977 }
4978}
4979impl ::treesitter_types::Spanned for QuotedAtomChildren<'_> {
4980 fn span(&self) -> ::treesitter_types::Span {
4981 match self {
4982 Self::EscapeSequence(inner) => inner.span(),
4983 Self::Interpolation(inner) => inner.span(),
4984 Self::QuotedContent(inner) => inner.span(),
4985 }
4986 }
4987}
4988#[derive(Debug, Clone, PartialEq, Eq)]
4989pub enum QuotedKeywordQuotedEnd {
4990 DoubleQuote(::treesitter_types::Span),
4991 SingleQuote(::treesitter_types::Span),
4992}
4993impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedKeywordQuotedEnd {
4994 #[allow(clippy::collapsible_else_if)]
4995 fn from_node(
4996 node: ::tree_sitter::Node<'tree>,
4997 _src: &'tree [u8],
4998 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
4999 match node.kind() {
5000 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5001 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
5002 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5003 }
5004 }
5005}
5006impl ::treesitter_types::Spanned for QuotedKeywordQuotedEnd {
5007 fn span(&self) -> ::treesitter_types::Span {
5008 match self {
5009 Self::DoubleQuote(span) => *span,
5010 Self::SingleQuote(span) => *span,
5011 }
5012 }
5013}
5014#[derive(Debug, Clone, PartialEq, Eq)]
5015pub enum QuotedKeywordQuotedStart {
5016 DoubleQuote(::treesitter_types::Span),
5017 SingleQuote(::treesitter_types::Span),
5018}
5019impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedKeywordQuotedStart {
5020 #[allow(clippy::collapsible_else_if)]
5021 fn from_node(
5022 node: ::tree_sitter::Node<'tree>,
5023 _src: &'tree [u8],
5024 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5025 match node.kind() {
5026 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5027 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
5028 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5029 }
5030 }
5031}
5032impl ::treesitter_types::Spanned for QuotedKeywordQuotedStart {
5033 fn span(&self) -> ::treesitter_types::Span {
5034 match self {
5035 Self::DoubleQuote(span) => *span,
5036 Self::SingleQuote(span) => *span,
5037 }
5038 }
5039}
5040#[derive(Debug, Clone, PartialEq, Eq)]
5041pub enum QuotedKeywordChildren<'tree> {
5042 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
5043 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
5044 QuotedContent(::std::boxed::Box<QuotedContent<'tree>>),
5045}
5046impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedKeywordChildren<'tree> {
5047 #[allow(clippy::collapsible_else_if)]
5048 fn from_node(
5049 node: ::tree_sitter::Node<'tree>,
5050 src: &'tree [u8],
5051 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5052 match node.kind() {
5053 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
5054 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
5055 ))),
5056 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
5057 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
5058 ))),
5059 "quoted_content" => Ok(Self::QuotedContent(::std::boxed::Box::new(
5060 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)?,
5061 ))),
5062 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5063 }
5064 }
5065}
5066impl ::treesitter_types::Spanned for QuotedKeywordChildren<'_> {
5067 fn span(&self) -> ::treesitter_types::Span {
5068 match self {
5069 Self::EscapeSequence(inner) => inner.span(),
5070 Self::Interpolation(inner) => inner.span(),
5071 Self::QuotedContent(inner) => inner.span(),
5072 }
5073 }
5074}
5075#[derive(Debug, Clone, PartialEq, Eq)]
5076pub enum RescueBlockChildren<'tree> {
5077 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
5078 Alias(::std::boxed::Box<Alias<'tree>>),
5079 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
5080 Atom(::std::boxed::Box<Atom<'tree>>),
5081 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
5082 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
5083 Block(::std::boxed::Box<Block<'tree>>),
5084 Boolean(::std::boxed::Box<Boolean<'tree>>),
5085 Call(::std::boxed::Box<Call<'tree>>),
5086 Char(::std::boxed::Box<Char<'tree>>),
5087 Charlist(::std::boxed::Box<Charlist<'tree>>),
5088 Dot(::std::boxed::Box<Dot<'tree>>),
5089 Float(::std::boxed::Box<Float<'tree>>),
5090 Identifier(::std::boxed::Box<Identifier<'tree>>),
5091 Integer(::std::boxed::Box<Integer<'tree>>),
5092 List(::std::boxed::Box<List<'tree>>),
5093 Map(::std::boxed::Box<Map<'tree>>),
5094 Nil(::std::boxed::Box<Nil<'tree>>),
5095 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
5096 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
5097 Sigil(::std::boxed::Box<Sigil<'tree>>),
5098 StabClause(::std::boxed::Box<StabClause<'tree>>),
5099 String(::std::boxed::Box<String<'tree>>),
5100 Tuple(::std::boxed::Box<Tuple<'tree>>),
5101 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
5102}
5103impl<'tree> ::treesitter_types::FromNode<'tree> for RescueBlockChildren<'tree> {
5104 #[allow(clippy::collapsible_else_if)]
5105 fn from_node(
5106 node: ::tree_sitter::Node<'tree>,
5107 src: &'tree [u8],
5108 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5109 match node.kind() {
5110 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
5111 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
5112 ))),
5113 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
5114 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
5115 ))),
5116 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
5117 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
5118 ))),
5119 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
5120 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
5121 ))),
5122 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
5123 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5124 ))),
5125 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
5126 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
5127 ))),
5128 "block" => Ok(Self::Block(::std::boxed::Box::new(
5129 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
5130 ))),
5131 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
5132 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
5133 ))),
5134 "call" => Ok(Self::Call(::std::boxed::Box::new(
5135 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
5136 ))),
5137 "char" => Ok(Self::Char(::std::boxed::Box::new(
5138 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
5139 ))),
5140 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
5141 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
5142 ))),
5143 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
5144 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
5145 ))),
5146 "float" => Ok(Self::Float(::std::boxed::Box::new(
5147 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
5148 ))),
5149 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
5150 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5151 ))),
5152 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
5153 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
5154 ))),
5155 "list" => Ok(Self::List(::std::boxed::Box::new(
5156 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
5157 ))),
5158 "map" => Ok(Self::Map(::std::boxed::Box::new(
5159 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
5160 ))),
5161 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
5162 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
5163 ))),
5164 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
5165 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5166 ))),
5167 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
5168 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
5169 ))),
5170 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
5171 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
5172 ))),
5173 "stab_clause" => Ok(Self::StabClause(::std::boxed::Box::new(
5174 <StabClause as ::treesitter_types::FromNode>::from_node(node, src)?,
5175 ))),
5176 "string" => Ok(Self::String(::std::boxed::Box::new(
5177 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
5178 ))),
5179 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
5180 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
5181 ))),
5182 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
5183 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5184 ))),
5185 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5186 }
5187 }
5188}
5189impl ::treesitter_types::Spanned for RescueBlockChildren<'_> {
5190 fn span(&self) -> ::treesitter_types::Span {
5191 match self {
5192 Self::AccessCall(inner) => inner.span(),
5193 Self::Alias(inner) => inner.span(),
5194 Self::AnonymousFunction(inner) => inner.span(),
5195 Self::Atom(inner) => inner.span(),
5196 Self::BinaryOperator(inner) => inner.span(),
5197 Self::Bitstring(inner) => inner.span(),
5198 Self::Block(inner) => inner.span(),
5199 Self::Boolean(inner) => inner.span(),
5200 Self::Call(inner) => inner.span(),
5201 Self::Char(inner) => inner.span(),
5202 Self::Charlist(inner) => inner.span(),
5203 Self::Dot(inner) => inner.span(),
5204 Self::Float(inner) => inner.span(),
5205 Self::Identifier(inner) => inner.span(),
5206 Self::Integer(inner) => inner.span(),
5207 Self::List(inner) => inner.span(),
5208 Self::Map(inner) => inner.span(),
5209 Self::Nil(inner) => inner.span(),
5210 Self::OperatorIdentifier(inner) => inner.span(),
5211 Self::QuotedAtom(inner) => inner.span(),
5212 Self::Sigil(inner) => inner.span(),
5213 Self::StabClause(inner) => inner.span(),
5214 Self::String(inner) => inner.span(),
5215 Self::Tuple(inner) => inner.span(),
5216 Self::UnaryOperator(inner) => inner.span(),
5217 }
5218 }
5219}
5220#[derive(Debug, Clone, PartialEq, Eq)]
5221pub enum SigilQuotedEnd {
5222 DoubleQuote(::treesitter_types::Span),
5223 DQuoteDQuoteDQuote(::treesitter_types::Span),
5224 SingleQuote(::treesitter_types::Span),
5225 SQuoteSQuoteSQuote(::treesitter_types::Span),
5226 RParen(::treesitter_types::Span),
5227 Slash(::treesitter_types::Span),
5228 Gt(::treesitter_types::Span),
5229 RBracket(::treesitter_types::Span),
5230 Pipe(::treesitter_types::Span),
5231 RBrace(::treesitter_types::Span),
5232}
5233impl<'tree> ::treesitter_types::FromNode<'tree> for SigilQuotedEnd {
5234 #[allow(clippy::collapsible_else_if)]
5235 fn from_node(
5236 node: ::tree_sitter::Node<'tree>,
5237 _src: &'tree [u8],
5238 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5239 match node.kind() {
5240 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5241 "\"\"\"" => Ok(Self::DQuoteDQuoteDQuote(::treesitter_types::Span::from(
5242 node,
5243 ))),
5244 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
5245 "'''" => Ok(Self::SQuoteSQuoteSQuote(::treesitter_types::Span::from(
5246 node,
5247 ))),
5248 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
5249 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
5250 ">" => Ok(Self::Gt(::treesitter_types::Span::from(node))),
5251 "]" => Ok(Self::RBracket(::treesitter_types::Span::from(node))),
5252 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
5253 "}" => Ok(Self::RBrace(::treesitter_types::Span::from(node))),
5254 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5255 }
5256 }
5257}
5258impl ::treesitter_types::Spanned for SigilQuotedEnd {
5259 fn span(&self) -> ::treesitter_types::Span {
5260 match self {
5261 Self::DoubleQuote(span) => *span,
5262 Self::DQuoteDQuoteDQuote(span) => *span,
5263 Self::SingleQuote(span) => *span,
5264 Self::SQuoteSQuoteSQuote(span) => *span,
5265 Self::RParen(span) => *span,
5266 Self::Slash(span) => *span,
5267 Self::Gt(span) => *span,
5268 Self::RBracket(span) => *span,
5269 Self::Pipe(span) => *span,
5270 Self::RBrace(span) => *span,
5271 }
5272 }
5273}
5274#[derive(Debug, Clone, PartialEq, Eq)]
5275pub enum SigilQuotedStart {
5276 DoubleQuote(::treesitter_types::Span),
5277 DQuoteDQuoteDQuote(::treesitter_types::Span),
5278 SingleQuote(::treesitter_types::Span),
5279 SQuoteSQuoteSQuote(::treesitter_types::Span),
5280 LParen(::treesitter_types::Span),
5281 Slash(::treesitter_types::Span),
5282 Lt(::treesitter_types::Span),
5283 LBracket(::treesitter_types::Span),
5284 LBrace(::treesitter_types::Span),
5285 Pipe(::treesitter_types::Span),
5286}
5287impl<'tree> ::treesitter_types::FromNode<'tree> for SigilQuotedStart {
5288 #[allow(clippy::collapsible_else_if)]
5289 fn from_node(
5290 node: ::tree_sitter::Node<'tree>,
5291 _src: &'tree [u8],
5292 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5293 match node.kind() {
5294 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5295 "\"\"\"" => Ok(Self::DQuoteDQuoteDQuote(::treesitter_types::Span::from(
5296 node,
5297 ))),
5298 "'" => Ok(Self::SingleQuote(::treesitter_types::Span::from(node))),
5299 "'''" => Ok(Self::SQuoteSQuoteSQuote(::treesitter_types::Span::from(
5300 node,
5301 ))),
5302 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
5303 "/" => Ok(Self::Slash(::treesitter_types::Span::from(node))),
5304 "<" => Ok(Self::Lt(::treesitter_types::Span::from(node))),
5305 "[" => Ok(Self::LBracket(::treesitter_types::Span::from(node))),
5306 "{" => Ok(Self::LBrace(::treesitter_types::Span::from(node))),
5307 "|" => Ok(Self::Pipe(::treesitter_types::Span::from(node))),
5308 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5309 }
5310 }
5311}
5312impl ::treesitter_types::Spanned for SigilQuotedStart {
5313 fn span(&self) -> ::treesitter_types::Span {
5314 match self {
5315 Self::DoubleQuote(span) => *span,
5316 Self::DQuoteDQuoteDQuote(span) => *span,
5317 Self::SingleQuote(span) => *span,
5318 Self::SQuoteSQuoteSQuote(span) => *span,
5319 Self::LParen(span) => *span,
5320 Self::Slash(span) => *span,
5321 Self::Lt(span) => *span,
5322 Self::LBracket(span) => *span,
5323 Self::LBrace(span) => *span,
5324 Self::Pipe(span) => *span,
5325 }
5326 }
5327}
5328#[derive(Debug, Clone, PartialEq, Eq)]
5329pub enum SigilChildren<'tree> {
5330 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
5331 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
5332 QuotedContent(::std::boxed::Box<QuotedContent<'tree>>),
5333 SigilModifiers(::std::boxed::Box<SigilModifiers<'tree>>),
5334 SigilName(::std::boxed::Box<SigilName<'tree>>),
5335}
5336impl<'tree> ::treesitter_types::FromNode<'tree> for SigilChildren<'tree> {
5337 #[allow(clippy::collapsible_else_if)]
5338 fn from_node(
5339 node: ::tree_sitter::Node<'tree>,
5340 src: &'tree [u8],
5341 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5342 match node.kind() {
5343 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
5344 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
5345 ))),
5346 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
5347 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
5348 ))),
5349 "quoted_content" => Ok(Self::QuotedContent(::std::boxed::Box::new(
5350 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)?,
5351 ))),
5352 "sigil_modifiers" => Ok(Self::SigilModifiers(::std::boxed::Box::new(
5353 <SigilModifiers as ::treesitter_types::FromNode>::from_node(node, src)?,
5354 ))),
5355 "sigil_name" => Ok(Self::SigilName(::std::boxed::Box::new(
5356 <SigilName as ::treesitter_types::FromNode>::from_node(node, src)?,
5357 ))),
5358 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5359 }
5360 }
5361}
5362impl ::treesitter_types::Spanned for SigilChildren<'_> {
5363 fn span(&self) -> ::treesitter_types::Span {
5364 match self {
5365 Self::EscapeSequence(inner) => inner.span(),
5366 Self::Interpolation(inner) => inner.span(),
5367 Self::QuotedContent(inner) => inner.span(),
5368 Self::SigilModifiers(inner) => inner.span(),
5369 Self::SigilName(inner) => inner.span(),
5370 }
5371 }
5372}
5373#[derive(Debug, Clone, PartialEq, Eq)]
5374pub enum SourceChildren<'tree> {
5375 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
5376 Alias(::std::boxed::Box<Alias<'tree>>),
5377 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
5378 Atom(::std::boxed::Box<Atom<'tree>>),
5379 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
5380 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
5381 Block(::std::boxed::Box<Block<'tree>>),
5382 Boolean(::std::boxed::Box<Boolean<'tree>>),
5383 Call(::std::boxed::Box<Call<'tree>>),
5384 Char(::std::boxed::Box<Char<'tree>>),
5385 Charlist(::std::boxed::Box<Charlist<'tree>>),
5386 Dot(::std::boxed::Box<Dot<'tree>>),
5387 Float(::std::boxed::Box<Float<'tree>>),
5388 Identifier(::std::boxed::Box<Identifier<'tree>>),
5389 Integer(::std::boxed::Box<Integer<'tree>>),
5390 List(::std::boxed::Box<List<'tree>>),
5391 Map(::std::boxed::Box<Map<'tree>>),
5392 Nil(::std::boxed::Box<Nil<'tree>>),
5393 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
5394 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
5395 Sigil(::std::boxed::Box<Sigil<'tree>>),
5396 String(::std::boxed::Box<String<'tree>>),
5397 Tuple(::std::boxed::Box<Tuple<'tree>>),
5398 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
5399}
5400impl<'tree> ::treesitter_types::FromNode<'tree> for SourceChildren<'tree> {
5401 #[allow(clippy::collapsible_else_if)]
5402 fn from_node(
5403 node: ::tree_sitter::Node<'tree>,
5404 src: &'tree [u8],
5405 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5406 match node.kind() {
5407 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
5408 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
5409 ))),
5410 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
5411 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
5412 ))),
5413 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
5414 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
5415 ))),
5416 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
5417 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
5418 ))),
5419 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
5420 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5421 ))),
5422 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
5423 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
5424 ))),
5425 "block" => Ok(Self::Block(::std::boxed::Box::new(
5426 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
5427 ))),
5428 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
5429 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
5430 ))),
5431 "call" => Ok(Self::Call(::std::boxed::Box::new(
5432 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
5433 ))),
5434 "char" => Ok(Self::Char(::std::boxed::Box::new(
5435 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
5436 ))),
5437 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
5438 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
5439 ))),
5440 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
5441 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
5442 ))),
5443 "float" => Ok(Self::Float(::std::boxed::Box::new(
5444 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
5445 ))),
5446 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
5447 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5448 ))),
5449 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
5450 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
5451 ))),
5452 "list" => Ok(Self::List(::std::boxed::Box::new(
5453 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
5454 ))),
5455 "map" => Ok(Self::Map(::std::boxed::Box::new(
5456 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
5457 ))),
5458 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
5459 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
5460 ))),
5461 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
5462 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5463 ))),
5464 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
5465 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
5466 ))),
5467 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
5468 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
5469 ))),
5470 "string" => Ok(Self::String(::std::boxed::Box::new(
5471 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
5472 ))),
5473 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
5474 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
5475 ))),
5476 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
5477 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5478 ))),
5479 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5480 }
5481 }
5482}
5483impl ::treesitter_types::Spanned for SourceChildren<'_> {
5484 fn span(&self) -> ::treesitter_types::Span {
5485 match self {
5486 Self::AccessCall(inner) => inner.span(),
5487 Self::Alias(inner) => inner.span(),
5488 Self::AnonymousFunction(inner) => inner.span(),
5489 Self::Atom(inner) => inner.span(),
5490 Self::BinaryOperator(inner) => inner.span(),
5491 Self::Bitstring(inner) => inner.span(),
5492 Self::Block(inner) => inner.span(),
5493 Self::Boolean(inner) => inner.span(),
5494 Self::Call(inner) => inner.span(),
5495 Self::Char(inner) => inner.span(),
5496 Self::Charlist(inner) => inner.span(),
5497 Self::Dot(inner) => inner.span(),
5498 Self::Float(inner) => inner.span(),
5499 Self::Identifier(inner) => inner.span(),
5500 Self::Integer(inner) => inner.span(),
5501 Self::List(inner) => inner.span(),
5502 Self::Map(inner) => inner.span(),
5503 Self::Nil(inner) => inner.span(),
5504 Self::OperatorIdentifier(inner) => inner.span(),
5505 Self::QuotedAtom(inner) => inner.span(),
5506 Self::Sigil(inner) => inner.span(),
5507 Self::String(inner) => inner.span(),
5508 Self::Tuple(inner) => inner.span(),
5509 Self::UnaryOperator(inner) => inner.span(),
5510 }
5511 }
5512}
5513#[derive(Debug, Clone, PartialEq, Eq)]
5514pub enum StabClauseLeft<'tree> {
5515 Arguments(::std::boxed::Box<Arguments<'tree>>),
5516 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
5517}
5518impl<'tree> ::treesitter_types::FromNode<'tree> for StabClauseLeft<'tree> {
5519 #[allow(clippy::collapsible_else_if)]
5520 fn from_node(
5521 node: ::tree_sitter::Node<'tree>,
5522 src: &'tree [u8],
5523 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5524 match node.kind() {
5525 "arguments" => Ok(Self::Arguments(::std::boxed::Box::new(
5526 <Arguments as ::treesitter_types::FromNode>::from_node(node, src)?,
5527 ))),
5528 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
5529 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5530 ))),
5531 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5532 }
5533 }
5534}
5535impl ::treesitter_types::Spanned for StabClauseLeft<'_> {
5536 fn span(&self) -> ::treesitter_types::Span {
5537 match self {
5538 Self::Arguments(inner) => inner.span(),
5539 Self::BinaryOperator(inner) => inner.span(),
5540 }
5541 }
5542}
5543#[derive(Debug, Clone, PartialEq, Eq)]
5544pub enum StabClauseOperator {
5545 Arrow(::treesitter_types::Span),
5546}
5547impl<'tree> ::treesitter_types::FromNode<'tree> for StabClauseOperator {
5548 #[allow(clippy::collapsible_else_if)]
5549 fn from_node(
5550 node: ::tree_sitter::Node<'tree>,
5551 _src: &'tree [u8],
5552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5553 match node.kind() {
5554 "->" => Ok(Self::Arrow(::treesitter_types::Span::from(node))),
5555 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5556 }
5557 }
5558}
5559impl ::treesitter_types::Spanned for StabClauseOperator {
5560 fn span(&self) -> ::treesitter_types::Span {
5561 match self {
5562 Self::Arrow(span) => *span,
5563 }
5564 }
5565}
5566#[derive(Debug, Clone, PartialEq, Eq)]
5567pub enum StringQuotedEnd {
5568 DoubleQuote(::treesitter_types::Span),
5569 DQuoteDQuoteDQuote(::treesitter_types::Span),
5570}
5571impl<'tree> ::treesitter_types::FromNode<'tree> for StringQuotedEnd {
5572 #[allow(clippy::collapsible_else_if)]
5573 fn from_node(
5574 node: ::tree_sitter::Node<'tree>,
5575 _src: &'tree [u8],
5576 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5577 match node.kind() {
5578 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5579 "\"\"\"" => Ok(Self::DQuoteDQuoteDQuote(::treesitter_types::Span::from(
5580 node,
5581 ))),
5582 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5583 }
5584 }
5585}
5586impl ::treesitter_types::Spanned for StringQuotedEnd {
5587 fn span(&self) -> ::treesitter_types::Span {
5588 match self {
5589 Self::DoubleQuote(span) => *span,
5590 Self::DQuoteDQuoteDQuote(span) => *span,
5591 }
5592 }
5593}
5594#[derive(Debug, Clone, PartialEq, Eq)]
5595pub enum StringQuotedStart {
5596 DoubleQuote(::treesitter_types::Span),
5597 DQuoteDQuoteDQuote(::treesitter_types::Span),
5598}
5599impl<'tree> ::treesitter_types::FromNode<'tree> for StringQuotedStart {
5600 #[allow(clippy::collapsible_else_if)]
5601 fn from_node(
5602 node: ::tree_sitter::Node<'tree>,
5603 _src: &'tree [u8],
5604 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5605 match node.kind() {
5606 "\"" => Ok(Self::DoubleQuote(::treesitter_types::Span::from(node))),
5607 "\"\"\"" => Ok(Self::DQuoteDQuoteDQuote(::treesitter_types::Span::from(
5608 node,
5609 ))),
5610 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5611 }
5612 }
5613}
5614impl ::treesitter_types::Spanned for StringQuotedStart {
5615 fn span(&self) -> ::treesitter_types::Span {
5616 match self {
5617 Self::DoubleQuote(span) => *span,
5618 Self::DQuoteDQuoteDQuote(span) => *span,
5619 }
5620 }
5621}
5622#[derive(Debug, Clone, PartialEq, Eq)]
5623pub enum StringChildren<'tree> {
5624 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
5625 Interpolation(::std::boxed::Box<Interpolation<'tree>>),
5626 QuotedContent(::std::boxed::Box<QuotedContent<'tree>>),
5627}
5628impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
5629 #[allow(clippy::collapsible_else_if)]
5630 fn from_node(
5631 node: ::tree_sitter::Node<'tree>,
5632 src: &'tree [u8],
5633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5634 match node.kind() {
5635 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
5636 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)?,
5637 ))),
5638 "interpolation" => Ok(Self::Interpolation(::std::boxed::Box::new(
5639 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)?,
5640 ))),
5641 "quoted_content" => Ok(Self::QuotedContent(::std::boxed::Box::new(
5642 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)?,
5643 ))),
5644 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5645 }
5646 }
5647}
5648impl ::treesitter_types::Spanned for StringChildren<'_> {
5649 fn span(&self) -> ::treesitter_types::Span {
5650 match self {
5651 Self::EscapeSequence(inner) => inner.span(),
5652 Self::Interpolation(inner) => inner.span(),
5653 Self::QuotedContent(inner) => inner.span(),
5654 }
5655 }
5656}
5657#[derive(Debug, Clone, PartialEq, Eq)]
5658pub enum StructChildren<'tree> {
5659 Alias(::std::boxed::Box<Alias<'tree>>),
5660 Atom(::std::boxed::Box<Atom<'tree>>),
5661 Call(::std::boxed::Box<Call<'tree>>),
5662 Dot(::std::boxed::Box<Dot<'tree>>),
5663 Identifier(::std::boxed::Box<Identifier<'tree>>),
5664 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
5665 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
5666}
5667impl<'tree> ::treesitter_types::FromNode<'tree> for StructChildren<'tree> {
5668 #[allow(clippy::collapsible_else_if)]
5669 fn from_node(
5670 node: ::tree_sitter::Node<'tree>,
5671 src: &'tree [u8],
5672 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5673 match node.kind() {
5674 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
5675 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
5676 ))),
5677 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
5678 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
5679 ))),
5680 "call" => Ok(Self::Call(::std::boxed::Box::new(
5681 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
5682 ))),
5683 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
5684 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
5685 ))),
5686 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
5687 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5688 ))),
5689 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
5690 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
5691 ))),
5692 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
5693 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5694 ))),
5695 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5696 }
5697 }
5698}
5699impl ::treesitter_types::Spanned for StructChildren<'_> {
5700 fn span(&self) -> ::treesitter_types::Span {
5701 match self {
5702 Self::Alias(inner) => inner.span(),
5703 Self::Atom(inner) => inner.span(),
5704 Self::Call(inner) => inner.span(),
5705 Self::Dot(inner) => inner.span(),
5706 Self::Identifier(inner) => inner.span(),
5707 Self::QuotedAtom(inner) => inner.span(),
5708 Self::UnaryOperator(inner) => inner.span(),
5709 }
5710 }
5711}
5712#[derive(Debug, Clone, PartialEq, Eq)]
5713pub enum TupleChildren<'tree> {
5714 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
5715 Alias(::std::boxed::Box<Alias<'tree>>),
5716 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
5717 Atom(::std::boxed::Box<Atom<'tree>>),
5718 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
5719 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
5720 Block(::std::boxed::Box<Block<'tree>>),
5721 Boolean(::std::boxed::Box<Boolean<'tree>>),
5722 Call(::std::boxed::Box<Call<'tree>>),
5723 Char(::std::boxed::Box<Char<'tree>>),
5724 Charlist(::std::boxed::Box<Charlist<'tree>>),
5725 Dot(::std::boxed::Box<Dot<'tree>>),
5726 Float(::std::boxed::Box<Float<'tree>>),
5727 Identifier(::std::boxed::Box<Identifier<'tree>>),
5728 Integer(::std::boxed::Box<Integer<'tree>>),
5729 Keywords(::std::boxed::Box<Keywords<'tree>>),
5730 List(::std::boxed::Box<List<'tree>>),
5731 Map(::std::boxed::Box<Map<'tree>>),
5732 Nil(::std::boxed::Box<Nil<'tree>>),
5733 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
5734 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
5735 Sigil(::std::boxed::Box<Sigil<'tree>>),
5736 String(::std::boxed::Box<String<'tree>>),
5737 Tuple(::std::boxed::Box<Tuple<'tree>>),
5738 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
5739}
5740impl<'tree> ::treesitter_types::FromNode<'tree> for TupleChildren<'tree> {
5741 #[allow(clippy::collapsible_else_if)]
5742 fn from_node(
5743 node: ::tree_sitter::Node<'tree>,
5744 src: &'tree [u8],
5745 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5746 match node.kind() {
5747 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
5748 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
5749 ))),
5750 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
5751 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
5752 ))),
5753 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
5754 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
5755 ))),
5756 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
5757 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
5758 ))),
5759 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
5760 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5761 ))),
5762 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
5763 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
5764 ))),
5765 "block" => Ok(Self::Block(::std::boxed::Box::new(
5766 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
5767 ))),
5768 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
5769 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
5770 ))),
5771 "call" => Ok(Self::Call(::std::boxed::Box::new(
5772 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
5773 ))),
5774 "char" => Ok(Self::Char(::std::boxed::Box::new(
5775 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
5776 ))),
5777 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
5778 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
5779 ))),
5780 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
5781 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
5782 ))),
5783 "float" => Ok(Self::Float(::std::boxed::Box::new(
5784 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
5785 ))),
5786 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
5787 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5788 ))),
5789 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
5790 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
5791 ))),
5792 "keywords" => Ok(Self::Keywords(::std::boxed::Box::new(
5793 <Keywords as ::treesitter_types::FromNode>::from_node(node, src)?,
5794 ))),
5795 "list" => Ok(Self::List(::std::boxed::Box::new(
5796 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
5797 ))),
5798 "map" => Ok(Self::Map(::std::boxed::Box::new(
5799 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
5800 ))),
5801 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
5802 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
5803 ))),
5804 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
5805 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5806 ))),
5807 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
5808 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
5809 ))),
5810 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
5811 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
5812 ))),
5813 "string" => Ok(Self::String(::std::boxed::Box::new(
5814 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
5815 ))),
5816 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
5817 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
5818 ))),
5819 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
5820 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5821 ))),
5822 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5823 }
5824 }
5825}
5826impl ::treesitter_types::Spanned for TupleChildren<'_> {
5827 fn span(&self) -> ::treesitter_types::Span {
5828 match self {
5829 Self::AccessCall(inner) => inner.span(),
5830 Self::Alias(inner) => inner.span(),
5831 Self::AnonymousFunction(inner) => inner.span(),
5832 Self::Atom(inner) => inner.span(),
5833 Self::BinaryOperator(inner) => inner.span(),
5834 Self::Bitstring(inner) => inner.span(),
5835 Self::Block(inner) => inner.span(),
5836 Self::Boolean(inner) => inner.span(),
5837 Self::Call(inner) => inner.span(),
5838 Self::Char(inner) => inner.span(),
5839 Self::Charlist(inner) => inner.span(),
5840 Self::Dot(inner) => inner.span(),
5841 Self::Float(inner) => inner.span(),
5842 Self::Identifier(inner) => inner.span(),
5843 Self::Integer(inner) => inner.span(),
5844 Self::Keywords(inner) => inner.span(),
5845 Self::List(inner) => inner.span(),
5846 Self::Map(inner) => inner.span(),
5847 Self::Nil(inner) => inner.span(),
5848 Self::OperatorIdentifier(inner) => inner.span(),
5849 Self::QuotedAtom(inner) => inner.span(),
5850 Self::Sigil(inner) => inner.span(),
5851 Self::String(inner) => inner.span(),
5852 Self::Tuple(inner) => inner.span(),
5853 Self::UnaryOperator(inner) => inner.span(),
5854 }
5855 }
5856}
5857#[derive(Debug, Clone, PartialEq, Eq)]
5858pub enum UnaryOperatorOperand<'tree> {
5859 LParen(::treesitter_types::Span),
5860 RParen(::treesitter_types::Span),
5861 AccessCall(::std::boxed::Box<AccessCall<'tree>>),
5862 Alias(::std::boxed::Box<Alias<'tree>>),
5863 AnonymousFunction(::std::boxed::Box<AnonymousFunction<'tree>>),
5864 Atom(::std::boxed::Box<Atom<'tree>>),
5865 BinaryOperator(::std::boxed::Box<BinaryOperator<'tree>>),
5866 Bitstring(::std::boxed::Box<Bitstring<'tree>>),
5867 Block(::std::boxed::Box<Block<'tree>>),
5868 Boolean(::std::boxed::Box<Boolean<'tree>>),
5869 Call(::std::boxed::Box<Call<'tree>>),
5870 Char(::std::boxed::Box<Char<'tree>>),
5871 Charlist(::std::boxed::Box<Charlist<'tree>>),
5872 Dot(::std::boxed::Box<Dot<'tree>>),
5873 Float(::std::boxed::Box<Float<'tree>>),
5874 Identifier(::std::boxed::Box<Identifier<'tree>>),
5875 Integer(::std::boxed::Box<Integer<'tree>>),
5876 List(::std::boxed::Box<List<'tree>>),
5877 Map(::std::boxed::Box<Map<'tree>>),
5878 Nil(::std::boxed::Box<Nil<'tree>>),
5879 OperatorIdentifier(::std::boxed::Box<OperatorIdentifier<'tree>>),
5880 QuotedAtom(::std::boxed::Box<QuotedAtom<'tree>>),
5881 Sigil(::std::boxed::Box<Sigil<'tree>>),
5882 String(::std::boxed::Box<String<'tree>>),
5883 Tuple(::std::boxed::Box<Tuple<'tree>>),
5884 UnaryOperator(::std::boxed::Box<UnaryOperator<'tree>>),
5885}
5886impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperatorOperand<'tree> {
5887 #[allow(clippy::collapsible_else_if)]
5888 fn from_node(
5889 node: ::tree_sitter::Node<'tree>,
5890 src: &'tree [u8],
5891 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
5892 match node.kind() {
5893 "(" => Ok(Self::LParen(::treesitter_types::Span::from(node))),
5894 ")" => Ok(Self::RParen(::treesitter_types::Span::from(node))),
5895 "access_call" => Ok(Self::AccessCall(::std::boxed::Box::new(
5896 <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)?,
5897 ))),
5898 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
5899 <Alias as ::treesitter_types::FromNode>::from_node(node, src)?,
5900 ))),
5901 "anonymous_function" => Ok(Self::AnonymousFunction(::std::boxed::Box::new(
5902 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)?,
5903 ))),
5904 "atom" => Ok(Self::Atom(::std::boxed::Box::new(
5905 <Atom as ::treesitter_types::FromNode>::from_node(node, src)?,
5906 ))),
5907 "binary_operator" => Ok(Self::BinaryOperator(::std::boxed::Box::new(
5908 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5909 ))),
5910 "bitstring" => Ok(Self::Bitstring(::std::boxed::Box::new(
5911 <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)?,
5912 ))),
5913 "block" => Ok(Self::Block(::std::boxed::Box::new(
5914 <Block as ::treesitter_types::FromNode>::from_node(node, src)?,
5915 ))),
5916 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
5917 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)?,
5918 ))),
5919 "call" => Ok(Self::Call(::std::boxed::Box::new(
5920 <Call as ::treesitter_types::FromNode>::from_node(node, src)?,
5921 ))),
5922 "char" => Ok(Self::Char(::std::boxed::Box::new(
5923 <Char as ::treesitter_types::FromNode>::from_node(node, src)?,
5924 ))),
5925 "charlist" => Ok(Self::Charlist(::std::boxed::Box::new(
5926 <Charlist as ::treesitter_types::FromNode>::from_node(node, src)?,
5927 ))),
5928 "dot" => Ok(Self::Dot(::std::boxed::Box::new(
5929 <Dot as ::treesitter_types::FromNode>::from_node(node, src)?,
5930 ))),
5931 "float" => Ok(Self::Float(::std::boxed::Box::new(
5932 <Float as ::treesitter_types::FromNode>::from_node(node, src)?,
5933 ))),
5934 "identifier" => Ok(Self::Identifier(::std::boxed::Box::new(
5935 <Identifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5936 ))),
5937 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
5938 <Integer as ::treesitter_types::FromNode>::from_node(node, src)?,
5939 ))),
5940 "list" => Ok(Self::List(::std::boxed::Box::new(
5941 <List as ::treesitter_types::FromNode>::from_node(node, src)?,
5942 ))),
5943 "map" => Ok(Self::Map(::std::boxed::Box::new(
5944 <Map as ::treesitter_types::FromNode>::from_node(node, src)?,
5945 ))),
5946 "nil" => Ok(Self::Nil(::std::boxed::Box::new(
5947 <Nil as ::treesitter_types::FromNode>::from_node(node, src)?,
5948 ))),
5949 "operator_identifier" => Ok(Self::OperatorIdentifier(::std::boxed::Box::new(
5950 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)?,
5951 ))),
5952 "quoted_atom" => Ok(Self::QuotedAtom(::std::boxed::Box::new(
5953 <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)?,
5954 ))),
5955 "sigil" => Ok(Self::Sigil(::std::boxed::Box::new(
5956 <Sigil as ::treesitter_types::FromNode>::from_node(node, src)?,
5957 ))),
5958 "string" => Ok(Self::String(::std::boxed::Box::new(
5959 <String as ::treesitter_types::FromNode>::from_node(node, src)?,
5960 ))),
5961 "tuple" => Ok(Self::Tuple(::std::boxed::Box::new(
5962 <Tuple as ::treesitter_types::FromNode>::from_node(node, src)?,
5963 ))),
5964 "unary_operator" => Ok(Self::UnaryOperator(::std::boxed::Box::new(
5965 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)?,
5966 ))),
5967 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
5968 }
5969 }
5970}
5971impl ::treesitter_types::Spanned for UnaryOperatorOperand<'_> {
5972 fn span(&self) -> ::treesitter_types::Span {
5973 match self {
5974 Self::LParen(span) => *span,
5975 Self::RParen(span) => *span,
5976 Self::AccessCall(inner) => inner.span(),
5977 Self::Alias(inner) => inner.span(),
5978 Self::AnonymousFunction(inner) => inner.span(),
5979 Self::Atom(inner) => inner.span(),
5980 Self::BinaryOperator(inner) => inner.span(),
5981 Self::Bitstring(inner) => inner.span(),
5982 Self::Block(inner) => inner.span(),
5983 Self::Boolean(inner) => inner.span(),
5984 Self::Call(inner) => inner.span(),
5985 Self::Char(inner) => inner.span(),
5986 Self::Charlist(inner) => inner.span(),
5987 Self::Dot(inner) => inner.span(),
5988 Self::Float(inner) => inner.span(),
5989 Self::Identifier(inner) => inner.span(),
5990 Self::Integer(inner) => inner.span(),
5991 Self::List(inner) => inner.span(),
5992 Self::Map(inner) => inner.span(),
5993 Self::Nil(inner) => inner.span(),
5994 Self::OperatorIdentifier(inner) => inner.span(),
5995 Self::QuotedAtom(inner) => inner.span(),
5996 Self::Sigil(inner) => inner.span(),
5997 Self::String(inner) => inner.span(),
5998 Self::Tuple(inner) => inner.span(),
5999 Self::UnaryOperator(inner) => inner.span(),
6000 }
6001 }
6002}
6003#[derive(Debug, Clone, PartialEq, Eq)]
6004pub enum UnaryOperatorOperator {
6005 Bang(::treesitter_types::Span),
6006 Amp(::treesitter_types::Span),
6007 Plus(::treesitter_types::Span),
6008 Minus(::treesitter_types::Span),
6009 At(::treesitter_types::Span),
6010 Caret(::treesitter_types::Span),
6011 Not(::treesitter_types::Span),
6012 TildeTildeTilde(::treesitter_types::Span),
6013}
6014impl<'tree> ::treesitter_types::FromNode<'tree> for UnaryOperatorOperator {
6015 #[allow(clippy::collapsible_else_if)]
6016 fn from_node(
6017 node: ::tree_sitter::Node<'tree>,
6018 _src: &'tree [u8],
6019 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
6020 match node.kind() {
6021 "!" => Ok(Self::Bang(::treesitter_types::Span::from(node))),
6022 "&" => Ok(Self::Amp(::treesitter_types::Span::from(node))),
6023 "+" => Ok(Self::Plus(::treesitter_types::Span::from(node))),
6024 "-" => Ok(Self::Minus(::treesitter_types::Span::from(node))),
6025 "@" => Ok(Self::At(::treesitter_types::Span::from(node))),
6026 "^" => Ok(Self::Caret(::treesitter_types::Span::from(node))),
6027 "not" => Ok(Self::Not(::treesitter_types::Span::from(node))),
6028 "~~~" => Ok(Self::TildeTildeTilde(::treesitter_types::Span::from(node))),
6029 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
6030 }
6031 }
6032}
6033impl ::treesitter_types::Spanned for UnaryOperatorOperator {
6034 fn span(&self) -> ::treesitter_types::Span {
6035 match self {
6036 Self::Bang(span) => *span,
6037 Self::Amp(span) => *span,
6038 Self::Plus(span) => *span,
6039 Self::Minus(span) => *span,
6040 Self::At(span) => *span,
6041 Self::Caret(span) => *span,
6042 Self::Not(span) => *span,
6043 Self::TildeTildeTilde(span) => *span,
6044 }
6045 }
6046}
6047#[derive(Debug, Clone, PartialEq, Eq)]
6048pub enum AnyNode<'tree> {
6049 AccessCall(AccessCall<'tree>),
6050 AfterBlock(AfterBlock<'tree>),
6051 AnonymousFunction(AnonymousFunction<'tree>),
6052 Arguments(Arguments<'tree>),
6053 BinaryOperator(BinaryOperator<'tree>),
6054 Bitstring(Bitstring<'tree>),
6055 Block(Block<'tree>),
6056 Body(Body<'tree>),
6057 Boolean(Boolean<'tree>),
6058 Call(Call<'tree>),
6059 CatchBlock(CatchBlock<'tree>),
6060 Charlist(Charlist<'tree>),
6061 DoBlock(DoBlock<'tree>),
6062 Dot(Dot<'tree>),
6063 ElseBlock(ElseBlock<'tree>),
6064 Identifier(Identifier<'tree>),
6065 Interpolation(Interpolation<'tree>),
6066 Keywords(Keywords<'tree>),
6067 List(List<'tree>),
6068 Map(Map<'tree>),
6069 MapContent(MapContent<'tree>),
6070 Nil(Nil<'tree>),
6071 OperatorIdentifier(OperatorIdentifier<'tree>),
6072 Pair(Pair<'tree>),
6073 QuotedAtom(QuotedAtom<'tree>),
6074 QuotedKeyword(QuotedKeyword<'tree>),
6075 RescueBlock(RescueBlock<'tree>),
6076 Sigil(Sigil<'tree>),
6077 Source(Source<'tree>),
6078 StabClause(StabClause<'tree>),
6079 String(String<'tree>),
6080 Struct(Struct<'tree>),
6081 Tuple(Tuple<'tree>),
6082 UnaryOperator(UnaryOperator<'tree>),
6083 Alias(Alias<'tree>),
6084 Atom(Atom<'tree>),
6085 Char(Char<'tree>),
6086 Comment(Comment<'tree>),
6087 EscapeSequence(EscapeSequence<'tree>),
6088 Float(Float<'tree>),
6089 Integer(Integer<'tree>),
6090 Keyword(Keyword<'tree>),
6091 QuotedContent(QuotedContent<'tree>),
6092 SigilModifiers(SigilModifiers<'tree>),
6093 SigilName(SigilName<'tree>),
6094 Unknown(::tree_sitter::Node<'tree>),
6095}
6096impl<'tree> AnyNode<'tree> {
6097 pub fn from_node(node: ::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
6098 match node.kind() {
6099 "access_call" => <AccessCall as ::treesitter_types::FromNode>::from_node(node, src)
6100 .map(Self::AccessCall)
6101 .unwrap_or(Self::Unknown(node)),
6102 "after_block" => <AfterBlock as ::treesitter_types::FromNode>::from_node(node, src)
6103 .map(Self::AfterBlock)
6104 .unwrap_or(Self::Unknown(node)),
6105 "anonymous_function" => {
6106 <AnonymousFunction as ::treesitter_types::FromNode>::from_node(node, src)
6107 .map(Self::AnonymousFunction)
6108 .unwrap_or(Self::Unknown(node))
6109 }
6110 "arguments" => <Arguments as ::treesitter_types::FromNode>::from_node(node, src)
6111 .map(Self::Arguments)
6112 .unwrap_or(Self::Unknown(node)),
6113 "binary_operator" => {
6114 <BinaryOperator as ::treesitter_types::FromNode>::from_node(node, src)
6115 .map(Self::BinaryOperator)
6116 .unwrap_or(Self::Unknown(node))
6117 }
6118 "bitstring" => <Bitstring as ::treesitter_types::FromNode>::from_node(node, src)
6119 .map(Self::Bitstring)
6120 .unwrap_or(Self::Unknown(node)),
6121 "block" => <Block as ::treesitter_types::FromNode>::from_node(node, src)
6122 .map(Self::Block)
6123 .unwrap_or(Self::Unknown(node)),
6124 "body" => <Body as ::treesitter_types::FromNode>::from_node(node, src)
6125 .map(Self::Body)
6126 .unwrap_or(Self::Unknown(node)),
6127 "boolean" => <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
6128 .map(Self::Boolean)
6129 .unwrap_or(Self::Unknown(node)),
6130 "call" => <Call as ::treesitter_types::FromNode>::from_node(node, src)
6131 .map(Self::Call)
6132 .unwrap_or(Self::Unknown(node)),
6133 "catch_block" => <CatchBlock as ::treesitter_types::FromNode>::from_node(node, src)
6134 .map(Self::CatchBlock)
6135 .unwrap_or(Self::Unknown(node)),
6136 "charlist" => <Charlist as ::treesitter_types::FromNode>::from_node(node, src)
6137 .map(Self::Charlist)
6138 .unwrap_or(Self::Unknown(node)),
6139 "do_block" => <DoBlock as ::treesitter_types::FromNode>::from_node(node, src)
6140 .map(Self::DoBlock)
6141 .unwrap_or(Self::Unknown(node)),
6142 "dot" => <Dot as ::treesitter_types::FromNode>::from_node(node, src)
6143 .map(Self::Dot)
6144 .unwrap_or(Self::Unknown(node)),
6145 "else_block" => <ElseBlock as ::treesitter_types::FromNode>::from_node(node, src)
6146 .map(Self::ElseBlock)
6147 .unwrap_or(Self::Unknown(node)),
6148 "identifier" => <Identifier as ::treesitter_types::FromNode>::from_node(node, src)
6149 .map(Self::Identifier)
6150 .unwrap_or(Self::Unknown(node)),
6151 "interpolation" => {
6152 <Interpolation as ::treesitter_types::FromNode>::from_node(node, src)
6153 .map(Self::Interpolation)
6154 .unwrap_or(Self::Unknown(node))
6155 }
6156 "keywords" => <Keywords as ::treesitter_types::FromNode>::from_node(node, src)
6157 .map(Self::Keywords)
6158 .unwrap_or(Self::Unknown(node)),
6159 "list" => <List as ::treesitter_types::FromNode>::from_node(node, src)
6160 .map(Self::List)
6161 .unwrap_or(Self::Unknown(node)),
6162 "map" => <Map as ::treesitter_types::FromNode>::from_node(node, src)
6163 .map(Self::Map)
6164 .unwrap_or(Self::Unknown(node)),
6165 "map_content" => <MapContent as ::treesitter_types::FromNode>::from_node(node, src)
6166 .map(Self::MapContent)
6167 .unwrap_or(Self::Unknown(node)),
6168 "nil" => <Nil as ::treesitter_types::FromNode>::from_node(node, src)
6169 .map(Self::Nil)
6170 .unwrap_or(Self::Unknown(node)),
6171 "operator_identifier" => {
6172 <OperatorIdentifier as ::treesitter_types::FromNode>::from_node(node, src)
6173 .map(Self::OperatorIdentifier)
6174 .unwrap_or(Self::Unknown(node))
6175 }
6176 "pair" => <Pair as ::treesitter_types::FromNode>::from_node(node, src)
6177 .map(Self::Pair)
6178 .unwrap_or(Self::Unknown(node)),
6179 "quoted_atom" => <QuotedAtom as ::treesitter_types::FromNode>::from_node(node, src)
6180 .map(Self::QuotedAtom)
6181 .unwrap_or(Self::Unknown(node)),
6182 "quoted_keyword" => {
6183 <QuotedKeyword as ::treesitter_types::FromNode>::from_node(node, src)
6184 .map(Self::QuotedKeyword)
6185 .unwrap_or(Self::Unknown(node))
6186 }
6187 "rescue_block" => <RescueBlock as ::treesitter_types::FromNode>::from_node(node, src)
6188 .map(Self::RescueBlock)
6189 .unwrap_or(Self::Unknown(node)),
6190 "sigil" => <Sigil as ::treesitter_types::FromNode>::from_node(node, src)
6191 .map(Self::Sigil)
6192 .unwrap_or(Self::Unknown(node)),
6193 "source" => <Source as ::treesitter_types::FromNode>::from_node(node, src)
6194 .map(Self::Source)
6195 .unwrap_or(Self::Unknown(node)),
6196 "stab_clause" => <StabClause as ::treesitter_types::FromNode>::from_node(node, src)
6197 .map(Self::StabClause)
6198 .unwrap_or(Self::Unknown(node)),
6199 "string" => <String as ::treesitter_types::FromNode>::from_node(node, src)
6200 .map(Self::String)
6201 .unwrap_or(Self::Unknown(node)),
6202 "struct" => <Struct as ::treesitter_types::FromNode>::from_node(node, src)
6203 .map(Self::Struct)
6204 .unwrap_or(Self::Unknown(node)),
6205 "tuple" => <Tuple as ::treesitter_types::FromNode>::from_node(node, src)
6206 .map(Self::Tuple)
6207 .unwrap_or(Self::Unknown(node)),
6208 "unary_operator" => {
6209 <UnaryOperator as ::treesitter_types::FromNode>::from_node(node, src)
6210 .map(Self::UnaryOperator)
6211 .unwrap_or(Self::Unknown(node))
6212 }
6213 "alias" => <Alias as ::treesitter_types::FromNode>::from_node(node, src)
6214 .map(Self::Alias)
6215 .unwrap_or(Self::Unknown(node)),
6216 "atom" => <Atom as ::treesitter_types::FromNode>::from_node(node, src)
6217 .map(Self::Atom)
6218 .unwrap_or(Self::Unknown(node)),
6219 "char" => <Char as ::treesitter_types::FromNode>::from_node(node, src)
6220 .map(Self::Char)
6221 .unwrap_or(Self::Unknown(node)),
6222 "comment" => <Comment as ::treesitter_types::FromNode>::from_node(node, src)
6223 .map(Self::Comment)
6224 .unwrap_or(Self::Unknown(node)),
6225 "escape_sequence" => {
6226 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
6227 .map(Self::EscapeSequence)
6228 .unwrap_or(Self::Unknown(node))
6229 }
6230 "float" => <Float as ::treesitter_types::FromNode>::from_node(node, src)
6231 .map(Self::Float)
6232 .unwrap_or(Self::Unknown(node)),
6233 "integer" => <Integer as ::treesitter_types::FromNode>::from_node(node, src)
6234 .map(Self::Integer)
6235 .unwrap_or(Self::Unknown(node)),
6236 "keyword" => <Keyword as ::treesitter_types::FromNode>::from_node(node, src)
6237 .map(Self::Keyword)
6238 .unwrap_or(Self::Unknown(node)),
6239 "quoted_content" => {
6240 <QuotedContent as ::treesitter_types::FromNode>::from_node(node, src)
6241 .map(Self::QuotedContent)
6242 .unwrap_or(Self::Unknown(node))
6243 }
6244 "sigil_modifiers" => {
6245 <SigilModifiers as ::treesitter_types::FromNode>::from_node(node, src)
6246 .map(Self::SigilModifiers)
6247 .unwrap_or(Self::Unknown(node))
6248 }
6249 "sigil_name" => <SigilName as ::treesitter_types::FromNode>::from_node(node, src)
6250 .map(Self::SigilName)
6251 .unwrap_or(Self::Unknown(node)),
6252 _ => Self::Unknown(node),
6253 }
6254 }
6255}
6256impl ::treesitter_types::Spanned for AnyNode<'_> {
6257 fn span(&self) -> ::treesitter_types::Span {
6258 match self {
6259 Self::AccessCall(inner) => inner.span(),
6260 Self::AfterBlock(inner) => inner.span(),
6261 Self::AnonymousFunction(inner) => inner.span(),
6262 Self::Arguments(inner) => inner.span(),
6263 Self::BinaryOperator(inner) => inner.span(),
6264 Self::Bitstring(inner) => inner.span(),
6265 Self::Block(inner) => inner.span(),
6266 Self::Body(inner) => inner.span(),
6267 Self::Boolean(inner) => inner.span(),
6268 Self::Call(inner) => inner.span(),
6269 Self::CatchBlock(inner) => inner.span(),
6270 Self::Charlist(inner) => inner.span(),
6271 Self::DoBlock(inner) => inner.span(),
6272 Self::Dot(inner) => inner.span(),
6273 Self::ElseBlock(inner) => inner.span(),
6274 Self::Identifier(inner) => inner.span(),
6275 Self::Interpolation(inner) => inner.span(),
6276 Self::Keywords(inner) => inner.span(),
6277 Self::List(inner) => inner.span(),
6278 Self::Map(inner) => inner.span(),
6279 Self::MapContent(inner) => inner.span(),
6280 Self::Nil(inner) => inner.span(),
6281 Self::OperatorIdentifier(inner) => inner.span(),
6282 Self::Pair(inner) => inner.span(),
6283 Self::QuotedAtom(inner) => inner.span(),
6284 Self::QuotedKeyword(inner) => inner.span(),
6285 Self::RescueBlock(inner) => inner.span(),
6286 Self::Sigil(inner) => inner.span(),
6287 Self::Source(inner) => inner.span(),
6288 Self::StabClause(inner) => inner.span(),
6289 Self::String(inner) => inner.span(),
6290 Self::Struct(inner) => inner.span(),
6291 Self::Tuple(inner) => inner.span(),
6292 Self::UnaryOperator(inner) => inner.span(),
6293 Self::Alias(inner) => inner.span(),
6294 Self::Atom(inner) => inner.span(),
6295 Self::Char(inner) => inner.span(),
6296 Self::Comment(inner) => inner.span(),
6297 Self::EscapeSequence(inner) => inner.span(),
6298 Self::Float(inner) => inner.span(),
6299 Self::Integer(inner) => inner.span(),
6300 Self::Keyword(inner) => inner.span(),
6301 Self::QuotedContent(inner) => inner.span(),
6302 Self::SigilModifiers(inner) => inner.span(),
6303 Self::SigilName(inner) => inner.span(),
6304 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
6305 }
6306 }
6307}