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