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