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