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