1#[derive(Debug, Clone, PartialEq, Eq)]
2pub struct Alias<'tree> {
3 pub span: ::treesitter_types::Span,
4 pub children: AliasName<'tree>,
5}
6impl<'tree> ::treesitter_types::FromNode<'tree> for Alias<'tree> {
7 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
8 fn from_node(
9 node: ::treesitter_types::tree_sitter::Node<'tree>,
10 src: &'tree [u8],
11 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
12 debug_assert_eq!(node.kind(), "alias");
13 Ok(Self {
14 span: ::treesitter_types::Span::from(node),
15 children: {
16 #[allow(clippy::suspicious_else_formatting)]
17 let non_field_children = {
18 let mut cursor = node.walk();
19 let mut result = ::std::vec::Vec::new();
20 if cursor.goto_first_child() {
21 loop {
22 if cursor.field_name().is_none()
23 && cursor.node().is_named()
24 && !cursor.node().is_extra()
25 {
26 result.push(cursor.node());
27 }
28 if !cursor.goto_next_sibling() {
29 break;
30 }
31 }
32 }
33 result
34 };
35 let child = if let Some(&c) = non_field_children.first() {
36 c
37 } else {
38 let mut fallback_cursor = node.walk();
39 let mut fallback_child = None;
40 if fallback_cursor.goto_first_child() {
41 loop {
42 if fallback_cursor.field_name().is_none()
43 && !fallback_cursor.node().is_extra()
44 {
45 let candidate = fallback_cursor.node();
46 #[allow(clippy::needless_question_mark)]
47 if (|| -> ::core::result::Result<
48 _,
49 ::treesitter_types::ParseError,
50 > {
51 let child = candidate;
52 Ok(
53 ::treesitter_types::runtime::maybe_grow_stack(|| <AliasName as ::treesitter_types::FromNode>::from_node(
54 child,
55 src,
56 ))?,
57 )
58 })()
59 .is_ok()
60 {
61 fallback_child = Some(candidate);
62 break;
63 }
64 }
65 if !fallback_cursor.goto_next_sibling() {
66 break;
67 }
68 }
69 }
70 if fallback_child.is_none() {
71 let mut cursor2 = node.walk();
72 if cursor2.goto_first_child() {
73 loop {
74 if cursor2.node().is_named() && !cursor2.node().is_extra() {
75 let candidate = cursor2.node();
76 #[allow(clippy::needless_question_mark)]
77 if (|| -> ::core::result::Result<
78 _,
79 ::treesitter_types::ParseError,
80 > {
81 let child = candidate;
82 Ok(
83 ::treesitter_types::runtime::maybe_grow_stack(|| <AliasName as ::treesitter_types::FromNode>::from_node(
84 child,
85 src,
86 ))?,
87 )
88 })()
89 .is_ok()
90 {
91 fallback_child = Some(candidate);
92 break;
93 }
94 }
95 if !cursor2.goto_next_sibling() {
96 break;
97 }
98 }
99 }
100 }
101 fallback_child.ok_or_else(|| {
102 ::treesitter_types::ParseError::missing_field("children", node)
103 })?
104 };
105 ::treesitter_types::runtime::maybe_grow_stack(|| {
106 <AliasName as ::treesitter_types::FromNode>::from_node(child, src)
107 })?
108 },
109 })
110 }
111}
112impl ::treesitter_types::Spanned for Alias<'_> {
113 fn span(&self) -> ::treesitter_types::Span {
114 self.span
115 }
116}
117#[derive(Debug, Clone, PartialEq, Eq)]
118pub struct Anchor<'tree> {
119 pub span: ::treesitter_types::Span,
120 pub children: AnchorName<'tree>,
121}
122impl<'tree> ::treesitter_types::FromNode<'tree> for Anchor<'tree> {
123 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
124 fn from_node(
125 node: ::treesitter_types::tree_sitter::Node<'tree>,
126 src: &'tree [u8],
127 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
128 debug_assert_eq!(node.kind(), "anchor");
129 Ok(Self {
130 span: ::treesitter_types::Span::from(node),
131 children: {
132 #[allow(clippy::suspicious_else_formatting)]
133 let non_field_children = {
134 let mut cursor = node.walk();
135 let mut result = ::std::vec::Vec::new();
136 if cursor.goto_first_child() {
137 loop {
138 if cursor.field_name().is_none()
139 && cursor.node().is_named()
140 && !cursor.node().is_extra()
141 {
142 result.push(cursor.node());
143 }
144 if !cursor.goto_next_sibling() {
145 break;
146 }
147 }
148 }
149 result
150 };
151 let child = if let Some(&c) = non_field_children.first() {
152 c
153 } else {
154 let mut fallback_cursor = node.walk();
155 let mut fallback_child = None;
156 if fallback_cursor.goto_first_child() {
157 loop {
158 if fallback_cursor.field_name().is_none()
159 && !fallback_cursor.node().is_extra()
160 {
161 let candidate = fallback_cursor.node();
162 #[allow(clippy::needless_question_mark)]
163 if (|| -> ::core::result::Result<
164 _,
165 ::treesitter_types::ParseError,
166 > {
167 let child = candidate;
168 Ok(
169 ::treesitter_types::runtime::maybe_grow_stack(|| <AnchorName as ::treesitter_types::FromNode>::from_node(
170 child,
171 src,
172 ))?,
173 )
174 })()
175 .is_ok()
176 {
177 fallback_child = Some(candidate);
178 break;
179 }
180 }
181 if !fallback_cursor.goto_next_sibling() {
182 break;
183 }
184 }
185 }
186 if fallback_child.is_none() {
187 let mut cursor2 = node.walk();
188 if cursor2.goto_first_child() {
189 loop {
190 if cursor2.node().is_named() && !cursor2.node().is_extra() {
191 let candidate = cursor2.node();
192 #[allow(clippy::needless_question_mark)]
193 if (|| -> ::core::result::Result<
194 _,
195 ::treesitter_types::ParseError,
196 > {
197 let child = candidate;
198 Ok(
199 ::treesitter_types::runtime::maybe_grow_stack(|| <AnchorName as ::treesitter_types::FromNode>::from_node(
200 child,
201 src,
202 ))?,
203 )
204 })()
205 .is_ok()
206 {
207 fallback_child = Some(candidate);
208 break;
209 }
210 }
211 if !cursor2.goto_next_sibling() {
212 break;
213 }
214 }
215 }
216 }
217 fallback_child.ok_or_else(|| {
218 ::treesitter_types::ParseError::missing_field("children", node)
219 })?
220 };
221 ::treesitter_types::runtime::maybe_grow_stack(|| {
222 <AnchorName as ::treesitter_types::FromNode>::from_node(child, src)
223 })?
224 },
225 })
226 }
227}
228impl ::treesitter_types::Spanned for Anchor<'_> {
229 fn span(&self) -> ::treesitter_types::Span {
230 self.span
231 }
232}
233#[derive(Debug, Clone, PartialEq, Eq)]
234pub struct BlockMapping<'tree> {
235 pub span: ::treesitter_types::Span,
236 pub children: ::std::vec::Vec<BlockMappingPair<'tree>>,
237}
238impl<'tree> ::treesitter_types::FromNode<'tree> for BlockMapping<'tree> {
239 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
240 fn from_node(
241 node: ::treesitter_types::tree_sitter::Node<'tree>,
242 src: &'tree [u8],
243 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
244 debug_assert_eq!(node.kind(), "block_mapping");
245 Ok(Self {
246 span: ::treesitter_types::Span::from(node),
247 children: {
248 #[allow(clippy::suspicious_else_formatting)]
249 let non_field_children = {
250 let mut cursor = node.walk();
251 let mut result = ::std::vec::Vec::new();
252 if cursor.goto_first_child() {
253 loop {
254 if cursor.field_name().is_none()
255 && cursor.node().is_named()
256 && !cursor.node().is_extra()
257 {
258 result.push(cursor.node());
259 }
260 if !cursor.goto_next_sibling() {
261 break;
262 }
263 }
264 }
265 result
266 };
267 let mut items = ::std::vec::Vec::new();
268 for child in non_field_children {
269 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
270 <BlockMappingPair as ::treesitter_types::FromNode>::from_node(child, src)
271 })?);
272 }
273 items
274 },
275 })
276 }
277}
278impl ::treesitter_types::Spanned for BlockMapping<'_> {
279 fn span(&self) -> ::treesitter_types::Span {
280 self.span
281 }
282}
283#[derive(Debug, Clone, PartialEq, Eq)]
284pub struct BlockMappingPair<'tree> {
285 pub span: ::treesitter_types::Span,
286 pub key: ::core::option::Option<BlockMappingPairKey<'tree>>,
287 pub value: ::core::option::Option<BlockMappingPairValue<'tree>>,
288}
289impl<'tree> ::treesitter_types::FromNode<'tree> for BlockMappingPair<'tree> {
290 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
291 fn from_node(
292 node: ::treesitter_types::tree_sitter::Node<'tree>,
293 src: &'tree [u8],
294 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
295 debug_assert_eq!(node.kind(), "block_mapping_pair");
296 Ok(Self {
297 span: ::treesitter_types::Span::from(node),
298 key: match node.child_by_field_name("key") {
299 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
300 <BlockMappingPairKey as ::treesitter_types::FromNode>::from_node(child, src)
301 })?),
302 None => None,
303 },
304 value: match node.child_by_field_name("value") {
305 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
306 <BlockMappingPairValue as ::treesitter_types::FromNode>::from_node(child, src)
307 })?),
308 None => None,
309 },
310 })
311 }
312}
313impl ::treesitter_types::Spanned for BlockMappingPair<'_> {
314 fn span(&self) -> ::treesitter_types::Span {
315 self.span
316 }
317}
318#[derive(Debug, Clone, PartialEq, Eq)]
319pub struct BlockNode<'tree> {
320 pub span: ::treesitter_types::Span,
321 pub children: ::std::vec::Vec<BlockNodeChildren<'tree>>,
322}
323impl<'tree> ::treesitter_types::FromNode<'tree> for BlockNode<'tree> {
324 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
325 fn from_node(
326 node: ::treesitter_types::tree_sitter::Node<'tree>,
327 src: &'tree [u8],
328 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
329 debug_assert_eq!(node.kind(), "block_node");
330 Ok(Self {
331 span: ::treesitter_types::Span::from(node),
332 children: {
333 #[allow(clippy::suspicious_else_formatting)]
334 let non_field_children = {
335 let mut cursor = node.walk();
336 let mut result = ::std::vec::Vec::new();
337 if cursor.goto_first_child() {
338 loop {
339 if cursor.field_name().is_none()
340 && cursor.node().is_named()
341 && !cursor.node().is_extra()
342 {
343 result.push(cursor.node());
344 }
345 if !cursor.goto_next_sibling() {
346 break;
347 }
348 }
349 }
350 result
351 };
352 let mut items = ::std::vec::Vec::new();
353 for child in non_field_children {
354 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
355 <BlockNodeChildren as ::treesitter_types::FromNode>::from_node(child, src)
356 })?);
357 }
358 items
359 },
360 })
361 }
362}
363impl ::treesitter_types::Spanned for BlockNode<'_> {
364 fn span(&self) -> ::treesitter_types::Span {
365 self.span
366 }
367}
368#[derive(Debug, Clone, PartialEq, Eq)]
369pub struct BlockScalar<'tree> {
370 pub span: ::treesitter_types::Span,
371 text: &'tree str,
372}
373impl<'tree> ::treesitter_types::FromNode<'tree> for BlockScalar<'tree> {
374 fn from_node(
375 node: ::treesitter_types::tree_sitter::Node<'tree>,
376 src: &'tree [u8],
377 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
378 debug_assert_eq!(node.kind(), "block_scalar");
379 Ok(Self {
380 span: ::treesitter_types::Span::from(node),
381 text: node.utf8_text(src)?,
382 })
383 }
384}
385impl<'tree> ::treesitter_types::LeafNode<'tree> for BlockScalar<'tree> {
386 fn text(&self) -> &'tree str {
387 self.text
388 }
389}
390impl ::treesitter_types::Spanned for BlockScalar<'_> {
391 fn span(&self) -> ::treesitter_types::Span {
392 self.span
393 }
394}
395#[derive(Debug, Clone, PartialEq, Eq)]
396pub struct BlockSequence<'tree> {
397 pub span: ::treesitter_types::Span,
398 pub children: ::std::vec::Vec<BlockSequenceItem<'tree>>,
399}
400impl<'tree> ::treesitter_types::FromNode<'tree> for BlockSequence<'tree> {
401 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
402 fn from_node(
403 node: ::treesitter_types::tree_sitter::Node<'tree>,
404 src: &'tree [u8],
405 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
406 debug_assert_eq!(node.kind(), "block_sequence");
407 Ok(Self {
408 span: ::treesitter_types::Span::from(node),
409 children: {
410 #[allow(clippy::suspicious_else_formatting)]
411 let non_field_children = {
412 let mut cursor = node.walk();
413 let mut result = ::std::vec::Vec::new();
414 if cursor.goto_first_child() {
415 loop {
416 if cursor.field_name().is_none()
417 && cursor.node().is_named()
418 && !cursor.node().is_extra()
419 {
420 result.push(cursor.node());
421 }
422 if !cursor.goto_next_sibling() {
423 break;
424 }
425 }
426 }
427 result
428 };
429 let mut items = ::std::vec::Vec::new();
430 for child in non_field_children {
431 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
432 <BlockSequenceItem as ::treesitter_types::FromNode>::from_node(child, src)
433 })?);
434 }
435 items
436 },
437 })
438 }
439}
440impl ::treesitter_types::Spanned for BlockSequence<'_> {
441 fn span(&self) -> ::treesitter_types::Span {
442 self.span
443 }
444}
445#[derive(Debug, Clone, PartialEq, Eq)]
446pub struct BlockSequenceItem<'tree> {
447 pub span: ::treesitter_types::Span,
448 pub children: ::core::option::Option<BlockSequenceItemChildren<'tree>>,
449}
450impl<'tree> ::treesitter_types::FromNode<'tree> for BlockSequenceItem<'tree> {
451 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
452 fn from_node(
453 node: ::treesitter_types::tree_sitter::Node<'tree>,
454 src: &'tree [u8],
455 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
456 debug_assert_eq!(node.kind(), "block_sequence_item");
457 Ok(Self {
458 span: ::treesitter_types::Span::from(node),
459 children: {
460 #[allow(clippy::suspicious_else_formatting)]
461 let non_field_children = {
462 let mut cursor = node.walk();
463 let mut result = ::std::vec::Vec::new();
464 if cursor.goto_first_child() {
465 loop {
466 if cursor.field_name().is_none()
467 && cursor.node().is_named()
468 && !cursor.node().is_extra()
469 {
470 result.push(cursor.node());
471 }
472 if !cursor.goto_next_sibling() {
473 break;
474 }
475 }
476 }
477 result
478 };
479 match non_field_children.first() {
480 Some(&child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
481 <BlockSequenceItemChildren as ::treesitter_types::FromNode>::from_node(
482 child, src,
483 )
484 })?),
485 None => None,
486 }
487 },
488 })
489 }
490}
491impl ::treesitter_types::Spanned for BlockSequenceItem<'_> {
492 fn span(&self) -> ::treesitter_types::Span {
493 self.span
494 }
495}
496#[derive(Debug, Clone, PartialEq, Eq)]
497pub struct Document<'tree> {
498 pub span: ::treesitter_types::Span,
499 pub children: ::std::vec::Vec<DocumentChildren<'tree>>,
500}
501impl<'tree> ::treesitter_types::FromNode<'tree> for Document<'tree> {
502 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
503 fn from_node(
504 node: ::treesitter_types::tree_sitter::Node<'tree>,
505 src: &'tree [u8],
506 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
507 debug_assert_eq!(node.kind(), "document");
508 Ok(Self {
509 span: ::treesitter_types::Span::from(node),
510 children: {
511 #[allow(clippy::suspicious_else_formatting)]
512 let non_field_children = {
513 let mut cursor = node.walk();
514 let mut result = ::std::vec::Vec::new();
515 if cursor.goto_first_child() {
516 loop {
517 if cursor.field_name().is_none()
518 && cursor.node().is_named()
519 && !cursor.node().is_extra()
520 {
521 result.push(cursor.node());
522 }
523 if !cursor.goto_next_sibling() {
524 break;
525 }
526 }
527 }
528 result
529 };
530 let mut items = ::std::vec::Vec::new();
531 for child in non_field_children {
532 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
533 <DocumentChildren as ::treesitter_types::FromNode>::from_node(child, src)
534 })?);
535 }
536 items
537 },
538 })
539 }
540}
541impl ::treesitter_types::Spanned for Document<'_> {
542 fn span(&self) -> ::treesitter_types::Span {
543 self.span
544 }
545}
546#[derive(Debug, Clone, PartialEq, Eq)]
547pub struct DoubleQuoteScalar<'tree> {
548 pub span: ::treesitter_types::Span,
549 pub children: ::std::vec::Vec<EscapeSequence<'tree>>,
550}
551impl<'tree> ::treesitter_types::FromNode<'tree> for DoubleQuoteScalar<'tree> {
552 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
553 fn from_node(
554 node: ::treesitter_types::tree_sitter::Node<'tree>,
555 src: &'tree [u8],
556 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
557 debug_assert_eq!(node.kind(), "double_quote_scalar");
558 Ok(Self {
559 span: ::treesitter_types::Span::from(node),
560 children: {
561 #[allow(clippy::suspicious_else_formatting)]
562 let non_field_children = {
563 let mut cursor = node.walk();
564 let mut result = ::std::vec::Vec::new();
565 if cursor.goto_first_child() {
566 loop {
567 if cursor.field_name().is_none()
568 && cursor.node().is_named()
569 && !cursor.node().is_extra()
570 {
571 result.push(cursor.node());
572 }
573 if !cursor.goto_next_sibling() {
574 break;
575 }
576 }
577 }
578 result
579 };
580 let mut items = ::std::vec::Vec::new();
581 for child in non_field_children {
582 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
583 <EscapeSequence as ::treesitter_types::FromNode>::from_node(child, src)
584 })?);
585 }
586 items
587 },
588 })
589 }
590}
591impl ::treesitter_types::Spanned for DoubleQuoteScalar<'_> {
592 fn span(&self) -> ::treesitter_types::Span {
593 self.span
594 }
595}
596#[derive(Debug, Clone, PartialEq, Eq)]
597pub struct FlowMapping<'tree> {
598 pub span: ::treesitter_types::Span,
599 pub children: ::std::vec::Vec<FlowMappingChildren<'tree>>,
600}
601impl<'tree> ::treesitter_types::FromNode<'tree> for FlowMapping<'tree> {
602 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
603 fn from_node(
604 node: ::treesitter_types::tree_sitter::Node<'tree>,
605 src: &'tree [u8],
606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
607 debug_assert_eq!(node.kind(), "flow_mapping");
608 Ok(Self {
609 span: ::treesitter_types::Span::from(node),
610 children: {
611 #[allow(clippy::suspicious_else_formatting)]
612 let non_field_children = {
613 let mut cursor = node.walk();
614 let mut result = ::std::vec::Vec::new();
615 if cursor.goto_first_child() {
616 loop {
617 if cursor.field_name().is_none()
618 && cursor.node().is_named()
619 && !cursor.node().is_extra()
620 {
621 result.push(cursor.node());
622 }
623 if !cursor.goto_next_sibling() {
624 break;
625 }
626 }
627 }
628 result
629 };
630 let mut items = ::std::vec::Vec::new();
631 for child in non_field_children {
632 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
633 <FlowMappingChildren as ::treesitter_types::FromNode>::from_node(child, src)
634 })?);
635 }
636 items
637 },
638 })
639 }
640}
641impl ::treesitter_types::Spanned for FlowMapping<'_> {
642 fn span(&self) -> ::treesitter_types::Span {
643 self.span
644 }
645}
646#[derive(Debug, Clone, PartialEq, Eq)]
647pub struct FlowNode<'tree> {
648 pub span: ::treesitter_types::Span,
649 pub children: ::std::vec::Vec<FlowNodeChildren<'tree>>,
650}
651impl<'tree> ::treesitter_types::FromNode<'tree> for FlowNode<'tree> {
652 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
653 fn from_node(
654 node: ::treesitter_types::tree_sitter::Node<'tree>,
655 src: &'tree [u8],
656 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
657 debug_assert_eq!(node.kind(), "flow_node");
658 Ok(Self {
659 span: ::treesitter_types::Span::from(node),
660 children: {
661 #[allow(clippy::suspicious_else_formatting)]
662 let non_field_children = {
663 let mut cursor = node.walk();
664 let mut result = ::std::vec::Vec::new();
665 if cursor.goto_first_child() {
666 loop {
667 if cursor.field_name().is_none()
668 && cursor.node().is_named()
669 && !cursor.node().is_extra()
670 {
671 result.push(cursor.node());
672 }
673 if !cursor.goto_next_sibling() {
674 break;
675 }
676 }
677 }
678 result
679 };
680 let mut items = ::std::vec::Vec::new();
681 for child in non_field_children {
682 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
683 <FlowNodeChildren as ::treesitter_types::FromNode>::from_node(child, src)
684 })?);
685 }
686 items
687 },
688 })
689 }
690}
691impl ::treesitter_types::Spanned for FlowNode<'_> {
692 fn span(&self) -> ::treesitter_types::Span {
693 self.span
694 }
695}
696#[derive(Debug, Clone, PartialEq, Eq)]
697pub struct FlowPair<'tree> {
698 pub span: ::treesitter_types::Span,
699 pub key: ::core::option::Option<FlowNode<'tree>>,
700 pub value: ::core::option::Option<FlowNode<'tree>>,
701}
702impl<'tree> ::treesitter_types::FromNode<'tree> for FlowPair<'tree> {
703 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
704 fn from_node(
705 node: ::treesitter_types::tree_sitter::Node<'tree>,
706 src: &'tree [u8],
707 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
708 debug_assert_eq!(node.kind(), "flow_pair");
709 Ok(Self {
710 span: ::treesitter_types::Span::from(node),
711 key: match node.child_by_field_name("key") {
712 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
713 <FlowNode as ::treesitter_types::FromNode>::from_node(child, src)
714 })?),
715 None => None,
716 },
717 value: match node.child_by_field_name("value") {
718 Some(child) => Some(::treesitter_types::runtime::maybe_grow_stack(|| {
719 <FlowNode as ::treesitter_types::FromNode>::from_node(child, src)
720 })?),
721 None => None,
722 },
723 })
724 }
725}
726impl ::treesitter_types::Spanned for FlowPair<'_> {
727 fn span(&self) -> ::treesitter_types::Span {
728 self.span
729 }
730}
731#[derive(Debug, Clone, PartialEq, Eq)]
732pub struct FlowSequence<'tree> {
733 pub span: ::treesitter_types::Span,
734 pub children: ::std::vec::Vec<FlowSequenceChildren<'tree>>,
735}
736impl<'tree> ::treesitter_types::FromNode<'tree> for FlowSequence<'tree> {
737 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
738 fn from_node(
739 node: ::treesitter_types::tree_sitter::Node<'tree>,
740 src: &'tree [u8],
741 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
742 debug_assert_eq!(node.kind(), "flow_sequence");
743 Ok(Self {
744 span: ::treesitter_types::Span::from(node),
745 children: {
746 #[allow(clippy::suspicious_else_formatting)]
747 let non_field_children = {
748 let mut cursor = node.walk();
749 let mut result = ::std::vec::Vec::new();
750 if cursor.goto_first_child() {
751 loop {
752 if cursor.field_name().is_none()
753 && cursor.node().is_named()
754 && !cursor.node().is_extra()
755 {
756 result.push(cursor.node());
757 }
758 if !cursor.goto_next_sibling() {
759 break;
760 }
761 }
762 }
763 result
764 };
765 let mut items = ::std::vec::Vec::new();
766 for child in non_field_children {
767 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
768 <FlowSequenceChildren as ::treesitter_types::FromNode>::from_node(
769 child, src,
770 )
771 })?);
772 }
773 items
774 },
775 })
776 }
777}
778impl ::treesitter_types::Spanned for FlowSequence<'_> {
779 fn span(&self) -> ::treesitter_types::Span {
780 self.span
781 }
782}
783#[derive(Debug, Clone, PartialEq, Eq)]
784pub struct PlainScalar<'tree> {
785 pub span: ::treesitter_types::Span,
786 pub children: PlainScalarChildren<'tree>,
787}
788impl<'tree> ::treesitter_types::FromNode<'tree> for PlainScalar<'tree> {
789 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
790 fn from_node(
791 node: ::treesitter_types::tree_sitter::Node<'tree>,
792 src: &'tree [u8],
793 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
794 debug_assert_eq!(node.kind(), "plain_scalar");
795 Ok(Self {
796 span: ::treesitter_types::Span::from(node),
797 children: {
798 #[allow(clippy::suspicious_else_formatting)]
799 let non_field_children = {
800 let mut cursor = node.walk();
801 let mut result = ::std::vec::Vec::new();
802 if cursor.goto_first_child() {
803 loop {
804 if cursor.field_name().is_none()
805 && cursor.node().is_named()
806 && !cursor.node().is_extra()
807 {
808 result.push(cursor.node());
809 }
810 if !cursor.goto_next_sibling() {
811 break;
812 }
813 }
814 }
815 result
816 };
817 let child = if let Some(&c) = non_field_children.first() {
818 c
819 } else {
820 let mut fallback_cursor = node.walk();
821 let mut fallback_child = None;
822 if fallback_cursor.goto_first_child() {
823 loop {
824 if fallback_cursor.field_name().is_none()
825 && !fallback_cursor.node().is_extra()
826 {
827 let candidate = fallback_cursor.node();
828 #[allow(clippy::needless_question_mark)]
829 if (|| -> ::core::result::Result<
830 _,
831 ::treesitter_types::ParseError,
832 > {
833 let child = candidate;
834 Ok(
835 ::treesitter_types::runtime::maybe_grow_stack(|| <PlainScalarChildren as ::treesitter_types::FromNode>::from_node(
836 child,
837 src,
838 ))?,
839 )
840 })()
841 .is_ok()
842 {
843 fallback_child = Some(candidate);
844 break;
845 }
846 }
847 if !fallback_cursor.goto_next_sibling() {
848 break;
849 }
850 }
851 }
852 if fallback_child.is_none() {
853 let mut cursor2 = node.walk();
854 if cursor2.goto_first_child() {
855 loop {
856 if cursor2.node().is_named() && !cursor2.node().is_extra() {
857 let candidate = cursor2.node();
858 #[allow(clippy::needless_question_mark)]
859 if (|| -> ::core::result::Result<
860 _,
861 ::treesitter_types::ParseError,
862 > {
863 let child = candidate;
864 Ok(
865 ::treesitter_types::runtime::maybe_grow_stack(|| <PlainScalarChildren as ::treesitter_types::FromNode>::from_node(
866 child,
867 src,
868 ))?,
869 )
870 })()
871 .is_ok()
872 {
873 fallback_child = Some(candidate);
874 break;
875 }
876 }
877 if !cursor2.goto_next_sibling() {
878 break;
879 }
880 }
881 }
882 }
883 fallback_child.ok_or_else(|| {
884 ::treesitter_types::ParseError::missing_field("children", node)
885 })?
886 };
887 ::treesitter_types::runtime::maybe_grow_stack(|| {
888 <PlainScalarChildren as ::treesitter_types::FromNode>::from_node(child, src)
889 })?
890 },
891 })
892 }
893}
894impl ::treesitter_types::Spanned for PlainScalar<'_> {
895 fn span(&self) -> ::treesitter_types::Span {
896 self.span
897 }
898}
899#[derive(Debug, Clone, PartialEq, Eq)]
900pub struct ReservedDirective<'tree> {
901 pub span: ::treesitter_types::Span,
902 pub children: ::std::vec::Vec<ReservedDirectiveChildren<'tree>>,
903}
904impl<'tree> ::treesitter_types::FromNode<'tree> for ReservedDirective<'tree> {
905 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
906 fn from_node(
907 node: ::treesitter_types::tree_sitter::Node<'tree>,
908 src: &'tree [u8],
909 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
910 debug_assert_eq!(node.kind(), "reserved_directive");
911 Ok(Self {
912 span: ::treesitter_types::Span::from(node),
913 children: {
914 #[allow(clippy::suspicious_else_formatting)]
915 let non_field_children = {
916 let mut cursor = node.walk();
917 let mut result = ::std::vec::Vec::new();
918 if cursor.goto_first_child() {
919 loop {
920 if cursor.field_name().is_none()
921 && cursor.node().is_named()
922 && !cursor.node().is_extra()
923 {
924 result.push(cursor.node());
925 }
926 if !cursor.goto_next_sibling() {
927 break;
928 }
929 }
930 }
931 result
932 };
933 let mut items = ::std::vec::Vec::new();
934 for child in non_field_children {
935 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
936 <ReservedDirectiveChildren as ::treesitter_types::FromNode>::from_node(
937 child, src,
938 )
939 })?);
940 }
941 items
942 },
943 })
944 }
945}
946impl ::treesitter_types::Spanned for ReservedDirective<'_> {
947 fn span(&self) -> ::treesitter_types::Span {
948 self.span
949 }
950}
951#[derive(Debug, Clone, PartialEq, Eq)]
952pub struct SingleQuoteScalar<'tree> {
953 pub span: ::treesitter_types::Span,
954 pub children: ::std::vec::Vec<EscapeSequence<'tree>>,
955}
956impl<'tree> ::treesitter_types::FromNode<'tree> for SingleQuoteScalar<'tree> {
957 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
958 fn from_node(
959 node: ::treesitter_types::tree_sitter::Node<'tree>,
960 src: &'tree [u8],
961 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
962 debug_assert_eq!(node.kind(), "single_quote_scalar");
963 Ok(Self {
964 span: ::treesitter_types::Span::from(node),
965 children: {
966 #[allow(clippy::suspicious_else_formatting)]
967 let non_field_children = {
968 let mut cursor = node.walk();
969 let mut result = ::std::vec::Vec::new();
970 if cursor.goto_first_child() {
971 loop {
972 if cursor.field_name().is_none()
973 && cursor.node().is_named()
974 && !cursor.node().is_extra()
975 {
976 result.push(cursor.node());
977 }
978 if !cursor.goto_next_sibling() {
979 break;
980 }
981 }
982 }
983 result
984 };
985 let mut items = ::std::vec::Vec::new();
986 for child in non_field_children {
987 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
988 <EscapeSequence as ::treesitter_types::FromNode>::from_node(child, src)
989 })?);
990 }
991 items
992 },
993 })
994 }
995}
996impl ::treesitter_types::Spanned for SingleQuoteScalar<'_> {
997 fn span(&self) -> ::treesitter_types::Span {
998 self.span
999 }
1000}
1001#[derive(Debug, Clone, PartialEq, Eq)]
1002pub struct Stream<'tree> {
1003 pub span: ::treesitter_types::Span,
1004 pub children: ::std::vec::Vec<Document<'tree>>,
1005}
1006impl<'tree> ::treesitter_types::FromNode<'tree> for Stream<'tree> {
1007 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1008 fn from_node(
1009 node: ::treesitter_types::tree_sitter::Node<'tree>,
1010 src: &'tree [u8],
1011 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1012 debug_assert_eq!(node.kind(), "stream");
1013 Ok(Self {
1014 span: ::treesitter_types::Span::from(node),
1015 children: {
1016 #[allow(clippy::suspicious_else_formatting)]
1017 let non_field_children = {
1018 let mut cursor = node.walk();
1019 let mut result = ::std::vec::Vec::new();
1020 if cursor.goto_first_child() {
1021 loop {
1022 if cursor.field_name().is_none()
1023 && cursor.node().is_named()
1024 && !cursor.node().is_extra()
1025 {
1026 result.push(cursor.node());
1027 }
1028 if !cursor.goto_next_sibling() {
1029 break;
1030 }
1031 }
1032 }
1033 result
1034 };
1035 let mut items = ::std::vec::Vec::new();
1036 for child in non_field_children {
1037 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1038 <Document as ::treesitter_types::FromNode>::from_node(child, src)
1039 })?);
1040 }
1041 items
1042 },
1043 })
1044 }
1045}
1046impl ::treesitter_types::Spanned for Stream<'_> {
1047 fn span(&self) -> ::treesitter_types::Span {
1048 self.span
1049 }
1050}
1051#[derive(Debug, Clone, PartialEq, Eq)]
1052pub struct TagDirective<'tree> {
1053 pub span: ::treesitter_types::Span,
1054 pub children: ::std::vec::Vec<TagDirectiveChildren<'tree>>,
1055}
1056impl<'tree> ::treesitter_types::FromNode<'tree> for TagDirective<'tree> {
1057 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1058 fn from_node(
1059 node: ::treesitter_types::tree_sitter::Node<'tree>,
1060 src: &'tree [u8],
1061 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1062 debug_assert_eq!(node.kind(), "tag_directive");
1063 Ok(Self {
1064 span: ::treesitter_types::Span::from(node),
1065 children: {
1066 #[allow(clippy::suspicious_else_formatting)]
1067 let non_field_children = {
1068 let mut cursor = node.walk();
1069 let mut result = ::std::vec::Vec::new();
1070 if cursor.goto_first_child() {
1071 loop {
1072 if cursor.field_name().is_none()
1073 && cursor.node().is_named()
1074 && !cursor.node().is_extra()
1075 {
1076 result.push(cursor.node());
1077 }
1078 if !cursor.goto_next_sibling() {
1079 break;
1080 }
1081 }
1082 }
1083 result
1084 };
1085 let mut items = ::std::vec::Vec::new();
1086 for child in non_field_children {
1087 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
1088 <TagDirectiveChildren as ::treesitter_types::FromNode>::from_node(
1089 child, src,
1090 )
1091 })?);
1092 }
1093 items
1094 },
1095 })
1096 }
1097}
1098impl ::treesitter_types::Spanned for TagDirective<'_> {
1099 fn span(&self) -> ::treesitter_types::Span {
1100 self.span
1101 }
1102}
1103#[derive(Debug, Clone, PartialEq, Eq)]
1104pub struct YamlDirective<'tree> {
1105 pub span: ::treesitter_types::Span,
1106 pub children: YamlVersion<'tree>,
1107}
1108impl<'tree> ::treesitter_types::FromNode<'tree> for YamlDirective<'tree> {
1109 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
1110 fn from_node(
1111 node: ::treesitter_types::tree_sitter::Node<'tree>,
1112 src: &'tree [u8],
1113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1114 debug_assert_eq!(node.kind(), "yaml_directive");
1115 Ok(Self {
1116 span: ::treesitter_types::Span::from(node),
1117 children: {
1118 #[allow(clippy::suspicious_else_formatting)]
1119 let non_field_children = {
1120 let mut cursor = node.walk();
1121 let mut result = ::std::vec::Vec::new();
1122 if cursor.goto_first_child() {
1123 loop {
1124 if cursor.field_name().is_none()
1125 && cursor.node().is_named()
1126 && !cursor.node().is_extra()
1127 {
1128 result.push(cursor.node());
1129 }
1130 if !cursor.goto_next_sibling() {
1131 break;
1132 }
1133 }
1134 }
1135 result
1136 };
1137 let child = if let Some(&c) = non_field_children.first() {
1138 c
1139 } else {
1140 let mut fallback_cursor = node.walk();
1141 let mut fallback_child = None;
1142 if fallback_cursor.goto_first_child() {
1143 loop {
1144 if fallback_cursor.field_name().is_none()
1145 && !fallback_cursor.node().is_extra()
1146 {
1147 let candidate = fallback_cursor.node();
1148 #[allow(clippy::needless_question_mark)]
1149 if (|| -> ::core::result::Result<
1150 _,
1151 ::treesitter_types::ParseError,
1152 > {
1153 let child = candidate;
1154 Ok(
1155 ::treesitter_types::runtime::maybe_grow_stack(|| <YamlVersion as ::treesitter_types::FromNode>::from_node(
1156 child,
1157 src,
1158 ))?,
1159 )
1160 })()
1161 .is_ok()
1162 {
1163 fallback_child = Some(candidate);
1164 break;
1165 }
1166 }
1167 if !fallback_cursor.goto_next_sibling() {
1168 break;
1169 }
1170 }
1171 }
1172 if fallback_child.is_none() {
1173 let mut cursor2 = node.walk();
1174 if cursor2.goto_first_child() {
1175 loop {
1176 if cursor2.node().is_named() && !cursor2.node().is_extra() {
1177 let candidate = cursor2.node();
1178 #[allow(clippy::needless_question_mark)]
1179 if (|| -> ::core::result::Result<
1180 _,
1181 ::treesitter_types::ParseError,
1182 > {
1183 let child = candidate;
1184 Ok(
1185 ::treesitter_types::runtime::maybe_grow_stack(|| <YamlVersion as ::treesitter_types::FromNode>::from_node(
1186 child,
1187 src,
1188 ))?,
1189 )
1190 })()
1191 .is_ok()
1192 {
1193 fallback_child = Some(candidate);
1194 break;
1195 }
1196 }
1197 if !cursor2.goto_next_sibling() {
1198 break;
1199 }
1200 }
1201 }
1202 }
1203 fallback_child.ok_or_else(|| {
1204 ::treesitter_types::ParseError::missing_field("children", node)
1205 })?
1206 };
1207 ::treesitter_types::runtime::maybe_grow_stack(|| {
1208 <YamlVersion as ::treesitter_types::FromNode>::from_node(child, src)
1209 })?
1210 },
1211 })
1212 }
1213}
1214impl ::treesitter_types::Spanned for YamlDirective<'_> {
1215 fn span(&self) -> ::treesitter_types::Span {
1216 self.span
1217 }
1218}
1219#[derive(Debug, Clone, PartialEq, Eq)]
1220pub struct AliasName<'tree> {
1221 pub span: ::treesitter_types::Span,
1222 text: &'tree str,
1223}
1224impl<'tree> ::treesitter_types::FromNode<'tree> for AliasName<'tree> {
1225 fn from_node(
1226 node: ::treesitter_types::tree_sitter::Node<'tree>,
1227 src: &'tree [u8],
1228 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1229 debug_assert_eq!(node.kind(), "alias_name");
1230 Ok(Self {
1231 span: ::treesitter_types::Span::from(node),
1232 text: node.utf8_text(src)?,
1233 })
1234 }
1235}
1236impl<'tree> ::treesitter_types::LeafNode<'tree> for AliasName<'tree> {
1237 fn text(&self) -> &'tree str {
1238 self.text
1239 }
1240}
1241impl ::treesitter_types::Spanned for AliasName<'_> {
1242 fn span(&self) -> ::treesitter_types::Span {
1243 self.span
1244 }
1245}
1246#[derive(Debug, Clone, PartialEq, Eq)]
1247pub struct AnchorName<'tree> {
1248 pub span: ::treesitter_types::Span,
1249 text: &'tree str,
1250}
1251impl<'tree> ::treesitter_types::FromNode<'tree> for AnchorName<'tree> {
1252 fn from_node(
1253 node: ::treesitter_types::tree_sitter::Node<'tree>,
1254 src: &'tree [u8],
1255 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1256 debug_assert_eq!(node.kind(), "anchor_name");
1257 Ok(Self {
1258 span: ::treesitter_types::Span::from(node),
1259 text: node.utf8_text(src)?,
1260 })
1261 }
1262}
1263impl<'tree> ::treesitter_types::LeafNode<'tree> for AnchorName<'tree> {
1264 fn text(&self) -> &'tree str {
1265 self.text
1266 }
1267}
1268impl ::treesitter_types::Spanned for AnchorName<'_> {
1269 fn span(&self) -> ::treesitter_types::Span {
1270 self.span
1271 }
1272}
1273#[derive(Debug, Clone, PartialEq, Eq)]
1274pub struct BooleanScalar<'tree> {
1275 pub span: ::treesitter_types::Span,
1276 text: &'tree str,
1277}
1278impl<'tree> ::treesitter_types::FromNode<'tree> for BooleanScalar<'tree> {
1279 fn from_node(
1280 node: ::treesitter_types::tree_sitter::Node<'tree>,
1281 src: &'tree [u8],
1282 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1283 debug_assert_eq!(node.kind(), "boolean_scalar");
1284 Ok(Self {
1285 span: ::treesitter_types::Span::from(node),
1286 text: node.utf8_text(src)?,
1287 })
1288 }
1289}
1290impl<'tree> ::treesitter_types::LeafNode<'tree> for BooleanScalar<'tree> {
1291 fn text(&self) -> &'tree str {
1292 self.text
1293 }
1294}
1295impl ::treesitter_types::Spanned for BooleanScalar<'_> {
1296 fn span(&self) -> ::treesitter_types::Span {
1297 self.span
1298 }
1299}
1300#[derive(Debug, Clone, PartialEq, Eq)]
1301pub struct Comment<'tree> {
1302 pub span: ::treesitter_types::Span,
1303 text: &'tree str,
1304}
1305impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
1306 fn from_node(
1307 node: ::treesitter_types::tree_sitter::Node<'tree>,
1308 src: &'tree [u8],
1309 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1310 debug_assert_eq!(node.kind(), "comment");
1311 Ok(Self {
1312 span: ::treesitter_types::Span::from(node),
1313 text: node.utf8_text(src)?,
1314 })
1315 }
1316}
1317impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
1318 fn text(&self) -> &'tree str {
1319 self.text
1320 }
1321}
1322impl ::treesitter_types::Spanned for Comment<'_> {
1323 fn span(&self) -> ::treesitter_types::Span {
1324 self.span
1325 }
1326}
1327#[derive(Debug, Clone, PartialEq, Eq)]
1328pub struct DirectiveName<'tree> {
1329 pub span: ::treesitter_types::Span,
1330 text: &'tree str,
1331}
1332impl<'tree> ::treesitter_types::FromNode<'tree> for DirectiveName<'tree> {
1333 fn from_node(
1334 node: ::treesitter_types::tree_sitter::Node<'tree>,
1335 src: &'tree [u8],
1336 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1337 debug_assert_eq!(node.kind(), "directive_name");
1338 Ok(Self {
1339 span: ::treesitter_types::Span::from(node),
1340 text: node.utf8_text(src)?,
1341 })
1342 }
1343}
1344impl<'tree> ::treesitter_types::LeafNode<'tree> for DirectiveName<'tree> {
1345 fn text(&self) -> &'tree str {
1346 self.text
1347 }
1348}
1349impl ::treesitter_types::Spanned for DirectiveName<'_> {
1350 fn span(&self) -> ::treesitter_types::Span {
1351 self.span
1352 }
1353}
1354#[derive(Debug, Clone, PartialEq, Eq)]
1355pub struct DirectiveParameter<'tree> {
1356 pub span: ::treesitter_types::Span,
1357 text: &'tree str,
1358}
1359impl<'tree> ::treesitter_types::FromNode<'tree> for DirectiveParameter<'tree> {
1360 fn from_node(
1361 node: ::treesitter_types::tree_sitter::Node<'tree>,
1362 src: &'tree [u8],
1363 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1364 debug_assert_eq!(node.kind(), "directive_parameter");
1365 Ok(Self {
1366 span: ::treesitter_types::Span::from(node),
1367 text: node.utf8_text(src)?,
1368 })
1369 }
1370}
1371impl<'tree> ::treesitter_types::LeafNode<'tree> for DirectiveParameter<'tree> {
1372 fn text(&self) -> &'tree str {
1373 self.text
1374 }
1375}
1376impl ::treesitter_types::Spanned for DirectiveParameter<'_> {
1377 fn span(&self) -> ::treesitter_types::Span {
1378 self.span
1379 }
1380}
1381#[derive(Debug, Clone, PartialEq, Eq)]
1382pub struct EscapeSequence<'tree> {
1383 pub span: ::treesitter_types::Span,
1384 text: &'tree str,
1385}
1386impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
1387 fn from_node(
1388 node: ::treesitter_types::tree_sitter::Node<'tree>,
1389 src: &'tree [u8],
1390 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1391 debug_assert_eq!(node.kind(), "escape_sequence");
1392 Ok(Self {
1393 span: ::treesitter_types::Span::from(node),
1394 text: node.utf8_text(src)?,
1395 })
1396 }
1397}
1398impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
1399 fn text(&self) -> &'tree str {
1400 self.text
1401 }
1402}
1403impl ::treesitter_types::Spanned for EscapeSequence<'_> {
1404 fn span(&self) -> ::treesitter_types::Span {
1405 self.span
1406 }
1407}
1408#[derive(Debug, Clone, PartialEq, Eq)]
1409pub struct FloatScalar<'tree> {
1410 pub span: ::treesitter_types::Span,
1411 text: &'tree str,
1412}
1413impl<'tree> ::treesitter_types::FromNode<'tree> for FloatScalar<'tree> {
1414 fn from_node(
1415 node: ::treesitter_types::tree_sitter::Node<'tree>,
1416 src: &'tree [u8],
1417 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1418 debug_assert_eq!(node.kind(), "float_scalar");
1419 Ok(Self {
1420 span: ::treesitter_types::Span::from(node),
1421 text: node.utf8_text(src)?,
1422 })
1423 }
1424}
1425impl<'tree> ::treesitter_types::LeafNode<'tree> for FloatScalar<'tree> {
1426 fn text(&self) -> &'tree str {
1427 self.text
1428 }
1429}
1430impl ::treesitter_types::Spanned for FloatScalar<'_> {
1431 fn span(&self) -> ::treesitter_types::Span {
1432 self.span
1433 }
1434}
1435#[derive(Debug, Clone, PartialEq, Eq)]
1436pub struct IntegerScalar<'tree> {
1437 pub span: ::treesitter_types::Span,
1438 text: &'tree str,
1439}
1440impl<'tree> ::treesitter_types::FromNode<'tree> for IntegerScalar<'tree> {
1441 fn from_node(
1442 node: ::treesitter_types::tree_sitter::Node<'tree>,
1443 src: &'tree [u8],
1444 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1445 debug_assert_eq!(node.kind(), "integer_scalar");
1446 Ok(Self {
1447 span: ::treesitter_types::Span::from(node),
1448 text: node.utf8_text(src)?,
1449 })
1450 }
1451}
1452impl<'tree> ::treesitter_types::LeafNode<'tree> for IntegerScalar<'tree> {
1453 fn text(&self) -> &'tree str {
1454 self.text
1455 }
1456}
1457impl ::treesitter_types::Spanned for IntegerScalar<'_> {
1458 fn span(&self) -> ::treesitter_types::Span {
1459 self.span
1460 }
1461}
1462#[derive(Debug, Clone, PartialEq, Eq)]
1463pub struct NullScalar<'tree> {
1464 pub span: ::treesitter_types::Span,
1465 text: &'tree str,
1466}
1467impl<'tree> ::treesitter_types::FromNode<'tree> for NullScalar<'tree> {
1468 fn from_node(
1469 node: ::treesitter_types::tree_sitter::Node<'tree>,
1470 src: &'tree [u8],
1471 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1472 debug_assert_eq!(node.kind(), "null_scalar");
1473 Ok(Self {
1474 span: ::treesitter_types::Span::from(node),
1475 text: node.utf8_text(src)?,
1476 })
1477 }
1478}
1479impl<'tree> ::treesitter_types::LeafNode<'tree> for NullScalar<'tree> {
1480 fn text(&self) -> &'tree str {
1481 self.text
1482 }
1483}
1484impl ::treesitter_types::Spanned for NullScalar<'_> {
1485 fn span(&self) -> ::treesitter_types::Span {
1486 self.span
1487 }
1488}
1489#[derive(Debug, Clone, PartialEq, Eq)]
1490pub struct StringScalar<'tree> {
1491 pub span: ::treesitter_types::Span,
1492 text: &'tree str,
1493}
1494impl<'tree> ::treesitter_types::FromNode<'tree> for StringScalar<'tree> {
1495 fn from_node(
1496 node: ::treesitter_types::tree_sitter::Node<'tree>,
1497 src: &'tree [u8],
1498 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1499 debug_assert_eq!(node.kind(), "string_scalar");
1500 Ok(Self {
1501 span: ::treesitter_types::Span::from(node),
1502 text: node.utf8_text(src)?,
1503 })
1504 }
1505}
1506impl<'tree> ::treesitter_types::LeafNode<'tree> for StringScalar<'tree> {
1507 fn text(&self) -> &'tree str {
1508 self.text
1509 }
1510}
1511impl ::treesitter_types::Spanned for StringScalar<'_> {
1512 fn span(&self) -> ::treesitter_types::Span {
1513 self.span
1514 }
1515}
1516#[derive(Debug, Clone, PartialEq, Eq)]
1517pub struct Tag<'tree> {
1518 pub span: ::treesitter_types::Span,
1519 text: &'tree str,
1520}
1521impl<'tree> ::treesitter_types::FromNode<'tree> for Tag<'tree> {
1522 fn from_node(
1523 node: ::treesitter_types::tree_sitter::Node<'tree>,
1524 src: &'tree [u8],
1525 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1526 debug_assert_eq!(node.kind(), "tag");
1527 Ok(Self {
1528 span: ::treesitter_types::Span::from(node),
1529 text: node.utf8_text(src)?,
1530 })
1531 }
1532}
1533impl<'tree> ::treesitter_types::LeafNode<'tree> for Tag<'tree> {
1534 fn text(&self) -> &'tree str {
1535 self.text
1536 }
1537}
1538impl ::treesitter_types::Spanned for Tag<'_> {
1539 fn span(&self) -> ::treesitter_types::Span {
1540 self.span
1541 }
1542}
1543#[derive(Debug, Clone, PartialEq, Eq)]
1544pub struct TagHandle<'tree> {
1545 pub span: ::treesitter_types::Span,
1546 text: &'tree str,
1547}
1548impl<'tree> ::treesitter_types::FromNode<'tree> for TagHandle<'tree> {
1549 fn from_node(
1550 node: ::treesitter_types::tree_sitter::Node<'tree>,
1551 src: &'tree [u8],
1552 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1553 debug_assert_eq!(node.kind(), "tag_handle");
1554 Ok(Self {
1555 span: ::treesitter_types::Span::from(node),
1556 text: node.utf8_text(src)?,
1557 })
1558 }
1559}
1560impl<'tree> ::treesitter_types::LeafNode<'tree> for TagHandle<'tree> {
1561 fn text(&self) -> &'tree str {
1562 self.text
1563 }
1564}
1565impl ::treesitter_types::Spanned for TagHandle<'_> {
1566 fn span(&self) -> ::treesitter_types::Span {
1567 self.span
1568 }
1569}
1570#[derive(Debug, Clone, PartialEq, Eq)]
1571pub struct TagPrefix<'tree> {
1572 pub span: ::treesitter_types::Span,
1573 text: &'tree str,
1574}
1575impl<'tree> ::treesitter_types::FromNode<'tree> for TagPrefix<'tree> {
1576 fn from_node(
1577 node: ::treesitter_types::tree_sitter::Node<'tree>,
1578 src: &'tree [u8],
1579 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1580 debug_assert_eq!(node.kind(), "tag_prefix");
1581 Ok(Self {
1582 span: ::treesitter_types::Span::from(node),
1583 text: node.utf8_text(src)?,
1584 })
1585 }
1586}
1587impl<'tree> ::treesitter_types::LeafNode<'tree> for TagPrefix<'tree> {
1588 fn text(&self) -> &'tree str {
1589 self.text
1590 }
1591}
1592impl ::treesitter_types::Spanned for TagPrefix<'_> {
1593 fn span(&self) -> ::treesitter_types::Span {
1594 self.span
1595 }
1596}
1597#[derive(Debug, Clone, PartialEq, Eq)]
1598pub struct TimestampScalar<'tree> {
1599 pub span: ::treesitter_types::Span,
1600 text: &'tree str,
1601}
1602impl<'tree> ::treesitter_types::FromNode<'tree> for TimestampScalar<'tree> {
1603 fn from_node(
1604 node: ::treesitter_types::tree_sitter::Node<'tree>,
1605 src: &'tree [u8],
1606 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1607 debug_assert_eq!(node.kind(), "timestamp_scalar");
1608 Ok(Self {
1609 span: ::treesitter_types::Span::from(node),
1610 text: node.utf8_text(src)?,
1611 })
1612 }
1613}
1614impl<'tree> ::treesitter_types::LeafNode<'tree> for TimestampScalar<'tree> {
1615 fn text(&self) -> &'tree str {
1616 self.text
1617 }
1618}
1619impl ::treesitter_types::Spanned for TimestampScalar<'_> {
1620 fn span(&self) -> ::treesitter_types::Span {
1621 self.span
1622 }
1623}
1624#[derive(Debug, Clone, PartialEq, Eq)]
1625pub struct YamlVersion<'tree> {
1626 pub span: ::treesitter_types::Span,
1627 text: &'tree str,
1628}
1629impl<'tree> ::treesitter_types::FromNode<'tree> for YamlVersion<'tree> {
1630 fn from_node(
1631 node: ::treesitter_types::tree_sitter::Node<'tree>,
1632 src: &'tree [u8],
1633 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1634 debug_assert_eq!(node.kind(), "yaml_version");
1635 Ok(Self {
1636 span: ::treesitter_types::Span::from(node),
1637 text: node.utf8_text(src)?,
1638 })
1639 }
1640}
1641impl<'tree> ::treesitter_types::LeafNode<'tree> for YamlVersion<'tree> {
1642 fn text(&self) -> &'tree str {
1643 self.text
1644 }
1645}
1646impl ::treesitter_types::Spanned for YamlVersion<'_> {
1647 fn span(&self) -> ::treesitter_types::Span {
1648 self.span
1649 }
1650}
1651#[derive(Debug, Clone, PartialEq, Eq)]
1652pub enum BlockMappingPairKey<'tree> {
1653 BlockNode(::std::boxed::Box<BlockNode<'tree>>),
1654 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1655}
1656impl<'tree> ::treesitter_types::FromNode<'tree> for BlockMappingPairKey<'tree> {
1657 #[allow(clippy::collapsible_else_if)]
1658 fn from_node(
1659 node: ::treesitter_types::tree_sitter::Node<'tree>,
1660 src: &'tree [u8],
1661 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1662 match node.kind() {
1663 "block_node" => Ok(Self::BlockNode(::std::boxed::Box::new(
1664 ::treesitter_types::runtime::maybe_grow_stack(|| {
1665 <BlockNode as ::treesitter_types::FromNode>::from_node(node, src)
1666 })?,
1667 ))),
1668 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1669 ::treesitter_types::runtime::maybe_grow_stack(|| {
1670 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1671 })?,
1672 ))),
1673 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1674 }
1675 }
1676}
1677impl ::treesitter_types::Spanned for BlockMappingPairKey<'_> {
1678 fn span(&self) -> ::treesitter_types::Span {
1679 match self {
1680 Self::BlockNode(inner) => inner.span(),
1681 Self::FlowNode(inner) => inner.span(),
1682 }
1683 }
1684}
1685#[derive(Debug, Clone, PartialEq, Eq)]
1686pub enum BlockMappingPairValue<'tree> {
1687 BlockNode(::std::boxed::Box<BlockNode<'tree>>),
1688 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1689}
1690impl<'tree> ::treesitter_types::FromNode<'tree> for BlockMappingPairValue<'tree> {
1691 #[allow(clippy::collapsible_else_if)]
1692 fn from_node(
1693 node: ::treesitter_types::tree_sitter::Node<'tree>,
1694 src: &'tree [u8],
1695 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1696 match node.kind() {
1697 "block_node" => Ok(Self::BlockNode(::std::boxed::Box::new(
1698 ::treesitter_types::runtime::maybe_grow_stack(|| {
1699 <BlockNode as ::treesitter_types::FromNode>::from_node(node, src)
1700 })?,
1701 ))),
1702 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1703 ::treesitter_types::runtime::maybe_grow_stack(|| {
1704 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1705 })?,
1706 ))),
1707 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1708 }
1709 }
1710}
1711impl ::treesitter_types::Spanned for BlockMappingPairValue<'_> {
1712 fn span(&self) -> ::treesitter_types::Span {
1713 match self {
1714 Self::BlockNode(inner) => inner.span(),
1715 Self::FlowNode(inner) => inner.span(),
1716 }
1717 }
1718}
1719#[derive(Debug, Clone, PartialEq, Eq)]
1720pub enum BlockNodeChildren<'tree> {
1721 Anchor(::std::boxed::Box<Anchor<'tree>>),
1722 BlockMapping(::std::boxed::Box<BlockMapping<'tree>>),
1723 BlockScalar(::std::boxed::Box<BlockScalar<'tree>>),
1724 BlockSequence(::std::boxed::Box<BlockSequence<'tree>>),
1725 Tag(::std::boxed::Box<Tag<'tree>>),
1726}
1727impl<'tree> ::treesitter_types::FromNode<'tree> for BlockNodeChildren<'tree> {
1728 #[allow(clippy::collapsible_else_if)]
1729 fn from_node(
1730 node: ::treesitter_types::tree_sitter::Node<'tree>,
1731 src: &'tree [u8],
1732 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1733 match node.kind() {
1734 "anchor" => Ok(Self::Anchor(::std::boxed::Box::new(
1735 ::treesitter_types::runtime::maybe_grow_stack(|| {
1736 <Anchor as ::treesitter_types::FromNode>::from_node(node, src)
1737 })?,
1738 ))),
1739 "block_mapping" => Ok(Self::BlockMapping(::std::boxed::Box::new(
1740 ::treesitter_types::runtime::maybe_grow_stack(|| {
1741 <BlockMapping as ::treesitter_types::FromNode>::from_node(node, src)
1742 })?,
1743 ))),
1744 "block_scalar" => Ok(Self::BlockScalar(::std::boxed::Box::new(
1745 ::treesitter_types::runtime::maybe_grow_stack(|| {
1746 <BlockScalar as ::treesitter_types::FromNode>::from_node(node, src)
1747 })?,
1748 ))),
1749 "block_sequence" => Ok(Self::BlockSequence(::std::boxed::Box::new(
1750 ::treesitter_types::runtime::maybe_grow_stack(|| {
1751 <BlockSequence as ::treesitter_types::FromNode>::from_node(node, src)
1752 })?,
1753 ))),
1754 "tag" => Ok(Self::Tag(::std::boxed::Box::new(
1755 ::treesitter_types::runtime::maybe_grow_stack(|| {
1756 <Tag as ::treesitter_types::FromNode>::from_node(node, src)
1757 })?,
1758 ))),
1759 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1760 }
1761 }
1762}
1763impl ::treesitter_types::Spanned for BlockNodeChildren<'_> {
1764 fn span(&self) -> ::treesitter_types::Span {
1765 match self {
1766 Self::Anchor(inner) => inner.span(),
1767 Self::BlockMapping(inner) => inner.span(),
1768 Self::BlockScalar(inner) => inner.span(),
1769 Self::BlockSequence(inner) => inner.span(),
1770 Self::Tag(inner) => inner.span(),
1771 }
1772 }
1773}
1774#[derive(Debug, Clone, PartialEq, Eq)]
1775pub enum BlockSequenceItemChildren<'tree> {
1776 BlockNode(::std::boxed::Box<BlockNode<'tree>>),
1777 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1778}
1779impl<'tree> ::treesitter_types::FromNode<'tree> for BlockSequenceItemChildren<'tree> {
1780 #[allow(clippy::collapsible_else_if)]
1781 fn from_node(
1782 node: ::treesitter_types::tree_sitter::Node<'tree>,
1783 src: &'tree [u8],
1784 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1785 match node.kind() {
1786 "block_node" => Ok(Self::BlockNode(::std::boxed::Box::new(
1787 ::treesitter_types::runtime::maybe_grow_stack(|| {
1788 <BlockNode as ::treesitter_types::FromNode>::from_node(node, src)
1789 })?,
1790 ))),
1791 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1792 ::treesitter_types::runtime::maybe_grow_stack(|| {
1793 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1794 })?,
1795 ))),
1796 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1797 }
1798 }
1799}
1800impl ::treesitter_types::Spanned for BlockSequenceItemChildren<'_> {
1801 fn span(&self) -> ::treesitter_types::Span {
1802 match self {
1803 Self::BlockNode(inner) => inner.span(),
1804 Self::FlowNode(inner) => inner.span(),
1805 }
1806 }
1807}
1808#[derive(Debug, Clone, PartialEq, Eq)]
1809pub enum DocumentChildren<'tree> {
1810 BlockNode(::std::boxed::Box<BlockNode<'tree>>),
1811 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1812 ReservedDirective(::std::boxed::Box<ReservedDirective<'tree>>),
1813 TagDirective(::std::boxed::Box<TagDirective<'tree>>),
1814 YamlDirective(::std::boxed::Box<YamlDirective<'tree>>),
1815}
1816impl<'tree> ::treesitter_types::FromNode<'tree> for DocumentChildren<'tree> {
1817 #[allow(clippy::collapsible_else_if)]
1818 fn from_node(
1819 node: ::treesitter_types::tree_sitter::Node<'tree>,
1820 src: &'tree [u8],
1821 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1822 match node.kind() {
1823 "block_node" => Ok(Self::BlockNode(::std::boxed::Box::new(
1824 ::treesitter_types::runtime::maybe_grow_stack(|| {
1825 <BlockNode as ::treesitter_types::FromNode>::from_node(node, src)
1826 })?,
1827 ))),
1828 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1829 ::treesitter_types::runtime::maybe_grow_stack(|| {
1830 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1831 })?,
1832 ))),
1833 "reserved_directive" => Ok(Self::ReservedDirective(::std::boxed::Box::new(
1834 ::treesitter_types::runtime::maybe_grow_stack(|| {
1835 <ReservedDirective as ::treesitter_types::FromNode>::from_node(node, src)
1836 })?,
1837 ))),
1838 "tag_directive" => Ok(Self::TagDirective(::std::boxed::Box::new(
1839 ::treesitter_types::runtime::maybe_grow_stack(|| {
1840 <TagDirective as ::treesitter_types::FromNode>::from_node(node, src)
1841 })?,
1842 ))),
1843 "yaml_directive" => Ok(Self::YamlDirective(::std::boxed::Box::new(
1844 ::treesitter_types::runtime::maybe_grow_stack(|| {
1845 <YamlDirective as ::treesitter_types::FromNode>::from_node(node, src)
1846 })?,
1847 ))),
1848 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1849 }
1850 }
1851}
1852impl ::treesitter_types::Spanned for DocumentChildren<'_> {
1853 fn span(&self) -> ::treesitter_types::Span {
1854 match self {
1855 Self::BlockNode(inner) => inner.span(),
1856 Self::FlowNode(inner) => inner.span(),
1857 Self::ReservedDirective(inner) => inner.span(),
1858 Self::TagDirective(inner) => inner.span(),
1859 Self::YamlDirective(inner) => inner.span(),
1860 }
1861 }
1862}
1863#[derive(Debug, Clone, PartialEq, Eq)]
1864pub enum FlowMappingChildren<'tree> {
1865 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1866 FlowPair(::std::boxed::Box<FlowPair<'tree>>),
1867}
1868impl<'tree> ::treesitter_types::FromNode<'tree> for FlowMappingChildren<'tree> {
1869 #[allow(clippy::collapsible_else_if)]
1870 fn from_node(
1871 node: ::treesitter_types::tree_sitter::Node<'tree>,
1872 src: &'tree [u8],
1873 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1874 match node.kind() {
1875 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1876 ::treesitter_types::runtime::maybe_grow_stack(|| {
1877 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1878 })?,
1879 ))),
1880 "flow_pair" => Ok(Self::FlowPair(::std::boxed::Box::new(
1881 ::treesitter_types::runtime::maybe_grow_stack(|| {
1882 <FlowPair as ::treesitter_types::FromNode>::from_node(node, src)
1883 })?,
1884 ))),
1885 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1886 }
1887 }
1888}
1889impl ::treesitter_types::Spanned for FlowMappingChildren<'_> {
1890 fn span(&self) -> ::treesitter_types::Span {
1891 match self {
1892 Self::FlowNode(inner) => inner.span(),
1893 Self::FlowPair(inner) => inner.span(),
1894 }
1895 }
1896}
1897#[derive(Debug, Clone, PartialEq, Eq)]
1898pub enum FlowNodeChildren<'tree> {
1899 Alias(::std::boxed::Box<Alias<'tree>>),
1900 Anchor(::std::boxed::Box<Anchor<'tree>>),
1901 DoubleQuoteScalar(::std::boxed::Box<DoubleQuoteScalar<'tree>>),
1902 FlowMapping(::std::boxed::Box<FlowMapping<'tree>>),
1903 FlowSequence(::std::boxed::Box<FlowSequence<'tree>>),
1904 PlainScalar(::std::boxed::Box<PlainScalar<'tree>>),
1905 SingleQuoteScalar(::std::boxed::Box<SingleQuoteScalar<'tree>>),
1906 Tag(::std::boxed::Box<Tag<'tree>>),
1907}
1908impl<'tree> ::treesitter_types::FromNode<'tree> for FlowNodeChildren<'tree> {
1909 #[allow(clippy::collapsible_else_if)]
1910 fn from_node(
1911 node: ::treesitter_types::tree_sitter::Node<'tree>,
1912 src: &'tree [u8],
1913 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1914 match node.kind() {
1915 "alias" => Ok(Self::Alias(::std::boxed::Box::new(
1916 ::treesitter_types::runtime::maybe_grow_stack(|| {
1917 <Alias as ::treesitter_types::FromNode>::from_node(node, src)
1918 })?,
1919 ))),
1920 "anchor" => Ok(Self::Anchor(::std::boxed::Box::new(
1921 ::treesitter_types::runtime::maybe_grow_stack(|| {
1922 <Anchor as ::treesitter_types::FromNode>::from_node(node, src)
1923 })?,
1924 ))),
1925 "double_quote_scalar" => Ok(Self::DoubleQuoteScalar(::std::boxed::Box::new(
1926 ::treesitter_types::runtime::maybe_grow_stack(|| {
1927 <DoubleQuoteScalar as ::treesitter_types::FromNode>::from_node(node, src)
1928 })?,
1929 ))),
1930 "flow_mapping" => Ok(Self::FlowMapping(::std::boxed::Box::new(
1931 ::treesitter_types::runtime::maybe_grow_stack(|| {
1932 <FlowMapping as ::treesitter_types::FromNode>::from_node(node, src)
1933 })?,
1934 ))),
1935 "flow_sequence" => Ok(Self::FlowSequence(::std::boxed::Box::new(
1936 ::treesitter_types::runtime::maybe_grow_stack(|| {
1937 <FlowSequence as ::treesitter_types::FromNode>::from_node(node, src)
1938 })?,
1939 ))),
1940 "plain_scalar" => Ok(Self::PlainScalar(::std::boxed::Box::new(
1941 ::treesitter_types::runtime::maybe_grow_stack(|| {
1942 <PlainScalar as ::treesitter_types::FromNode>::from_node(node, src)
1943 })?,
1944 ))),
1945 "single_quote_scalar" => Ok(Self::SingleQuoteScalar(::std::boxed::Box::new(
1946 ::treesitter_types::runtime::maybe_grow_stack(|| {
1947 <SingleQuoteScalar as ::treesitter_types::FromNode>::from_node(node, src)
1948 })?,
1949 ))),
1950 "tag" => Ok(Self::Tag(::std::boxed::Box::new(
1951 ::treesitter_types::runtime::maybe_grow_stack(|| {
1952 <Tag as ::treesitter_types::FromNode>::from_node(node, src)
1953 })?,
1954 ))),
1955 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1956 }
1957 }
1958}
1959impl ::treesitter_types::Spanned for FlowNodeChildren<'_> {
1960 fn span(&self) -> ::treesitter_types::Span {
1961 match self {
1962 Self::Alias(inner) => inner.span(),
1963 Self::Anchor(inner) => inner.span(),
1964 Self::DoubleQuoteScalar(inner) => inner.span(),
1965 Self::FlowMapping(inner) => inner.span(),
1966 Self::FlowSequence(inner) => inner.span(),
1967 Self::PlainScalar(inner) => inner.span(),
1968 Self::SingleQuoteScalar(inner) => inner.span(),
1969 Self::Tag(inner) => inner.span(),
1970 }
1971 }
1972}
1973#[derive(Debug, Clone, PartialEq, Eq)]
1974pub enum FlowSequenceChildren<'tree> {
1975 FlowNode(::std::boxed::Box<FlowNode<'tree>>),
1976 FlowPair(::std::boxed::Box<FlowPair<'tree>>),
1977}
1978impl<'tree> ::treesitter_types::FromNode<'tree> for FlowSequenceChildren<'tree> {
1979 #[allow(clippy::collapsible_else_if)]
1980 fn from_node(
1981 node: ::treesitter_types::tree_sitter::Node<'tree>,
1982 src: &'tree [u8],
1983 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1984 match node.kind() {
1985 "flow_node" => Ok(Self::FlowNode(::std::boxed::Box::new(
1986 ::treesitter_types::runtime::maybe_grow_stack(|| {
1987 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
1988 })?,
1989 ))),
1990 "flow_pair" => Ok(Self::FlowPair(::std::boxed::Box::new(
1991 ::treesitter_types::runtime::maybe_grow_stack(|| {
1992 <FlowPair as ::treesitter_types::FromNode>::from_node(node, src)
1993 })?,
1994 ))),
1995 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1996 }
1997 }
1998}
1999impl ::treesitter_types::Spanned for FlowSequenceChildren<'_> {
2000 fn span(&self) -> ::treesitter_types::Span {
2001 match self {
2002 Self::FlowNode(inner) => inner.span(),
2003 Self::FlowPair(inner) => inner.span(),
2004 }
2005 }
2006}
2007#[derive(Debug, Clone, PartialEq, Eq)]
2008pub enum PlainScalarChildren<'tree> {
2009 BooleanScalar(::std::boxed::Box<BooleanScalar<'tree>>),
2010 FloatScalar(::std::boxed::Box<FloatScalar<'tree>>),
2011 IntegerScalar(::std::boxed::Box<IntegerScalar<'tree>>),
2012 NullScalar(::std::boxed::Box<NullScalar<'tree>>),
2013 StringScalar(::std::boxed::Box<StringScalar<'tree>>),
2014 TimestampScalar(::std::boxed::Box<TimestampScalar<'tree>>),
2015}
2016impl<'tree> ::treesitter_types::FromNode<'tree> for PlainScalarChildren<'tree> {
2017 #[allow(clippy::collapsible_else_if)]
2018 fn from_node(
2019 node: ::treesitter_types::tree_sitter::Node<'tree>,
2020 src: &'tree [u8],
2021 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2022 match node.kind() {
2023 "boolean_scalar" => Ok(Self::BooleanScalar(::std::boxed::Box::new(
2024 ::treesitter_types::runtime::maybe_grow_stack(|| {
2025 <BooleanScalar as ::treesitter_types::FromNode>::from_node(node, src)
2026 })?,
2027 ))),
2028 "float_scalar" => Ok(Self::FloatScalar(::std::boxed::Box::new(
2029 ::treesitter_types::runtime::maybe_grow_stack(|| {
2030 <FloatScalar as ::treesitter_types::FromNode>::from_node(node, src)
2031 })?,
2032 ))),
2033 "integer_scalar" => Ok(Self::IntegerScalar(::std::boxed::Box::new(
2034 ::treesitter_types::runtime::maybe_grow_stack(|| {
2035 <IntegerScalar as ::treesitter_types::FromNode>::from_node(node, src)
2036 })?,
2037 ))),
2038 "null_scalar" => Ok(Self::NullScalar(::std::boxed::Box::new(
2039 ::treesitter_types::runtime::maybe_grow_stack(|| {
2040 <NullScalar as ::treesitter_types::FromNode>::from_node(node, src)
2041 })?,
2042 ))),
2043 "string_scalar" => Ok(Self::StringScalar(::std::boxed::Box::new(
2044 ::treesitter_types::runtime::maybe_grow_stack(|| {
2045 <StringScalar as ::treesitter_types::FromNode>::from_node(node, src)
2046 })?,
2047 ))),
2048 "timestamp_scalar" => Ok(Self::TimestampScalar(::std::boxed::Box::new(
2049 ::treesitter_types::runtime::maybe_grow_stack(|| {
2050 <TimestampScalar as ::treesitter_types::FromNode>::from_node(node, src)
2051 })?,
2052 ))),
2053 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2054 }
2055 }
2056}
2057impl ::treesitter_types::Spanned for PlainScalarChildren<'_> {
2058 fn span(&self) -> ::treesitter_types::Span {
2059 match self {
2060 Self::BooleanScalar(inner) => inner.span(),
2061 Self::FloatScalar(inner) => inner.span(),
2062 Self::IntegerScalar(inner) => inner.span(),
2063 Self::NullScalar(inner) => inner.span(),
2064 Self::StringScalar(inner) => inner.span(),
2065 Self::TimestampScalar(inner) => inner.span(),
2066 }
2067 }
2068}
2069#[derive(Debug, Clone, PartialEq, Eq)]
2070pub enum ReservedDirectiveChildren<'tree> {
2071 DirectiveName(::std::boxed::Box<DirectiveName<'tree>>),
2072 DirectiveParameter(::std::boxed::Box<DirectiveParameter<'tree>>),
2073}
2074impl<'tree> ::treesitter_types::FromNode<'tree> for ReservedDirectiveChildren<'tree> {
2075 #[allow(clippy::collapsible_else_if)]
2076 fn from_node(
2077 node: ::treesitter_types::tree_sitter::Node<'tree>,
2078 src: &'tree [u8],
2079 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2080 match node.kind() {
2081 "directive_name" => Ok(Self::DirectiveName(::std::boxed::Box::new(
2082 ::treesitter_types::runtime::maybe_grow_stack(|| {
2083 <DirectiveName as ::treesitter_types::FromNode>::from_node(node, src)
2084 })?,
2085 ))),
2086 "directive_parameter" => Ok(Self::DirectiveParameter(::std::boxed::Box::new(
2087 ::treesitter_types::runtime::maybe_grow_stack(|| {
2088 <DirectiveParameter as ::treesitter_types::FromNode>::from_node(node, src)
2089 })?,
2090 ))),
2091 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2092 }
2093 }
2094}
2095impl ::treesitter_types::Spanned for ReservedDirectiveChildren<'_> {
2096 fn span(&self) -> ::treesitter_types::Span {
2097 match self {
2098 Self::DirectiveName(inner) => inner.span(),
2099 Self::DirectiveParameter(inner) => inner.span(),
2100 }
2101 }
2102}
2103#[derive(Debug, Clone, PartialEq, Eq)]
2104pub enum TagDirectiveChildren<'tree> {
2105 TagHandle(::std::boxed::Box<TagHandle<'tree>>),
2106 TagPrefix(::std::boxed::Box<TagPrefix<'tree>>),
2107}
2108impl<'tree> ::treesitter_types::FromNode<'tree> for TagDirectiveChildren<'tree> {
2109 #[allow(clippy::collapsible_else_if)]
2110 fn from_node(
2111 node: ::treesitter_types::tree_sitter::Node<'tree>,
2112 src: &'tree [u8],
2113 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
2114 match node.kind() {
2115 "tag_handle" => Ok(Self::TagHandle(::std::boxed::Box::new(
2116 ::treesitter_types::runtime::maybe_grow_stack(|| {
2117 <TagHandle as ::treesitter_types::FromNode>::from_node(node, src)
2118 })?,
2119 ))),
2120 "tag_prefix" => Ok(Self::TagPrefix(::std::boxed::Box::new(
2121 ::treesitter_types::runtime::maybe_grow_stack(|| {
2122 <TagPrefix as ::treesitter_types::FromNode>::from_node(node, src)
2123 })?,
2124 ))),
2125 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
2126 }
2127 }
2128}
2129impl ::treesitter_types::Spanned for TagDirectiveChildren<'_> {
2130 fn span(&self) -> ::treesitter_types::Span {
2131 match self {
2132 Self::TagHandle(inner) => inner.span(),
2133 Self::TagPrefix(inner) => inner.span(),
2134 }
2135 }
2136}
2137#[derive(Debug, Clone, PartialEq, Eq)]
2138pub enum AnyNode<'tree> {
2139 Alias(Alias<'tree>),
2140 Anchor(Anchor<'tree>),
2141 BlockMapping(BlockMapping<'tree>),
2142 BlockMappingPair(BlockMappingPair<'tree>),
2143 BlockNode(BlockNode<'tree>),
2144 BlockScalar(BlockScalar<'tree>),
2145 BlockSequence(BlockSequence<'tree>),
2146 BlockSequenceItem(BlockSequenceItem<'tree>),
2147 Document(Document<'tree>),
2148 DoubleQuoteScalar(DoubleQuoteScalar<'tree>),
2149 FlowMapping(FlowMapping<'tree>),
2150 FlowNode(FlowNode<'tree>),
2151 FlowPair(FlowPair<'tree>),
2152 FlowSequence(FlowSequence<'tree>),
2153 PlainScalar(PlainScalar<'tree>),
2154 ReservedDirective(ReservedDirective<'tree>),
2155 SingleQuoteScalar(SingleQuoteScalar<'tree>),
2156 Stream(Stream<'tree>),
2157 TagDirective(TagDirective<'tree>),
2158 YamlDirective(YamlDirective<'tree>),
2159 AliasName(AliasName<'tree>),
2160 AnchorName(AnchorName<'tree>),
2161 BooleanScalar(BooleanScalar<'tree>),
2162 Comment(Comment<'tree>),
2163 DirectiveName(DirectiveName<'tree>),
2164 DirectiveParameter(DirectiveParameter<'tree>),
2165 EscapeSequence(EscapeSequence<'tree>),
2166 FloatScalar(FloatScalar<'tree>),
2167 IntegerScalar(IntegerScalar<'tree>),
2168 NullScalar(NullScalar<'tree>),
2169 StringScalar(StringScalar<'tree>),
2170 Tag(Tag<'tree>),
2171 TagHandle(TagHandle<'tree>),
2172 TagPrefix(TagPrefix<'tree>),
2173 TimestampScalar(TimestampScalar<'tree>),
2174 YamlVersion(YamlVersion<'tree>),
2175 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
2176}
2177impl<'tree> AnyNode<'tree> {
2178 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
2179 match node.kind() {
2180 "alias" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2181 <Alias as ::treesitter_types::FromNode>::from_node(node, src)
2182 })
2183 .map(Self::Alias)
2184 .unwrap_or(Self::Unknown(node)),
2185 "anchor" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2186 <Anchor as ::treesitter_types::FromNode>::from_node(node, src)
2187 })
2188 .map(Self::Anchor)
2189 .unwrap_or(Self::Unknown(node)),
2190 "block_mapping" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2191 <BlockMapping as ::treesitter_types::FromNode>::from_node(node, src)
2192 })
2193 .map(Self::BlockMapping)
2194 .unwrap_or(Self::Unknown(node)),
2195 "block_mapping_pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2196 <BlockMappingPair as ::treesitter_types::FromNode>::from_node(node, src)
2197 })
2198 .map(Self::BlockMappingPair)
2199 .unwrap_or(Self::Unknown(node)),
2200 "block_node" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2201 <BlockNode as ::treesitter_types::FromNode>::from_node(node, src)
2202 })
2203 .map(Self::BlockNode)
2204 .unwrap_or(Self::Unknown(node)),
2205 "block_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2206 <BlockScalar as ::treesitter_types::FromNode>::from_node(node, src)
2207 })
2208 .map(Self::BlockScalar)
2209 .unwrap_or(Self::Unknown(node)),
2210 "block_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2211 <BlockSequence as ::treesitter_types::FromNode>::from_node(node, src)
2212 })
2213 .map(Self::BlockSequence)
2214 .unwrap_or(Self::Unknown(node)),
2215 "block_sequence_item" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2216 <BlockSequenceItem as ::treesitter_types::FromNode>::from_node(node, src)
2217 })
2218 .map(Self::BlockSequenceItem)
2219 .unwrap_or(Self::Unknown(node)),
2220 "document" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2221 <Document as ::treesitter_types::FromNode>::from_node(node, src)
2222 })
2223 .map(Self::Document)
2224 .unwrap_or(Self::Unknown(node)),
2225 "double_quote_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2226 <DoubleQuoteScalar as ::treesitter_types::FromNode>::from_node(node, src)
2227 })
2228 .map(Self::DoubleQuoteScalar)
2229 .unwrap_or(Self::Unknown(node)),
2230 "flow_mapping" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2231 <FlowMapping as ::treesitter_types::FromNode>::from_node(node, src)
2232 })
2233 .map(Self::FlowMapping)
2234 .unwrap_or(Self::Unknown(node)),
2235 "flow_node" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2236 <FlowNode as ::treesitter_types::FromNode>::from_node(node, src)
2237 })
2238 .map(Self::FlowNode)
2239 .unwrap_or(Self::Unknown(node)),
2240 "flow_pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2241 <FlowPair as ::treesitter_types::FromNode>::from_node(node, src)
2242 })
2243 .map(Self::FlowPair)
2244 .unwrap_or(Self::Unknown(node)),
2245 "flow_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2246 <FlowSequence as ::treesitter_types::FromNode>::from_node(node, src)
2247 })
2248 .map(Self::FlowSequence)
2249 .unwrap_or(Self::Unknown(node)),
2250 "plain_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2251 <PlainScalar as ::treesitter_types::FromNode>::from_node(node, src)
2252 })
2253 .map(Self::PlainScalar)
2254 .unwrap_or(Self::Unknown(node)),
2255 "reserved_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2256 <ReservedDirective as ::treesitter_types::FromNode>::from_node(node, src)
2257 })
2258 .map(Self::ReservedDirective)
2259 .unwrap_or(Self::Unknown(node)),
2260 "single_quote_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2261 <SingleQuoteScalar as ::treesitter_types::FromNode>::from_node(node, src)
2262 })
2263 .map(Self::SingleQuoteScalar)
2264 .unwrap_or(Self::Unknown(node)),
2265 "stream" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2266 <Stream as ::treesitter_types::FromNode>::from_node(node, src)
2267 })
2268 .map(Self::Stream)
2269 .unwrap_or(Self::Unknown(node)),
2270 "tag_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2271 <TagDirective as ::treesitter_types::FromNode>::from_node(node, src)
2272 })
2273 .map(Self::TagDirective)
2274 .unwrap_or(Self::Unknown(node)),
2275 "yaml_directive" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2276 <YamlDirective as ::treesitter_types::FromNode>::from_node(node, src)
2277 })
2278 .map(Self::YamlDirective)
2279 .unwrap_or(Self::Unknown(node)),
2280 "alias_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2281 <AliasName as ::treesitter_types::FromNode>::from_node(node, src)
2282 })
2283 .map(Self::AliasName)
2284 .unwrap_or(Self::Unknown(node)),
2285 "anchor_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2286 <AnchorName as ::treesitter_types::FromNode>::from_node(node, src)
2287 })
2288 .map(Self::AnchorName)
2289 .unwrap_or(Self::Unknown(node)),
2290 "boolean_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2291 <BooleanScalar as ::treesitter_types::FromNode>::from_node(node, src)
2292 })
2293 .map(Self::BooleanScalar)
2294 .unwrap_or(Self::Unknown(node)),
2295 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2296 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
2297 })
2298 .map(Self::Comment)
2299 .unwrap_or(Self::Unknown(node)),
2300 "directive_name" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2301 <DirectiveName as ::treesitter_types::FromNode>::from_node(node, src)
2302 })
2303 .map(Self::DirectiveName)
2304 .unwrap_or(Self::Unknown(node)),
2305 "directive_parameter" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2306 <DirectiveParameter as ::treesitter_types::FromNode>::from_node(node, src)
2307 })
2308 .map(Self::DirectiveParameter)
2309 .unwrap_or(Self::Unknown(node)),
2310 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2311 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
2312 })
2313 .map(Self::EscapeSequence)
2314 .unwrap_or(Self::Unknown(node)),
2315 "float_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2316 <FloatScalar as ::treesitter_types::FromNode>::from_node(node, src)
2317 })
2318 .map(Self::FloatScalar)
2319 .unwrap_or(Self::Unknown(node)),
2320 "integer_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2321 <IntegerScalar as ::treesitter_types::FromNode>::from_node(node, src)
2322 })
2323 .map(Self::IntegerScalar)
2324 .unwrap_or(Self::Unknown(node)),
2325 "null_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2326 <NullScalar as ::treesitter_types::FromNode>::from_node(node, src)
2327 })
2328 .map(Self::NullScalar)
2329 .unwrap_or(Self::Unknown(node)),
2330 "string_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2331 <StringScalar as ::treesitter_types::FromNode>::from_node(node, src)
2332 })
2333 .map(Self::StringScalar)
2334 .unwrap_or(Self::Unknown(node)),
2335 "tag" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2336 <Tag as ::treesitter_types::FromNode>::from_node(node, src)
2337 })
2338 .map(Self::Tag)
2339 .unwrap_or(Self::Unknown(node)),
2340 "tag_handle" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2341 <TagHandle as ::treesitter_types::FromNode>::from_node(node, src)
2342 })
2343 .map(Self::TagHandle)
2344 .unwrap_or(Self::Unknown(node)),
2345 "tag_prefix" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2346 <TagPrefix as ::treesitter_types::FromNode>::from_node(node, src)
2347 })
2348 .map(Self::TagPrefix)
2349 .unwrap_or(Self::Unknown(node)),
2350 "timestamp_scalar" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2351 <TimestampScalar as ::treesitter_types::FromNode>::from_node(node, src)
2352 })
2353 .map(Self::TimestampScalar)
2354 .unwrap_or(Self::Unknown(node)),
2355 "yaml_version" => ::treesitter_types::runtime::maybe_grow_stack(|| {
2356 <YamlVersion as ::treesitter_types::FromNode>::from_node(node, src)
2357 })
2358 .map(Self::YamlVersion)
2359 .unwrap_or(Self::Unknown(node)),
2360 _ => Self::Unknown(node),
2361 }
2362 }
2363}
2364impl ::treesitter_types::Spanned for AnyNode<'_> {
2365 fn span(&self) -> ::treesitter_types::Span {
2366 match self {
2367 Self::Alias(inner) => inner.span(),
2368 Self::Anchor(inner) => inner.span(),
2369 Self::BlockMapping(inner) => inner.span(),
2370 Self::BlockMappingPair(inner) => inner.span(),
2371 Self::BlockNode(inner) => inner.span(),
2372 Self::BlockScalar(inner) => inner.span(),
2373 Self::BlockSequence(inner) => inner.span(),
2374 Self::BlockSequenceItem(inner) => inner.span(),
2375 Self::Document(inner) => inner.span(),
2376 Self::DoubleQuoteScalar(inner) => inner.span(),
2377 Self::FlowMapping(inner) => inner.span(),
2378 Self::FlowNode(inner) => inner.span(),
2379 Self::FlowPair(inner) => inner.span(),
2380 Self::FlowSequence(inner) => inner.span(),
2381 Self::PlainScalar(inner) => inner.span(),
2382 Self::ReservedDirective(inner) => inner.span(),
2383 Self::SingleQuoteScalar(inner) => inner.span(),
2384 Self::Stream(inner) => inner.span(),
2385 Self::TagDirective(inner) => inner.span(),
2386 Self::YamlDirective(inner) => inner.span(),
2387 Self::AliasName(inner) => inner.span(),
2388 Self::AnchorName(inner) => inner.span(),
2389 Self::BooleanScalar(inner) => inner.span(),
2390 Self::Comment(inner) => inner.span(),
2391 Self::DirectiveName(inner) => inner.span(),
2392 Self::DirectiveParameter(inner) => inner.span(),
2393 Self::EscapeSequence(inner) => inner.span(),
2394 Self::FloatScalar(inner) => inner.span(),
2395 Self::IntegerScalar(inner) => inner.span(),
2396 Self::NullScalar(inner) => inner.span(),
2397 Self::StringScalar(inner) => inner.span(),
2398 Self::Tag(inner) => inner.span(),
2399 Self::TagHandle(inner) => inner.span(),
2400 Self::TagPrefix(inner) => inner.span(),
2401 Self::TimestampScalar(inner) => inner.span(),
2402 Self::YamlVersion(inner) => inner.span(),
2403 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
2404 }
2405 }
2406}