1#[derive(Debug, Clone, PartialEq, Eq)]
2pub struct Array<'tree> {
3 pub span: ::treesitter_types::Span,
4 pub children: ::std::vec::Vec<ArrayChildren<'tree>>,
5}
6impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'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(), "array");
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 mut items = ::std::vec::Vec::new();
36 for child in non_field_children {
37 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
38 <ArrayChildren as ::treesitter_types::FromNode>::from_node(child, src)
39 })?);
40 }
41 items
42 },
43 })
44 }
45}
46impl ::treesitter_types::Spanned for Array<'_> {
47 fn span(&self) -> ::treesitter_types::Span {
48 self.span
49 }
50}
51#[derive(Debug, Clone, PartialEq, Eq)]
52pub struct Document<'tree> {
53 pub span: ::treesitter_types::Span,
54 pub children: ::std::vec::Vec<DocumentChildren<'tree>>,
55}
56impl<'tree> ::treesitter_types::FromNode<'tree> for Document<'tree> {
57 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
58 fn from_node(
59 node: ::treesitter_types::tree_sitter::Node<'tree>,
60 src: &'tree [u8],
61 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
62 debug_assert_eq!(node.kind(), "document");
63 Ok(Self {
64 span: ::treesitter_types::Span::from(node),
65 children: {
66 #[allow(clippy::suspicious_else_formatting)]
67 let non_field_children = {
68 let mut cursor = node.walk();
69 let mut result = ::std::vec::Vec::new();
70 if cursor.goto_first_child() {
71 loop {
72 if cursor.field_name().is_none()
73 && cursor.node().is_named()
74 && !cursor.node().is_extra()
75 {
76 result.push(cursor.node());
77 }
78 if !cursor.goto_next_sibling() {
79 break;
80 }
81 }
82 }
83 result
84 };
85 let mut items = ::std::vec::Vec::new();
86 for child in non_field_children {
87 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
88 <DocumentChildren as ::treesitter_types::FromNode>::from_node(child, src)
89 })?);
90 }
91 items
92 },
93 })
94 }
95}
96impl ::treesitter_types::Spanned for Document<'_> {
97 fn span(&self) -> ::treesitter_types::Span {
98 self.span
99 }
100}
101#[derive(Debug, Clone, PartialEq, Eq)]
102pub struct DottedKey<'tree> {
103 pub span: ::treesitter_types::Span,
104 pub children: ::std::vec::Vec<DottedKeyChildren<'tree>>,
105}
106impl<'tree> ::treesitter_types::FromNode<'tree> for DottedKey<'tree> {
107 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
108 fn from_node(
109 node: ::treesitter_types::tree_sitter::Node<'tree>,
110 src: &'tree [u8],
111 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
112 debug_assert_eq!(node.kind(), "dotted_key");
113 Ok(Self {
114 span: ::treesitter_types::Span::from(node),
115 children: {
116 #[allow(clippy::suspicious_else_formatting)]
117 let non_field_children = {
118 let mut cursor = node.walk();
119 let mut result = ::std::vec::Vec::new();
120 if cursor.goto_first_child() {
121 loop {
122 if cursor.field_name().is_none()
123 && cursor.node().is_named()
124 && !cursor.node().is_extra()
125 {
126 result.push(cursor.node());
127 }
128 if !cursor.goto_next_sibling() {
129 break;
130 }
131 }
132 }
133 result
134 };
135 let mut items = ::std::vec::Vec::new();
136 for child in non_field_children {
137 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
138 <DottedKeyChildren as ::treesitter_types::FromNode>::from_node(child, src)
139 })?);
140 }
141 items
142 },
143 })
144 }
145}
146impl ::treesitter_types::Spanned for DottedKey<'_> {
147 fn span(&self) -> ::treesitter_types::Span {
148 self.span
149 }
150}
151#[derive(Debug, Clone, PartialEq, Eq)]
152pub struct Float<'tree> {
153 pub span: ::treesitter_types::Span,
154 text: &'tree str,
155}
156impl<'tree> ::treesitter_types::FromNode<'tree> for Float<'tree> {
157 fn from_node(
158 node: ::treesitter_types::tree_sitter::Node<'tree>,
159 src: &'tree [u8],
160 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
161 debug_assert_eq!(node.kind(), "float");
162 Ok(Self {
163 span: ::treesitter_types::Span::from(node),
164 text: node.utf8_text(src)?,
165 })
166 }
167}
168impl<'tree> ::treesitter_types::LeafNode<'tree> for Float<'tree> {
169 fn text(&self) -> &'tree str {
170 self.text
171 }
172}
173impl ::treesitter_types::Spanned for Float<'_> {
174 fn span(&self) -> ::treesitter_types::Span {
175 self.span
176 }
177}
178#[derive(Debug, Clone, PartialEq, Eq)]
179pub struct InlineTable<'tree> {
180 pub span: ::treesitter_types::Span,
181 pub children: ::std::vec::Vec<Pair<'tree>>,
182}
183impl<'tree> ::treesitter_types::FromNode<'tree> for InlineTable<'tree> {
184 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
185 fn from_node(
186 node: ::treesitter_types::tree_sitter::Node<'tree>,
187 src: &'tree [u8],
188 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
189 debug_assert_eq!(node.kind(), "inline_table");
190 Ok(Self {
191 span: ::treesitter_types::Span::from(node),
192 children: {
193 #[allow(clippy::suspicious_else_formatting)]
194 let non_field_children = {
195 let mut cursor = node.walk();
196 let mut result = ::std::vec::Vec::new();
197 if cursor.goto_first_child() {
198 loop {
199 if cursor.field_name().is_none()
200 && cursor.node().is_named()
201 && !cursor.node().is_extra()
202 {
203 result.push(cursor.node());
204 }
205 if !cursor.goto_next_sibling() {
206 break;
207 }
208 }
209 }
210 result
211 };
212 let mut items = ::std::vec::Vec::new();
213 for child in non_field_children {
214 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
215 <Pair as ::treesitter_types::FromNode>::from_node(child, src)
216 })?);
217 }
218 items
219 },
220 })
221 }
222}
223impl ::treesitter_types::Spanned for InlineTable<'_> {
224 fn span(&self) -> ::treesitter_types::Span {
225 self.span
226 }
227}
228#[derive(Debug, Clone, PartialEq, Eq)]
229pub struct Integer<'tree> {
230 pub span: ::treesitter_types::Span,
231 text: &'tree str,
232}
233impl<'tree> ::treesitter_types::FromNode<'tree> for Integer<'tree> {
234 fn from_node(
235 node: ::treesitter_types::tree_sitter::Node<'tree>,
236 src: &'tree [u8],
237 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
238 debug_assert_eq!(node.kind(), "integer");
239 Ok(Self {
240 span: ::treesitter_types::Span::from(node),
241 text: node.utf8_text(src)?,
242 })
243 }
244}
245impl<'tree> ::treesitter_types::LeafNode<'tree> for Integer<'tree> {
246 fn text(&self) -> &'tree str {
247 self.text
248 }
249}
250impl ::treesitter_types::Spanned for Integer<'_> {
251 fn span(&self) -> ::treesitter_types::Span {
252 self.span
253 }
254}
255#[derive(Debug, Clone, PartialEq, Eq)]
256pub struct Pair<'tree> {
257 pub span: ::treesitter_types::Span,
258 pub children: ::std::vec::Vec<PairChildren<'tree>>,
259}
260impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
261 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
262 fn from_node(
263 node: ::treesitter_types::tree_sitter::Node<'tree>,
264 src: &'tree [u8],
265 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
266 debug_assert_eq!(node.kind(), "pair");
267 Ok(Self {
268 span: ::treesitter_types::Span::from(node),
269 children: {
270 #[allow(clippy::suspicious_else_formatting)]
271 let non_field_children = {
272 let mut cursor = node.walk();
273 let mut result = ::std::vec::Vec::new();
274 if cursor.goto_first_child() {
275 loop {
276 if cursor.field_name().is_none()
277 && cursor.node().is_named()
278 && !cursor.node().is_extra()
279 {
280 result.push(cursor.node());
281 }
282 if !cursor.goto_next_sibling() {
283 break;
284 }
285 }
286 }
287 result
288 };
289 let mut items = ::std::vec::Vec::new();
290 for child in non_field_children {
291 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
292 <PairChildren as ::treesitter_types::FromNode>::from_node(child, src)
293 })?);
294 }
295 items
296 },
297 })
298 }
299}
300impl ::treesitter_types::Spanned for Pair<'_> {
301 fn span(&self) -> ::treesitter_types::Span {
302 self.span
303 }
304}
305#[derive(Debug, Clone, PartialEq, Eq)]
306pub struct QuotedKey<'tree> {
307 pub span: ::treesitter_types::Span,
308 pub children: ::std::vec::Vec<EscapeSequence<'tree>>,
309}
310impl<'tree> ::treesitter_types::FromNode<'tree> for QuotedKey<'tree> {
311 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
312 fn from_node(
313 node: ::treesitter_types::tree_sitter::Node<'tree>,
314 src: &'tree [u8],
315 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
316 debug_assert_eq!(node.kind(), "quoted_key");
317 Ok(Self {
318 span: ::treesitter_types::Span::from(node),
319 children: {
320 #[allow(clippy::suspicious_else_formatting)]
321 let non_field_children = {
322 let mut cursor = node.walk();
323 let mut result = ::std::vec::Vec::new();
324 if cursor.goto_first_child() {
325 loop {
326 if cursor.field_name().is_none()
327 && cursor.node().is_named()
328 && !cursor.node().is_extra()
329 {
330 result.push(cursor.node());
331 }
332 if !cursor.goto_next_sibling() {
333 break;
334 }
335 }
336 }
337 result
338 };
339 let mut items = ::std::vec::Vec::new();
340 for child in non_field_children {
341 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
342 <EscapeSequence as ::treesitter_types::FromNode>::from_node(child, src)
343 })?);
344 }
345 items
346 },
347 })
348 }
349}
350impl ::treesitter_types::Spanned for QuotedKey<'_> {
351 fn span(&self) -> ::treesitter_types::Span {
352 self.span
353 }
354}
355#[derive(Debug, Clone, PartialEq, Eq)]
356pub struct String<'tree> {
357 pub span: ::treesitter_types::Span,
358 pub children: ::std::vec::Vec<EscapeSequence<'tree>>,
359}
360impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
361 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
362 fn from_node(
363 node: ::treesitter_types::tree_sitter::Node<'tree>,
364 src: &'tree [u8],
365 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
366 debug_assert_eq!(node.kind(), "string");
367 Ok(Self {
368 span: ::treesitter_types::Span::from(node),
369 children: {
370 #[allow(clippy::suspicious_else_formatting)]
371 let non_field_children = {
372 let mut cursor = node.walk();
373 let mut result = ::std::vec::Vec::new();
374 if cursor.goto_first_child() {
375 loop {
376 if cursor.field_name().is_none()
377 && cursor.node().is_named()
378 && !cursor.node().is_extra()
379 {
380 result.push(cursor.node());
381 }
382 if !cursor.goto_next_sibling() {
383 break;
384 }
385 }
386 }
387 result
388 };
389 let mut items = ::std::vec::Vec::new();
390 for child in non_field_children {
391 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
392 <EscapeSequence as ::treesitter_types::FromNode>::from_node(child, src)
393 })?);
394 }
395 items
396 },
397 })
398 }
399}
400impl ::treesitter_types::Spanned for String<'_> {
401 fn span(&self) -> ::treesitter_types::Span {
402 self.span
403 }
404}
405#[derive(Debug, Clone, PartialEq, Eq)]
406pub struct Table<'tree> {
407 pub span: ::treesitter_types::Span,
408 pub children: ::std::vec::Vec<TableChildren<'tree>>,
409}
410impl<'tree> ::treesitter_types::FromNode<'tree> for Table<'tree> {
411 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
412 fn from_node(
413 node: ::treesitter_types::tree_sitter::Node<'tree>,
414 src: &'tree [u8],
415 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
416 debug_assert_eq!(node.kind(), "table");
417 Ok(Self {
418 span: ::treesitter_types::Span::from(node),
419 children: {
420 #[allow(clippy::suspicious_else_formatting)]
421 let non_field_children = {
422 let mut cursor = node.walk();
423 let mut result = ::std::vec::Vec::new();
424 if cursor.goto_first_child() {
425 loop {
426 if cursor.field_name().is_none()
427 && cursor.node().is_named()
428 && !cursor.node().is_extra()
429 {
430 result.push(cursor.node());
431 }
432 if !cursor.goto_next_sibling() {
433 break;
434 }
435 }
436 }
437 result
438 };
439 let mut items = ::std::vec::Vec::new();
440 for child in non_field_children {
441 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
442 <TableChildren as ::treesitter_types::FromNode>::from_node(child, src)
443 })?);
444 }
445 items
446 },
447 })
448 }
449}
450impl ::treesitter_types::Spanned for Table<'_> {
451 fn span(&self) -> ::treesitter_types::Span {
452 self.span
453 }
454}
455#[derive(Debug, Clone, PartialEq, Eq)]
456pub struct TableArrayElement<'tree> {
457 pub span: ::treesitter_types::Span,
458 pub children: ::std::vec::Vec<TableArrayElementChildren<'tree>>,
459}
460impl<'tree> ::treesitter_types::FromNode<'tree> for TableArrayElement<'tree> {
461 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
462 fn from_node(
463 node: ::treesitter_types::tree_sitter::Node<'tree>,
464 src: &'tree [u8],
465 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
466 debug_assert_eq!(node.kind(), "table_array_element");
467 Ok(Self {
468 span: ::treesitter_types::Span::from(node),
469 children: {
470 #[allow(clippy::suspicious_else_formatting)]
471 let non_field_children = {
472 let mut cursor = node.walk();
473 let mut result = ::std::vec::Vec::new();
474 if cursor.goto_first_child() {
475 loop {
476 if cursor.field_name().is_none()
477 && cursor.node().is_named()
478 && !cursor.node().is_extra()
479 {
480 result.push(cursor.node());
481 }
482 if !cursor.goto_next_sibling() {
483 break;
484 }
485 }
486 }
487 result
488 };
489 let mut items = ::std::vec::Vec::new();
490 for child in non_field_children {
491 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
492 <TableArrayElementChildren as ::treesitter_types::FromNode>::from_node(
493 child, src,
494 )
495 })?);
496 }
497 items
498 },
499 })
500 }
501}
502impl ::treesitter_types::Spanned for TableArrayElement<'_> {
503 fn span(&self) -> ::treesitter_types::Span {
504 self.span
505 }
506}
507#[derive(Debug, Clone, PartialEq, Eq)]
508pub struct BareKey<'tree> {
509 pub span: ::treesitter_types::Span,
510 text: &'tree str,
511}
512impl<'tree> ::treesitter_types::FromNode<'tree> for BareKey<'tree> {
513 fn from_node(
514 node: ::treesitter_types::tree_sitter::Node<'tree>,
515 src: &'tree [u8],
516 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
517 debug_assert_eq!(node.kind(), "bare_key");
518 Ok(Self {
519 span: ::treesitter_types::Span::from(node),
520 text: node.utf8_text(src)?,
521 })
522 }
523}
524impl<'tree> ::treesitter_types::LeafNode<'tree> for BareKey<'tree> {
525 fn text(&self) -> &'tree str {
526 self.text
527 }
528}
529impl ::treesitter_types::Spanned for BareKey<'_> {
530 fn span(&self) -> ::treesitter_types::Span {
531 self.span
532 }
533}
534#[derive(Debug, Clone, PartialEq, Eq)]
535pub struct Boolean<'tree> {
536 pub span: ::treesitter_types::Span,
537 text: &'tree str,
538}
539impl<'tree> ::treesitter_types::FromNode<'tree> for Boolean<'tree> {
540 fn from_node(
541 node: ::treesitter_types::tree_sitter::Node<'tree>,
542 src: &'tree [u8],
543 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
544 debug_assert_eq!(node.kind(), "boolean");
545 Ok(Self {
546 span: ::treesitter_types::Span::from(node),
547 text: node.utf8_text(src)?,
548 })
549 }
550}
551impl<'tree> ::treesitter_types::LeafNode<'tree> for Boolean<'tree> {
552 fn text(&self) -> &'tree str {
553 self.text
554 }
555}
556impl ::treesitter_types::Spanned for Boolean<'_> {
557 fn span(&self) -> ::treesitter_types::Span {
558 self.span
559 }
560}
561#[derive(Debug, Clone, PartialEq, Eq)]
562pub struct Comment<'tree> {
563 pub span: ::treesitter_types::Span,
564 text: &'tree str,
565}
566impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
567 fn from_node(
568 node: ::treesitter_types::tree_sitter::Node<'tree>,
569 src: &'tree [u8],
570 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
571 debug_assert_eq!(node.kind(), "comment");
572 Ok(Self {
573 span: ::treesitter_types::Span::from(node),
574 text: node.utf8_text(src)?,
575 })
576 }
577}
578impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
579 fn text(&self) -> &'tree str {
580 self.text
581 }
582}
583impl ::treesitter_types::Spanned for Comment<'_> {
584 fn span(&self) -> ::treesitter_types::Span {
585 self.span
586 }
587}
588#[derive(Debug, Clone, PartialEq, Eq)]
589pub struct EscapeSequence<'tree> {
590 pub span: ::treesitter_types::Span,
591 text: &'tree str,
592}
593impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
594 fn from_node(
595 node: ::treesitter_types::tree_sitter::Node<'tree>,
596 src: &'tree [u8],
597 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
598 debug_assert_eq!(node.kind(), "escape_sequence");
599 Ok(Self {
600 span: ::treesitter_types::Span::from(node),
601 text: node.utf8_text(src)?,
602 })
603 }
604}
605impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
606 fn text(&self) -> &'tree str {
607 self.text
608 }
609}
610impl ::treesitter_types::Spanned for EscapeSequence<'_> {
611 fn span(&self) -> ::treesitter_types::Span {
612 self.span
613 }
614}
615#[derive(Debug, Clone, PartialEq, Eq)]
616pub struct LocalDate<'tree> {
617 pub span: ::treesitter_types::Span,
618 text: &'tree str,
619}
620impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDate<'tree> {
621 fn from_node(
622 node: ::treesitter_types::tree_sitter::Node<'tree>,
623 src: &'tree [u8],
624 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
625 debug_assert_eq!(node.kind(), "local_date");
626 Ok(Self {
627 span: ::treesitter_types::Span::from(node),
628 text: node.utf8_text(src)?,
629 })
630 }
631}
632impl<'tree> ::treesitter_types::LeafNode<'tree> for LocalDate<'tree> {
633 fn text(&self) -> &'tree str {
634 self.text
635 }
636}
637impl ::treesitter_types::Spanned for LocalDate<'_> {
638 fn span(&self) -> ::treesitter_types::Span {
639 self.span
640 }
641}
642#[derive(Debug, Clone, PartialEq, Eq)]
643pub struct LocalDateTime<'tree> {
644 pub span: ::treesitter_types::Span,
645 text: &'tree str,
646}
647impl<'tree> ::treesitter_types::FromNode<'tree> for LocalDateTime<'tree> {
648 fn from_node(
649 node: ::treesitter_types::tree_sitter::Node<'tree>,
650 src: &'tree [u8],
651 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
652 debug_assert_eq!(node.kind(), "local_date_time");
653 Ok(Self {
654 span: ::treesitter_types::Span::from(node),
655 text: node.utf8_text(src)?,
656 })
657 }
658}
659impl<'tree> ::treesitter_types::LeafNode<'tree> for LocalDateTime<'tree> {
660 fn text(&self) -> &'tree str {
661 self.text
662 }
663}
664impl ::treesitter_types::Spanned for LocalDateTime<'_> {
665 fn span(&self) -> ::treesitter_types::Span {
666 self.span
667 }
668}
669#[derive(Debug, Clone, PartialEq, Eq)]
670pub struct LocalTime<'tree> {
671 pub span: ::treesitter_types::Span,
672 text: &'tree str,
673}
674impl<'tree> ::treesitter_types::FromNode<'tree> for LocalTime<'tree> {
675 fn from_node(
676 node: ::treesitter_types::tree_sitter::Node<'tree>,
677 src: &'tree [u8],
678 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
679 debug_assert_eq!(node.kind(), "local_time");
680 Ok(Self {
681 span: ::treesitter_types::Span::from(node),
682 text: node.utf8_text(src)?,
683 })
684 }
685}
686impl<'tree> ::treesitter_types::LeafNode<'tree> for LocalTime<'tree> {
687 fn text(&self) -> &'tree str {
688 self.text
689 }
690}
691impl ::treesitter_types::Spanned for LocalTime<'_> {
692 fn span(&self) -> ::treesitter_types::Span {
693 self.span
694 }
695}
696#[derive(Debug, Clone, PartialEq, Eq)]
697pub struct OffsetDateTime<'tree> {
698 pub span: ::treesitter_types::Span,
699 text: &'tree str,
700}
701impl<'tree> ::treesitter_types::FromNode<'tree> for OffsetDateTime<'tree> {
702 fn from_node(
703 node: ::treesitter_types::tree_sitter::Node<'tree>,
704 src: &'tree [u8],
705 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
706 debug_assert_eq!(node.kind(), "offset_date_time");
707 Ok(Self {
708 span: ::treesitter_types::Span::from(node),
709 text: node.utf8_text(src)?,
710 })
711 }
712}
713impl<'tree> ::treesitter_types::LeafNode<'tree> for OffsetDateTime<'tree> {
714 fn text(&self) -> &'tree str {
715 self.text
716 }
717}
718impl ::treesitter_types::Spanned for OffsetDateTime<'_> {
719 fn span(&self) -> ::treesitter_types::Span {
720 self.span
721 }
722}
723#[derive(Debug, Clone, PartialEq, Eq)]
724pub enum ArrayChildren<'tree> {
725 Array(::std::boxed::Box<Array<'tree>>),
726 Boolean(::std::boxed::Box<Boolean<'tree>>),
727 Float(::std::boxed::Box<Float<'tree>>),
728 InlineTable(::std::boxed::Box<InlineTable<'tree>>),
729 Integer(::std::boxed::Box<Integer<'tree>>),
730 LocalDate(::std::boxed::Box<LocalDate<'tree>>),
731 LocalDateTime(::std::boxed::Box<LocalDateTime<'tree>>),
732 LocalTime(::std::boxed::Box<LocalTime<'tree>>),
733 OffsetDateTime(::std::boxed::Box<OffsetDateTime<'tree>>),
734 String(::std::boxed::Box<String<'tree>>),
735}
736impl<'tree> ::treesitter_types::FromNode<'tree> for ArrayChildren<'tree> {
737 #[allow(clippy::collapsible_else_if)]
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 match node.kind() {
743 "array" => Ok(Self::Array(::std::boxed::Box::new(
744 ::treesitter_types::runtime::maybe_grow_stack(|| {
745 <Array as ::treesitter_types::FromNode>::from_node(node, src)
746 })?,
747 ))),
748 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
749 ::treesitter_types::runtime::maybe_grow_stack(|| {
750 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
751 })?,
752 ))),
753 "float" => Ok(Self::Float(::std::boxed::Box::new(
754 ::treesitter_types::runtime::maybe_grow_stack(|| {
755 <Float as ::treesitter_types::FromNode>::from_node(node, src)
756 })?,
757 ))),
758 "inline_table" => Ok(Self::InlineTable(::std::boxed::Box::new(
759 ::treesitter_types::runtime::maybe_grow_stack(|| {
760 <InlineTable as ::treesitter_types::FromNode>::from_node(node, src)
761 })?,
762 ))),
763 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
764 ::treesitter_types::runtime::maybe_grow_stack(|| {
765 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
766 })?,
767 ))),
768 "local_date" => Ok(Self::LocalDate(::std::boxed::Box::new(
769 ::treesitter_types::runtime::maybe_grow_stack(|| {
770 <LocalDate as ::treesitter_types::FromNode>::from_node(node, src)
771 })?,
772 ))),
773 "local_date_time" => Ok(Self::LocalDateTime(::std::boxed::Box::new(
774 ::treesitter_types::runtime::maybe_grow_stack(|| {
775 <LocalDateTime as ::treesitter_types::FromNode>::from_node(node, src)
776 })?,
777 ))),
778 "local_time" => Ok(Self::LocalTime(::std::boxed::Box::new(
779 ::treesitter_types::runtime::maybe_grow_stack(|| {
780 <LocalTime as ::treesitter_types::FromNode>::from_node(node, src)
781 })?,
782 ))),
783 "offset_date_time" => Ok(Self::OffsetDateTime(::std::boxed::Box::new(
784 ::treesitter_types::runtime::maybe_grow_stack(|| {
785 <OffsetDateTime as ::treesitter_types::FromNode>::from_node(node, src)
786 })?,
787 ))),
788 "string" => Ok(Self::String(::std::boxed::Box::new(
789 ::treesitter_types::runtime::maybe_grow_stack(|| {
790 <String as ::treesitter_types::FromNode>::from_node(node, src)
791 })?,
792 ))),
793 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
794 }
795 }
796}
797impl ::treesitter_types::Spanned for ArrayChildren<'_> {
798 fn span(&self) -> ::treesitter_types::Span {
799 match self {
800 Self::Array(inner) => inner.span(),
801 Self::Boolean(inner) => inner.span(),
802 Self::Float(inner) => inner.span(),
803 Self::InlineTable(inner) => inner.span(),
804 Self::Integer(inner) => inner.span(),
805 Self::LocalDate(inner) => inner.span(),
806 Self::LocalDateTime(inner) => inner.span(),
807 Self::LocalTime(inner) => inner.span(),
808 Self::OffsetDateTime(inner) => inner.span(),
809 Self::String(inner) => inner.span(),
810 }
811 }
812}
813#[derive(Debug, Clone, PartialEq, Eq)]
814pub enum DocumentChildren<'tree> {
815 Pair(::std::boxed::Box<Pair<'tree>>),
816 Table(::std::boxed::Box<Table<'tree>>),
817 TableArrayElement(::std::boxed::Box<TableArrayElement<'tree>>),
818}
819impl<'tree> ::treesitter_types::FromNode<'tree> for DocumentChildren<'tree> {
820 #[allow(clippy::collapsible_else_if)]
821 fn from_node(
822 node: ::treesitter_types::tree_sitter::Node<'tree>,
823 src: &'tree [u8],
824 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
825 match node.kind() {
826 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
827 ::treesitter_types::runtime::maybe_grow_stack(|| {
828 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
829 })?,
830 ))),
831 "table" => Ok(Self::Table(::std::boxed::Box::new(
832 ::treesitter_types::runtime::maybe_grow_stack(|| {
833 <Table as ::treesitter_types::FromNode>::from_node(node, src)
834 })?,
835 ))),
836 "table_array_element" => Ok(Self::TableArrayElement(::std::boxed::Box::new(
837 ::treesitter_types::runtime::maybe_grow_stack(|| {
838 <TableArrayElement as ::treesitter_types::FromNode>::from_node(node, src)
839 })?,
840 ))),
841 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
842 }
843 }
844}
845impl ::treesitter_types::Spanned for DocumentChildren<'_> {
846 fn span(&self) -> ::treesitter_types::Span {
847 match self {
848 Self::Pair(inner) => inner.span(),
849 Self::Table(inner) => inner.span(),
850 Self::TableArrayElement(inner) => inner.span(),
851 }
852 }
853}
854#[derive(Debug, Clone, PartialEq, Eq)]
855pub enum DottedKeyChildren<'tree> {
856 BareKey(::std::boxed::Box<BareKey<'tree>>),
857 DottedKey(::std::boxed::Box<DottedKey<'tree>>),
858 QuotedKey(::std::boxed::Box<QuotedKey<'tree>>),
859}
860impl<'tree> ::treesitter_types::FromNode<'tree> for DottedKeyChildren<'tree> {
861 #[allow(clippy::collapsible_else_if)]
862 fn from_node(
863 node: ::treesitter_types::tree_sitter::Node<'tree>,
864 src: &'tree [u8],
865 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
866 match node.kind() {
867 "bare_key" => Ok(Self::BareKey(::std::boxed::Box::new(
868 ::treesitter_types::runtime::maybe_grow_stack(|| {
869 <BareKey as ::treesitter_types::FromNode>::from_node(node, src)
870 })?,
871 ))),
872 "dotted_key" => Ok(Self::DottedKey(::std::boxed::Box::new(
873 ::treesitter_types::runtime::maybe_grow_stack(|| {
874 <DottedKey as ::treesitter_types::FromNode>::from_node(node, src)
875 })?,
876 ))),
877 "quoted_key" => Ok(Self::QuotedKey(::std::boxed::Box::new(
878 ::treesitter_types::runtime::maybe_grow_stack(|| {
879 <QuotedKey as ::treesitter_types::FromNode>::from_node(node, src)
880 })?,
881 ))),
882 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
883 }
884 }
885}
886impl ::treesitter_types::Spanned for DottedKeyChildren<'_> {
887 fn span(&self) -> ::treesitter_types::Span {
888 match self {
889 Self::BareKey(inner) => inner.span(),
890 Self::DottedKey(inner) => inner.span(),
891 Self::QuotedKey(inner) => inner.span(),
892 }
893 }
894}
895#[derive(Debug, Clone, PartialEq, Eq)]
896pub enum PairChildren<'tree> {
897 Array(::std::boxed::Box<Array<'tree>>),
898 BareKey(::std::boxed::Box<BareKey<'tree>>),
899 Boolean(::std::boxed::Box<Boolean<'tree>>),
900 DottedKey(::std::boxed::Box<DottedKey<'tree>>),
901 Float(::std::boxed::Box<Float<'tree>>),
902 InlineTable(::std::boxed::Box<InlineTable<'tree>>),
903 Integer(::std::boxed::Box<Integer<'tree>>),
904 LocalDate(::std::boxed::Box<LocalDate<'tree>>),
905 LocalDateTime(::std::boxed::Box<LocalDateTime<'tree>>),
906 LocalTime(::std::boxed::Box<LocalTime<'tree>>),
907 OffsetDateTime(::std::boxed::Box<OffsetDateTime<'tree>>),
908 QuotedKey(::std::boxed::Box<QuotedKey<'tree>>),
909 String(::std::boxed::Box<String<'tree>>),
910}
911impl<'tree> ::treesitter_types::FromNode<'tree> for PairChildren<'tree> {
912 #[allow(clippy::collapsible_else_if)]
913 fn from_node(
914 node: ::treesitter_types::tree_sitter::Node<'tree>,
915 src: &'tree [u8],
916 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
917 match node.kind() {
918 "array" => Ok(Self::Array(::std::boxed::Box::new(
919 ::treesitter_types::runtime::maybe_grow_stack(|| {
920 <Array as ::treesitter_types::FromNode>::from_node(node, src)
921 })?,
922 ))),
923 "bare_key" => Ok(Self::BareKey(::std::boxed::Box::new(
924 ::treesitter_types::runtime::maybe_grow_stack(|| {
925 <BareKey as ::treesitter_types::FromNode>::from_node(node, src)
926 })?,
927 ))),
928 "boolean" => Ok(Self::Boolean(::std::boxed::Box::new(
929 ::treesitter_types::runtime::maybe_grow_stack(|| {
930 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
931 })?,
932 ))),
933 "dotted_key" => Ok(Self::DottedKey(::std::boxed::Box::new(
934 ::treesitter_types::runtime::maybe_grow_stack(|| {
935 <DottedKey as ::treesitter_types::FromNode>::from_node(node, src)
936 })?,
937 ))),
938 "float" => Ok(Self::Float(::std::boxed::Box::new(
939 ::treesitter_types::runtime::maybe_grow_stack(|| {
940 <Float as ::treesitter_types::FromNode>::from_node(node, src)
941 })?,
942 ))),
943 "inline_table" => Ok(Self::InlineTable(::std::boxed::Box::new(
944 ::treesitter_types::runtime::maybe_grow_stack(|| {
945 <InlineTable as ::treesitter_types::FromNode>::from_node(node, src)
946 })?,
947 ))),
948 "integer" => Ok(Self::Integer(::std::boxed::Box::new(
949 ::treesitter_types::runtime::maybe_grow_stack(|| {
950 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
951 })?,
952 ))),
953 "local_date" => Ok(Self::LocalDate(::std::boxed::Box::new(
954 ::treesitter_types::runtime::maybe_grow_stack(|| {
955 <LocalDate as ::treesitter_types::FromNode>::from_node(node, src)
956 })?,
957 ))),
958 "local_date_time" => Ok(Self::LocalDateTime(::std::boxed::Box::new(
959 ::treesitter_types::runtime::maybe_grow_stack(|| {
960 <LocalDateTime as ::treesitter_types::FromNode>::from_node(node, src)
961 })?,
962 ))),
963 "local_time" => Ok(Self::LocalTime(::std::boxed::Box::new(
964 ::treesitter_types::runtime::maybe_grow_stack(|| {
965 <LocalTime as ::treesitter_types::FromNode>::from_node(node, src)
966 })?,
967 ))),
968 "offset_date_time" => Ok(Self::OffsetDateTime(::std::boxed::Box::new(
969 ::treesitter_types::runtime::maybe_grow_stack(|| {
970 <OffsetDateTime as ::treesitter_types::FromNode>::from_node(node, src)
971 })?,
972 ))),
973 "quoted_key" => Ok(Self::QuotedKey(::std::boxed::Box::new(
974 ::treesitter_types::runtime::maybe_grow_stack(|| {
975 <QuotedKey as ::treesitter_types::FromNode>::from_node(node, src)
976 })?,
977 ))),
978 "string" => Ok(Self::String(::std::boxed::Box::new(
979 ::treesitter_types::runtime::maybe_grow_stack(|| {
980 <String as ::treesitter_types::FromNode>::from_node(node, src)
981 })?,
982 ))),
983 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
984 }
985 }
986}
987impl ::treesitter_types::Spanned for PairChildren<'_> {
988 fn span(&self) -> ::treesitter_types::Span {
989 match self {
990 Self::Array(inner) => inner.span(),
991 Self::BareKey(inner) => inner.span(),
992 Self::Boolean(inner) => inner.span(),
993 Self::DottedKey(inner) => inner.span(),
994 Self::Float(inner) => inner.span(),
995 Self::InlineTable(inner) => inner.span(),
996 Self::Integer(inner) => inner.span(),
997 Self::LocalDate(inner) => inner.span(),
998 Self::LocalDateTime(inner) => inner.span(),
999 Self::LocalTime(inner) => inner.span(),
1000 Self::OffsetDateTime(inner) => inner.span(),
1001 Self::QuotedKey(inner) => inner.span(),
1002 Self::String(inner) => inner.span(),
1003 }
1004 }
1005}
1006#[derive(Debug, Clone, PartialEq, Eq)]
1007pub enum TableChildren<'tree> {
1008 BareKey(::std::boxed::Box<BareKey<'tree>>),
1009 DottedKey(::std::boxed::Box<DottedKey<'tree>>),
1010 Pair(::std::boxed::Box<Pair<'tree>>),
1011 QuotedKey(::std::boxed::Box<QuotedKey<'tree>>),
1012}
1013impl<'tree> ::treesitter_types::FromNode<'tree> for TableChildren<'tree> {
1014 #[allow(clippy::collapsible_else_if)]
1015 fn from_node(
1016 node: ::treesitter_types::tree_sitter::Node<'tree>,
1017 src: &'tree [u8],
1018 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1019 match node.kind() {
1020 "bare_key" => Ok(Self::BareKey(::std::boxed::Box::new(
1021 ::treesitter_types::runtime::maybe_grow_stack(|| {
1022 <BareKey as ::treesitter_types::FromNode>::from_node(node, src)
1023 })?,
1024 ))),
1025 "dotted_key" => Ok(Self::DottedKey(::std::boxed::Box::new(
1026 ::treesitter_types::runtime::maybe_grow_stack(|| {
1027 <DottedKey as ::treesitter_types::FromNode>::from_node(node, src)
1028 })?,
1029 ))),
1030 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
1031 ::treesitter_types::runtime::maybe_grow_stack(|| {
1032 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
1033 })?,
1034 ))),
1035 "quoted_key" => Ok(Self::QuotedKey(::std::boxed::Box::new(
1036 ::treesitter_types::runtime::maybe_grow_stack(|| {
1037 <QuotedKey as ::treesitter_types::FromNode>::from_node(node, src)
1038 })?,
1039 ))),
1040 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1041 }
1042 }
1043}
1044impl ::treesitter_types::Spanned for TableChildren<'_> {
1045 fn span(&self) -> ::treesitter_types::Span {
1046 match self {
1047 Self::BareKey(inner) => inner.span(),
1048 Self::DottedKey(inner) => inner.span(),
1049 Self::Pair(inner) => inner.span(),
1050 Self::QuotedKey(inner) => inner.span(),
1051 }
1052 }
1053}
1054#[derive(Debug, Clone, PartialEq, Eq)]
1055pub enum TableArrayElementChildren<'tree> {
1056 BareKey(::std::boxed::Box<BareKey<'tree>>),
1057 DottedKey(::std::boxed::Box<DottedKey<'tree>>),
1058 Pair(::std::boxed::Box<Pair<'tree>>),
1059 QuotedKey(::std::boxed::Box<QuotedKey<'tree>>),
1060}
1061impl<'tree> ::treesitter_types::FromNode<'tree> for TableArrayElementChildren<'tree> {
1062 #[allow(clippy::collapsible_else_if)]
1063 fn from_node(
1064 node: ::treesitter_types::tree_sitter::Node<'tree>,
1065 src: &'tree [u8],
1066 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
1067 match node.kind() {
1068 "bare_key" => Ok(Self::BareKey(::std::boxed::Box::new(
1069 ::treesitter_types::runtime::maybe_grow_stack(|| {
1070 <BareKey as ::treesitter_types::FromNode>::from_node(node, src)
1071 })?,
1072 ))),
1073 "dotted_key" => Ok(Self::DottedKey(::std::boxed::Box::new(
1074 ::treesitter_types::runtime::maybe_grow_stack(|| {
1075 <DottedKey as ::treesitter_types::FromNode>::from_node(node, src)
1076 })?,
1077 ))),
1078 "pair" => Ok(Self::Pair(::std::boxed::Box::new(
1079 ::treesitter_types::runtime::maybe_grow_stack(|| {
1080 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
1081 })?,
1082 ))),
1083 "quoted_key" => Ok(Self::QuotedKey(::std::boxed::Box::new(
1084 ::treesitter_types::runtime::maybe_grow_stack(|| {
1085 <QuotedKey as ::treesitter_types::FromNode>::from_node(node, src)
1086 })?,
1087 ))),
1088 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
1089 }
1090 }
1091}
1092impl ::treesitter_types::Spanned for TableArrayElementChildren<'_> {
1093 fn span(&self) -> ::treesitter_types::Span {
1094 match self {
1095 Self::BareKey(inner) => inner.span(),
1096 Self::DottedKey(inner) => inner.span(),
1097 Self::Pair(inner) => inner.span(),
1098 Self::QuotedKey(inner) => inner.span(),
1099 }
1100 }
1101}
1102#[derive(Debug, Clone, PartialEq, Eq)]
1103pub enum AnyNode<'tree> {
1104 Array(Array<'tree>),
1105 Document(Document<'tree>),
1106 DottedKey(DottedKey<'tree>),
1107 Float(Float<'tree>),
1108 InlineTable(InlineTable<'tree>),
1109 Integer(Integer<'tree>),
1110 Pair(Pair<'tree>),
1111 QuotedKey(QuotedKey<'tree>),
1112 String(String<'tree>),
1113 Table(Table<'tree>),
1114 TableArrayElement(TableArrayElement<'tree>),
1115 BareKey(BareKey<'tree>),
1116 Boolean(Boolean<'tree>),
1117 Comment(Comment<'tree>),
1118 EscapeSequence(EscapeSequence<'tree>),
1119 LocalDate(LocalDate<'tree>),
1120 LocalDateTime(LocalDateTime<'tree>),
1121 LocalTime(LocalTime<'tree>),
1122 OffsetDateTime(OffsetDateTime<'tree>),
1123 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
1124}
1125impl<'tree> AnyNode<'tree> {
1126 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
1127 match node.kind() {
1128 "array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1129 <Array as ::treesitter_types::FromNode>::from_node(node, src)
1130 })
1131 .map(Self::Array)
1132 .unwrap_or(Self::Unknown(node)),
1133 "document" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1134 <Document as ::treesitter_types::FromNode>::from_node(node, src)
1135 })
1136 .map(Self::Document)
1137 .unwrap_or(Self::Unknown(node)),
1138 "dotted_key" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1139 <DottedKey as ::treesitter_types::FromNode>::from_node(node, src)
1140 })
1141 .map(Self::DottedKey)
1142 .unwrap_or(Self::Unknown(node)),
1143 "float" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1144 <Float as ::treesitter_types::FromNode>::from_node(node, src)
1145 })
1146 .map(Self::Float)
1147 .unwrap_or(Self::Unknown(node)),
1148 "inline_table" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1149 <InlineTable as ::treesitter_types::FromNode>::from_node(node, src)
1150 })
1151 .map(Self::InlineTable)
1152 .unwrap_or(Self::Unknown(node)),
1153 "integer" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1154 <Integer as ::treesitter_types::FromNode>::from_node(node, src)
1155 })
1156 .map(Self::Integer)
1157 .unwrap_or(Self::Unknown(node)),
1158 "pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1159 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
1160 })
1161 .map(Self::Pair)
1162 .unwrap_or(Self::Unknown(node)),
1163 "quoted_key" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1164 <QuotedKey as ::treesitter_types::FromNode>::from_node(node, src)
1165 })
1166 .map(Self::QuotedKey)
1167 .unwrap_or(Self::Unknown(node)),
1168 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1169 <String as ::treesitter_types::FromNode>::from_node(node, src)
1170 })
1171 .map(Self::String)
1172 .unwrap_or(Self::Unknown(node)),
1173 "table" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1174 <Table as ::treesitter_types::FromNode>::from_node(node, src)
1175 })
1176 .map(Self::Table)
1177 .unwrap_or(Self::Unknown(node)),
1178 "table_array_element" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1179 <TableArrayElement as ::treesitter_types::FromNode>::from_node(node, src)
1180 })
1181 .map(Self::TableArrayElement)
1182 .unwrap_or(Self::Unknown(node)),
1183 "bare_key" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1184 <BareKey as ::treesitter_types::FromNode>::from_node(node, src)
1185 })
1186 .map(Self::BareKey)
1187 .unwrap_or(Self::Unknown(node)),
1188 "boolean" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1189 <Boolean as ::treesitter_types::FromNode>::from_node(node, src)
1190 })
1191 .map(Self::Boolean)
1192 .unwrap_or(Self::Unknown(node)),
1193 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1194 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
1195 })
1196 .map(Self::Comment)
1197 .unwrap_or(Self::Unknown(node)),
1198 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1199 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
1200 })
1201 .map(Self::EscapeSequence)
1202 .unwrap_or(Self::Unknown(node)),
1203 "local_date" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1204 <LocalDate as ::treesitter_types::FromNode>::from_node(node, src)
1205 })
1206 .map(Self::LocalDate)
1207 .unwrap_or(Self::Unknown(node)),
1208 "local_date_time" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1209 <LocalDateTime as ::treesitter_types::FromNode>::from_node(node, src)
1210 })
1211 .map(Self::LocalDateTime)
1212 .unwrap_or(Self::Unknown(node)),
1213 "local_time" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1214 <LocalTime as ::treesitter_types::FromNode>::from_node(node, src)
1215 })
1216 .map(Self::LocalTime)
1217 .unwrap_or(Self::Unknown(node)),
1218 "offset_date_time" => ::treesitter_types::runtime::maybe_grow_stack(|| {
1219 <OffsetDateTime as ::treesitter_types::FromNode>::from_node(node, src)
1220 })
1221 .map(Self::OffsetDateTime)
1222 .unwrap_or(Self::Unknown(node)),
1223 _ => Self::Unknown(node),
1224 }
1225 }
1226}
1227impl ::treesitter_types::Spanned for AnyNode<'_> {
1228 fn span(&self) -> ::treesitter_types::Span {
1229 match self {
1230 Self::Array(inner) => inner.span(),
1231 Self::Document(inner) => inner.span(),
1232 Self::DottedKey(inner) => inner.span(),
1233 Self::Float(inner) => inner.span(),
1234 Self::InlineTable(inner) => inner.span(),
1235 Self::Integer(inner) => inner.span(),
1236 Self::Pair(inner) => inner.span(),
1237 Self::QuotedKey(inner) => inner.span(),
1238 Self::String(inner) => inner.span(),
1239 Self::Table(inner) => inner.span(),
1240 Self::TableArrayElement(inner) => inner.span(),
1241 Self::BareKey(inner) => inner.span(),
1242 Self::Boolean(inner) => inner.span(),
1243 Self::Comment(inner) => inner.span(),
1244 Self::EscapeSequence(inner) => inner.span(),
1245 Self::LocalDate(inner) => inner.span(),
1246 Self::LocalDateTime(inner) => inner.span(),
1247 Self::LocalTime(inner) => inner.span(),
1248 Self::OffsetDateTime(inner) => inner.span(),
1249 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
1250 }
1251 }
1252}