1#[derive(Debug, Clone, PartialEq, Eq)]
2pub enum Value<'tree> {
3 Array(::std::boxed::Box<Array<'tree>>),
4 False(::std::boxed::Box<False<'tree>>),
5 Null(::std::boxed::Box<Null<'tree>>),
6 Number(::std::boxed::Box<Number<'tree>>),
7 Object(::std::boxed::Box<Object<'tree>>),
8 String(::std::boxed::Box<String<'tree>>),
9 True(::std::boxed::Box<True<'tree>>),
10}
11impl<'tree> ::treesitter_types::FromNode<'tree> for Value<'tree> {
12 #[allow(clippy::collapsible_else_if)]
13 fn from_node(
14 node: ::treesitter_types::tree_sitter::Node<'tree>,
15 src: &'tree [u8],
16 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
17 match node.kind() {
18 "array" => Ok(Self::Array(::std::boxed::Box::new(
19 ::treesitter_types::runtime::maybe_grow_stack(|| {
20 <Array as ::treesitter_types::FromNode>::from_node(node, src)
21 })?,
22 ))),
23 "false" => Ok(Self::False(::std::boxed::Box::new(
24 ::treesitter_types::runtime::maybe_grow_stack(|| {
25 <False as ::treesitter_types::FromNode>::from_node(node, src)
26 })?,
27 ))),
28 "null" => Ok(Self::Null(::std::boxed::Box::new(
29 ::treesitter_types::runtime::maybe_grow_stack(|| {
30 <Null as ::treesitter_types::FromNode>::from_node(node, src)
31 })?,
32 ))),
33 "number" => Ok(Self::Number(::std::boxed::Box::new(
34 ::treesitter_types::runtime::maybe_grow_stack(|| {
35 <Number as ::treesitter_types::FromNode>::from_node(node, src)
36 })?,
37 ))),
38 "object" => Ok(Self::Object(::std::boxed::Box::new(
39 ::treesitter_types::runtime::maybe_grow_stack(|| {
40 <Object as ::treesitter_types::FromNode>::from_node(node, src)
41 })?,
42 ))),
43 "string" => Ok(Self::String(::std::boxed::Box::new(
44 ::treesitter_types::runtime::maybe_grow_stack(|| {
45 <String as ::treesitter_types::FromNode>::from_node(node, src)
46 })?,
47 ))),
48 "true" => Ok(Self::True(::std::boxed::Box::new(
49 ::treesitter_types::runtime::maybe_grow_stack(|| {
50 <True as ::treesitter_types::FromNode>::from_node(node, src)
51 })?,
52 ))),
53 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
54 }
55 }
56}
57impl ::treesitter_types::Spanned for Value<'_> {
58 fn span(&self) -> ::treesitter_types::Span {
59 match self {
60 Self::Array(inner) => inner.span(),
61 Self::False(inner) => inner.span(),
62 Self::Null(inner) => inner.span(),
63 Self::Number(inner) => inner.span(),
64 Self::Object(inner) => inner.span(),
65 Self::String(inner) => inner.span(),
66 Self::True(inner) => inner.span(),
67 }
68 }
69}
70#[derive(Debug, Clone, PartialEq, Eq)]
71pub struct Array<'tree> {
72 pub span: ::treesitter_types::Span,
73 pub children: ::std::vec::Vec<Value<'tree>>,
74}
75impl<'tree> ::treesitter_types::FromNode<'tree> for Array<'tree> {
76 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
77 fn from_node(
78 node: ::treesitter_types::tree_sitter::Node<'tree>,
79 src: &'tree [u8],
80 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
81 debug_assert_eq!(node.kind(), "array");
82 Ok(Self {
83 span: ::treesitter_types::Span::from(node),
84 children: {
85 #[allow(clippy::suspicious_else_formatting)]
86 let non_field_children = {
87 let mut cursor = node.walk();
88 let mut result = ::std::vec::Vec::new();
89 if cursor.goto_first_child() {
90 loop {
91 if cursor.field_name().is_none()
92 && cursor.node().is_named()
93 && !cursor.node().is_extra()
94 {
95 result.push(cursor.node());
96 }
97 if !cursor.goto_next_sibling() {
98 break;
99 }
100 }
101 }
102 result
103 };
104 let mut items = ::std::vec::Vec::new();
105 for child in non_field_children {
106 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
107 <Value as ::treesitter_types::FromNode>::from_node(child, src)
108 })?);
109 }
110 items
111 },
112 })
113 }
114}
115impl ::treesitter_types::Spanned for Array<'_> {
116 fn span(&self) -> ::treesitter_types::Span {
117 self.span
118 }
119}
120#[derive(Debug, Clone, PartialEq, Eq)]
121pub struct Document<'tree> {
122 pub span: ::treesitter_types::Span,
123 pub children: ::std::vec::Vec<Value<'tree>>,
124}
125impl<'tree> ::treesitter_types::FromNode<'tree> for Document<'tree> {
126 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
127 fn from_node(
128 node: ::treesitter_types::tree_sitter::Node<'tree>,
129 src: &'tree [u8],
130 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
131 debug_assert_eq!(node.kind(), "document");
132 Ok(Self {
133 span: ::treesitter_types::Span::from(node),
134 children: {
135 #[allow(clippy::suspicious_else_formatting)]
136 let non_field_children = {
137 let mut cursor = node.walk();
138 let mut result = ::std::vec::Vec::new();
139 if cursor.goto_first_child() {
140 loop {
141 if cursor.field_name().is_none()
142 && cursor.node().is_named()
143 && !cursor.node().is_extra()
144 {
145 result.push(cursor.node());
146 }
147 if !cursor.goto_next_sibling() {
148 break;
149 }
150 }
151 }
152 result
153 };
154 let mut items = ::std::vec::Vec::new();
155 for child in non_field_children {
156 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
157 <Value as ::treesitter_types::FromNode>::from_node(child, src)
158 })?);
159 }
160 items
161 },
162 })
163 }
164}
165impl ::treesitter_types::Spanned for Document<'_> {
166 fn span(&self) -> ::treesitter_types::Span {
167 self.span
168 }
169}
170#[derive(Debug, Clone, PartialEq, Eq)]
171pub struct Object<'tree> {
172 pub span: ::treesitter_types::Span,
173 pub children: ::std::vec::Vec<Pair<'tree>>,
174}
175impl<'tree> ::treesitter_types::FromNode<'tree> for Object<'tree> {
176 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
177 fn from_node(
178 node: ::treesitter_types::tree_sitter::Node<'tree>,
179 src: &'tree [u8],
180 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
181 debug_assert_eq!(node.kind(), "object");
182 Ok(Self {
183 span: ::treesitter_types::Span::from(node),
184 children: {
185 #[allow(clippy::suspicious_else_formatting)]
186 let non_field_children = {
187 let mut cursor = node.walk();
188 let mut result = ::std::vec::Vec::new();
189 if cursor.goto_first_child() {
190 loop {
191 if cursor.field_name().is_none()
192 && cursor.node().is_named()
193 && !cursor.node().is_extra()
194 {
195 result.push(cursor.node());
196 }
197 if !cursor.goto_next_sibling() {
198 break;
199 }
200 }
201 }
202 result
203 };
204 let mut items = ::std::vec::Vec::new();
205 for child in non_field_children {
206 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
207 <Pair as ::treesitter_types::FromNode>::from_node(child, src)
208 })?);
209 }
210 items
211 },
212 })
213 }
214}
215impl ::treesitter_types::Spanned for Object<'_> {
216 fn span(&self) -> ::treesitter_types::Span {
217 self.span
218 }
219}
220#[derive(Debug, Clone, PartialEq, Eq)]
221pub struct Pair<'tree> {
222 pub span: ::treesitter_types::Span,
223 pub key: String<'tree>,
224 pub value: Value<'tree>,
225}
226impl<'tree> ::treesitter_types::FromNode<'tree> for Pair<'tree> {
227 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
228 fn from_node(
229 node: ::treesitter_types::tree_sitter::Node<'tree>,
230 src: &'tree [u8],
231 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
232 debug_assert_eq!(node.kind(), "pair");
233 Ok(Self {
234 span: ::treesitter_types::Span::from(node),
235 key: {
236 let child = node
237 .child_by_field_name("key")
238 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("key", node))?;
239 ::treesitter_types::runtime::maybe_grow_stack(|| {
240 <String as ::treesitter_types::FromNode>::from_node(child, src)
241 })?
242 },
243 value: {
244 let child = node
245 .child_by_field_name("value")
246 .ok_or_else(|| ::treesitter_types::ParseError::missing_field("value", node))?;
247 ::treesitter_types::runtime::maybe_grow_stack(|| {
248 <Value as ::treesitter_types::FromNode>::from_node(child, src)
249 })?
250 },
251 })
252 }
253}
254impl ::treesitter_types::Spanned for Pair<'_> {
255 fn span(&self) -> ::treesitter_types::Span {
256 self.span
257 }
258}
259#[derive(Debug, Clone, PartialEq, Eq)]
260pub struct String<'tree> {
261 pub span: ::treesitter_types::Span,
262 pub children: ::std::vec::Vec<StringChildren<'tree>>,
263}
264impl<'tree> ::treesitter_types::FromNode<'tree> for String<'tree> {
265 #[allow(clippy::match_single_binding, clippy::suspicious_else_formatting)]
266 fn from_node(
267 node: ::treesitter_types::tree_sitter::Node<'tree>,
268 src: &'tree [u8],
269 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
270 debug_assert_eq!(node.kind(), "string");
271 Ok(Self {
272 span: ::treesitter_types::Span::from(node),
273 children: {
274 #[allow(clippy::suspicious_else_formatting)]
275 let non_field_children = {
276 let mut cursor = node.walk();
277 let mut result = ::std::vec::Vec::new();
278 if cursor.goto_first_child() {
279 loop {
280 if cursor.field_name().is_none()
281 && cursor.node().is_named()
282 && !cursor.node().is_extra()
283 {
284 result.push(cursor.node());
285 }
286 if !cursor.goto_next_sibling() {
287 break;
288 }
289 }
290 }
291 result
292 };
293 let mut items = ::std::vec::Vec::new();
294 for child in non_field_children {
295 items.push(::treesitter_types::runtime::maybe_grow_stack(|| {
296 <StringChildren as ::treesitter_types::FromNode>::from_node(child, src)
297 })?);
298 }
299 items
300 },
301 })
302 }
303}
304impl ::treesitter_types::Spanned for String<'_> {
305 fn span(&self) -> ::treesitter_types::Span {
306 self.span
307 }
308}
309#[derive(Debug, Clone, PartialEq, Eq)]
310pub struct Comment<'tree> {
311 pub span: ::treesitter_types::Span,
312 text: &'tree str,
313}
314impl<'tree> ::treesitter_types::FromNode<'tree> for Comment<'tree> {
315 fn from_node(
316 node: ::treesitter_types::tree_sitter::Node<'tree>,
317 src: &'tree [u8],
318 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
319 debug_assert_eq!(node.kind(), "comment");
320 Ok(Self {
321 span: ::treesitter_types::Span::from(node),
322 text: node.utf8_text(src)?,
323 })
324 }
325}
326impl<'tree> ::treesitter_types::LeafNode<'tree> for Comment<'tree> {
327 fn text(&self) -> &'tree str {
328 self.text
329 }
330}
331impl ::treesitter_types::Spanned for Comment<'_> {
332 fn span(&self) -> ::treesitter_types::Span {
333 self.span
334 }
335}
336#[derive(Debug, Clone, PartialEq, Eq)]
337pub struct EscapeSequence<'tree> {
338 pub span: ::treesitter_types::Span,
339 text: &'tree str,
340}
341impl<'tree> ::treesitter_types::FromNode<'tree> for EscapeSequence<'tree> {
342 fn from_node(
343 node: ::treesitter_types::tree_sitter::Node<'tree>,
344 src: &'tree [u8],
345 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
346 debug_assert_eq!(node.kind(), "escape_sequence");
347 Ok(Self {
348 span: ::treesitter_types::Span::from(node),
349 text: node.utf8_text(src)?,
350 })
351 }
352}
353impl<'tree> ::treesitter_types::LeafNode<'tree> for EscapeSequence<'tree> {
354 fn text(&self) -> &'tree str {
355 self.text
356 }
357}
358impl ::treesitter_types::Spanned for EscapeSequence<'_> {
359 fn span(&self) -> ::treesitter_types::Span {
360 self.span
361 }
362}
363#[derive(Debug, Clone, PartialEq, Eq)]
364pub struct False<'tree> {
365 pub span: ::treesitter_types::Span,
366 text: &'tree str,
367}
368impl<'tree> ::treesitter_types::FromNode<'tree> for False<'tree> {
369 fn from_node(
370 node: ::treesitter_types::tree_sitter::Node<'tree>,
371 src: &'tree [u8],
372 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
373 debug_assert_eq!(node.kind(), "false");
374 Ok(Self {
375 span: ::treesitter_types::Span::from(node),
376 text: node.utf8_text(src)?,
377 })
378 }
379}
380impl<'tree> ::treesitter_types::LeafNode<'tree> for False<'tree> {
381 fn text(&self) -> &'tree str {
382 self.text
383 }
384}
385impl ::treesitter_types::Spanned for False<'_> {
386 fn span(&self) -> ::treesitter_types::Span {
387 self.span
388 }
389}
390#[derive(Debug, Clone, PartialEq, Eq)]
391pub struct Null<'tree> {
392 pub span: ::treesitter_types::Span,
393 text: &'tree str,
394}
395impl<'tree> ::treesitter_types::FromNode<'tree> for Null<'tree> {
396 fn from_node(
397 node: ::treesitter_types::tree_sitter::Node<'tree>,
398 src: &'tree [u8],
399 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
400 debug_assert_eq!(node.kind(), "null");
401 Ok(Self {
402 span: ::treesitter_types::Span::from(node),
403 text: node.utf8_text(src)?,
404 })
405 }
406}
407impl<'tree> ::treesitter_types::LeafNode<'tree> for Null<'tree> {
408 fn text(&self) -> &'tree str {
409 self.text
410 }
411}
412impl ::treesitter_types::Spanned for Null<'_> {
413 fn span(&self) -> ::treesitter_types::Span {
414 self.span
415 }
416}
417#[derive(Debug, Clone, PartialEq, Eq)]
418pub struct Number<'tree> {
419 pub span: ::treesitter_types::Span,
420 text: &'tree str,
421}
422impl<'tree> ::treesitter_types::FromNode<'tree> for Number<'tree> {
423 fn from_node(
424 node: ::treesitter_types::tree_sitter::Node<'tree>,
425 src: &'tree [u8],
426 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
427 debug_assert_eq!(node.kind(), "number");
428 Ok(Self {
429 span: ::treesitter_types::Span::from(node),
430 text: node.utf8_text(src)?,
431 })
432 }
433}
434impl<'tree> ::treesitter_types::LeafNode<'tree> for Number<'tree> {
435 fn text(&self) -> &'tree str {
436 self.text
437 }
438}
439impl ::treesitter_types::Spanned for Number<'_> {
440 fn span(&self) -> ::treesitter_types::Span {
441 self.span
442 }
443}
444#[derive(Debug, Clone, PartialEq, Eq)]
445pub struct StringContent<'tree> {
446 pub span: ::treesitter_types::Span,
447 text: &'tree str,
448}
449impl<'tree> ::treesitter_types::FromNode<'tree> for StringContent<'tree> {
450 fn from_node(
451 node: ::treesitter_types::tree_sitter::Node<'tree>,
452 src: &'tree [u8],
453 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
454 debug_assert_eq!(node.kind(), "string_content");
455 Ok(Self {
456 span: ::treesitter_types::Span::from(node),
457 text: node.utf8_text(src)?,
458 })
459 }
460}
461impl<'tree> ::treesitter_types::LeafNode<'tree> for StringContent<'tree> {
462 fn text(&self) -> &'tree str {
463 self.text
464 }
465}
466impl ::treesitter_types::Spanned for StringContent<'_> {
467 fn span(&self) -> ::treesitter_types::Span {
468 self.span
469 }
470}
471#[derive(Debug, Clone, PartialEq, Eq)]
472pub struct True<'tree> {
473 pub span: ::treesitter_types::Span,
474 text: &'tree str,
475}
476impl<'tree> ::treesitter_types::FromNode<'tree> for True<'tree> {
477 fn from_node(
478 node: ::treesitter_types::tree_sitter::Node<'tree>,
479 src: &'tree [u8],
480 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
481 debug_assert_eq!(node.kind(), "true");
482 Ok(Self {
483 span: ::treesitter_types::Span::from(node),
484 text: node.utf8_text(src)?,
485 })
486 }
487}
488impl<'tree> ::treesitter_types::LeafNode<'tree> for True<'tree> {
489 fn text(&self) -> &'tree str {
490 self.text
491 }
492}
493impl ::treesitter_types::Spanned for True<'_> {
494 fn span(&self) -> ::treesitter_types::Span {
495 self.span
496 }
497}
498#[derive(Debug, Clone, PartialEq, Eq)]
499pub enum StringChildren<'tree> {
500 EscapeSequence(::std::boxed::Box<EscapeSequence<'tree>>),
501 StringContent(::std::boxed::Box<StringContent<'tree>>),
502}
503impl<'tree> ::treesitter_types::FromNode<'tree> for StringChildren<'tree> {
504 #[allow(clippy::collapsible_else_if)]
505 fn from_node(
506 node: ::treesitter_types::tree_sitter::Node<'tree>,
507 src: &'tree [u8],
508 ) -> ::core::result::Result<Self, ::treesitter_types::ParseError> {
509 match node.kind() {
510 "escape_sequence" => Ok(Self::EscapeSequence(::std::boxed::Box::new(
511 ::treesitter_types::runtime::maybe_grow_stack(|| {
512 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
513 })?,
514 ))),
515 "string_content" => Ok(Self::StringContent(::std::boxed::Box::new(
516 ::treesitter_types::runtime::maybe_grow_stack(|| {
517 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
518 })?,
519 ))),
520 other => Err(::treesitter_types::ParseError::unexpected_kind(other, node)),
521 }
522 }
523}
524impl ::treesitter_types::Spanned for StringChildren<'_> {
525 fn span(&self) -> ::treesitter_types::Span {
526 match self {
527 Self::EscapeSequence(inner) => inner.span(),
528 Self::StringContent(inner) => inner.span(),
529 }
530 }
531}
532#[derive(Debug, Clone, PartialEq, Eq)]
533pub enum AnyNode<'tree> {
534 Value(Value<'tree>),
535 Array(Array<'tree>),
536 Document(Document<'tree>),
537 Object(Object<'tree>),
538 Pair(Pair<'tree>),
539 String(String<'tree>),
540 Comment(Comment<'tree>),
541 EscapeSequence(EscapeSequence<'tree>),
542 False(False<'tree>),
543 Null(Null<'tree>),
544 Number(Number<'tree>),
545 StringContent(StringContent<'tree>),
546 True(True<'tree>),
547 Unknown(::treesitter_types::tree_sitter::Node<'tree>),
548}
549impl<'tree> AnyNode<'tree> {
550 pub fn from_node(node: ::treesitter_types::tree_sitter::Node<'tree>, src: &'tree [u8]) -> Self {
551 match node.kind() {
552 "_value" => ::treesitter_types::runtime::maybe_grow_stack(|| {
553 <Value as ::treesitter_types::FromNode>::from_node(node, src)
554 })
555 .map(Self::Value)
556 .unwrap_or(Self::Unknown(node)),
557 "array" => ::treesitter_types::runtime::maybe_grow_stack(|| {
558 <Array as ::treesitter_types::FromNode>::from_node(node, src)
559 })
560 .map(Self::Array)
561 .unwrap_or(Self::Unknown(node)),
562 "document" => ::treesitter_types::runtime::maybe_grow_stack(|| {
563 <Document as ::treesitter_types::FromNode>::from_node(node, src)
564 })
565 .map(Self::Document)
566 .unwrap_or(Self::Unknown(node)),
567 "object" => ::treesitter_types::runtime::maybe_grow_stack(|| {
568 <Object as ::treesitter_types::FromNode>::from_node(node, src)
569 })
570 .map(Self::Object)
571 .unwrap_or(Self::Unknown(node)),
572 "pair" => ::treesitter_types::runtime::maybe_grow_stack(|| {
573 <Pair as ::treesitter_types::FromNode>::from_node(node, src)
574 })
575 .map(Self::Pair)
576 .unwrap_or(Self::Unknown(node)),
577 "string" => ::treesitter_types::runtime::maybe_grow_stack(|| {
578 <String as ::treesitter_types::FromNode>::from_node(node, src)
579 })
580 .map(Self::String)
581 .unwrap_or(Self::Unknown(node)),
582 "comment" => ::treesitter_types::runtime::maybe_grow_stack(|| {
583 <Comment as ::treesitter_types::FromNode>::from_node(node, src)
584 })
585 .map(Self::Comment)
586 .unwrap_or(Self::Unknown(node)),
587 "escape_sequence" => ::treesitter_types::runtime::maybe_grow_stack(|| {
588 <EscapeSequence as ::treesitter_types::FromNode>::from_node(node, src)
589 })
590 .map(Self::EscapeSequence)
591 .unwrap_or(Self::Unknown(node)),
592 "false" => ::treesitter_types::runtime::maybe_grow_stack(|| {
593 <False as ::treesitter_types::FromNode>::from_node(node, src)
594 })
595 .map(Self::False)
596 .unwrap_or(Self::Unknown(node)),
597 "null" => ::treesitter_types::runtime::maybe_grow_stack(|| {
598 <Null as ::treesitter_types::FromNode>::from_node(node, src)
599 })
600 .map(Self::Null)
601 .unwrap_or(Self::Unknown(node)),
602 "number" => ::treesitter_types::runtime::maybe_grow_stack(|| {
603 <Number as ::treesitter_types::FromNode>::from_node(node, src)
604 })
605 .map(Self::Number)
606 .unwrap_or(Self::Unknown(node)),
607 "string_content" => ::treesitter_types::runtime::maybe_grow_stack(|| {
608 <StringContent as ::treesitter_types::FromNode>::from_node(node, src)
609 })
610 .map(Self::StringContent)
611 .unwrap_or(Self::Unknown(node)),
612 "true" => ::treesitter_types::runtime::maybe_grow_stack(|| {
613 <True as ::treesitter_types::FromNode>::from_node(node, src)
614 })
615 .map(Self::True)
616 .unwrap_or(Self::Unknown(node)),
617 _ => Self::Unknown(node),
618 }
619 }
620}
621impl ::treesitter_types::Spanned for AnyNode<'_> {
622 fn span(&self) -> ::treesitter_types::Span {
623 match self {
624 Self::Value(inner) => inner.span(),
625 Self::Array(inner) => inner.span(),
626 Self::Document(inner) => inner.span(),
627 Self::Object(inner) => inner.span(),
628 Self::Pair(inner) => inner.span(),
629 Self::String(inner) => inner.span(),
630 Self::Comment(inner) => inner.span(),
631 Self::EscapeSequence(inner) => inner.span(),
632 Self::False(inner) => inner.span(),
633 Self::Null(inner) => inner.span(),
634 Self::Number(inner) => inner.span(),
635 Self::StringContent(inner) => inner.span(),
636 Self::True(inner) => inner.span(),
637 Self::Unknown(node) => ::treesitter_types::Span::from(*node),
638 }
639 }
640}