1#[derive(Debug, ::m2_syn::Spanned)]
4pub struct Symbol {
5 pub text: String,
6 span: ::m2_syn::Span,
7}
8impl Symbol {
9 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
10 Self {
11 text: text.into(),
12 span,
13 }
14 }
15}
16impl ::m2_syn::ToTokens for Symbol {
17 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
18 output.push_ident(::m2_syn::IdentToken::new(
19 &self.text,
20 ::m2_syn::Spanned::span(self),
21 ));
22 }
23}
24impl ::m2_syn::PrettyTree for Symbol {
25 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
26 ::m2_syn::PrettyNode::token(
27 stringify!(Symbol),
28 &self.text,
29 ::m2_syn::Spanned::span(self),
30 )
31 }
32}
33impl<N> ::m2_syn::Reconstruct<N> for Symbol
34where
35 N: ::m2_syn::ExternalCstNode,
36{
37 fn matches(node: &N) -> bool {
38 node.identity().matches("symbol", true)
39 }
40 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
41 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
42 return Err(::m2_syn::ReconstructError::wrong_node(
43 "symbol",
44 true,
45 node.identity(),
46 ));
47 }
48 Ok(Self::new(node.text(), node.span()))
49 }
50}
51#[derive(Debug, ::m2_syn::Spanned)]
52pub struct BlockComment {
53 pub text: String,
54 span: ::m2_syn::Span,
55}
56impl BlockComment {
57 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
58 Self {
59 text: text.into(),
60 span,
61 }
62 }
63}
64impl ::m2_syn::ToTokens for BlockComment {
65 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
66 output.push_trivia(::m2_syn::Trivia::new(
67 ::m2_syn::TriviaKind::BlockComment,
68 &self.text,
69 ::m2_syn::Spanned::span(self),
70 ));
71 }
72}
73impl ::m2_syn::PrettyTree for BlockComment {
74 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
75 ::m2_syn::PrettyNode::token(
76 stringify!(BlockComment),
77 &self.text,
78 ::m2_syn::Spanned::span(self),
79 )
80 }
81}
82impl<N> ::m2_syn::Reconstruct<N> for BlockComment
83where
84 N: ::m2_syn::ExternalCstNode,
85{
86 fn matches(node: &N) -> bool {
87 node.identity().matches("block_comment", true)
88 }
89 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
90 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
91 return Err(::m2_syn::ReconstructError::wrong_node(
92 "block_comment",
93 true,
94 node.identity(),
95 ));
96 }
97 Ok(Self::new(node.text(), node.span()))
98 }
99}
100#[derive(Debug, ::m2_syn::Spanned)]
101pub struct LineComment {
102 pub text: String,
103 span: ::m2_syn::Span,
104}
105impl LineComment {
106 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
107 Self {
108 text: text.into(),
109 span,
110 }
111 }
112}
113impl ::m2_syn::ToTokens for LineComment {
114 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
115 output.push_trivia(::m2_syn::Trivia::new(
116 ::m2_syn::TriviaKind::LineComment,
117 &self.text,
118 ::m2_syn::Spanned::span(self),
119 ));
120 }
121}
122impl ::m2_syn::PrettyTree for LineComment {
123 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
124 ::m2_syn::PrettyNode::token(
125 stringify!(LineComment),
126 &self.text,
127 ::m2_syn::Spanned::span(self),
128 )
129 }
130}
131impl<N> ::m2_syn::Reconstruct<N> for LineComment
132where
133 N: ::m2_syn::ExternalCstNode,
134{
135 fn matches(node: &N) -> bool {
136 node.identity().matches("line_comment", true)
137 }
138 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
139 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
140 return Err(::m2_syn::ReconstructError::wrong_node(
141 "line_comment",
142 true,
143 node.identity(),
144 ));
145 }
146 Ok(Self::new(node.text(), node.span()))
147 }
148}
149#[derive(Debug, ::m2_syn::Spanned)]
150pub struct EmptyComponent {
151 pub text: String,
152 span: ::m2_syn::Span,
153}
154impl EmptyComponent {
155 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
156 Self {
157 text: text.into(),
158 span,
159 }
160 }
161}
162impl ::m2_syn::ToTokens for EmptyComponent {
163 fn to_tokens(&self, _output: &mut ::m2_syn::TokenStream) {}
164}
165impl ::m2_syn::PrettyTree for EmptyComponent {
166 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
167 ::m2_syn::PrettyNode::token(
168 stringify!(EmptyComponent),
169 "∅",
170 ::m2_syn::Spanned::span(self),
171 )
172 }
173}
174impl<N> ::m2_syn::Reconstruct<N> for EmptyComponent
175where
176 N: ::m2_syn::ExternalCstNode,
177{
178 fn matches(node: &N) -> bool {
179 node.identity().matches("empty_component", true)
180 }
181 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
182 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
183 return Err(::m2_syn::ReconstructError::wrong_node(
184 "empty_component",
185 true,
186 node.identity(),
187 ));
188 }
189 Ok(Self::new(node.text(), node.span()))
190 }
191}
192#[derive(Debug, ::m2_syn::Spanned)]
193pub struct EscapeSequence {
194 pub text: String,
195 span: ::m2_syn::Span,
196}
197impl EscapeSequence {
198 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
199 Self {
200 text: text.into(),
201 span,
202 }
203 }
204}
205impl ::m2_syn::ToTokens for EscapeSequence {
206 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
207 output.push_ident(::m2_syn::IdentToken::new(
208 &self.text,
209 ::m2_syn::Spanned::span(self),
210 ));
211 }
212}
213impl ::m2_syn::PrettyTree for EscapeSequence {
214 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
215 ::m2_syn::PrettyNode::token(
216 stringify!(EscapeSequence),
217 &self.text,
218 ::m2_syn::Spanned::span(self),
219 )
220 }
221}
222impl<N> ::m2_syn::Reconstruct<N> for EscapeSequence
223where
224 N: ::m2_syn::ExternalCstNode,
225{
226 fn matches(node: &N) -> bool {
227 node.identity().matches("escape_sequence", true)
228 }
229 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
230 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
231 return Err(::m2_syn::ReconstructError::wrong_node(
232 "escape_sequence",
233 true,
234 node.identity(),
235 ));
236 }
237 Ok(Self::new(node.text(), node.span()))
238 }
239}
240#[derive(Debug, ::m2_syn::Spanned)]
241pub struct FloatLiteral {
242 pub text: String,
243 span: ::m2_syn::Span,
244}
245impl FloatLiteral {
246 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
247 Self {
248 text: text.into(),
249 span,
250 }
251 }
252}
253impl ::m2_syn::ToTokens for FloatLiteral {
254 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
255 output.push_literal(::m2_syn::Literal::new(
256 ::m2_syn::LiteralKind::Float,
257 self.text.clone(),
258 ::m2_syn::Spanned::span(self),
259 ));
260 }
261}
262impl ::m2_syn::PrettyTree for FloatLiteral {
263 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
264 ::m2_syn::PrettyNode::token(
265 stringify!(FloatLiteral),
266 &self.text,
267 ::m2_syn::Spanned::span(self),
268 )
269 }
270}
271impl<N> ::m2_syn::Reconstruct<N> for FloatLiteral
272where
273 N: ::m2_syn::ExternalCstNode,
274{
275 fn matches(node: &N) -> bool {
276 node.identity().matches("float_literal", true)
277 }
278 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
279 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
280 return Err(::m2_syn::ReconstructError::wrong_node(
281 "float_literal",
282 true,
283 node.identity(),
284 ));
285 }
286 Ok(Self::new(node.text(), node.span()))
287 }
288}
289#[derive(Debug, ::m2_syn::Spanned)]
290pub struct IntegerLiteral {
291 pub text: String,
292 span: ::m2_syn::Span,
293}
294impl IntegerLiteral {
295 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
296 Self {
297 text: text.into(),
298 span,
299 }
300 }
301}
302impl ::m2_syn::ToTokens for IntegerLiteral {
303 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
304 output.push_literal(::m2_syn::Literal::new(
305 ::m2_syn::LiteralKind::Integer,
306 self.text.clone(),
307 ::m2_syn::Spanned::span(self),
308 ));
309 }
310}
311impl ::m2_syn::PrettyTree for IntegerLiteral {
312 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
313 ::m2_syn::PrettyNode::token(
314 stringify!(IntegerLiteral),
315 &self.text,
316 ::m2_syn::Spanned::span(self),
317 )
318 }
319}
320impl<N> ::m2_syn::Reconstruct<N> for IntegerLiteral
321where
322 N: ::m2_syn::ExternalCstNode,
323{
324 fn matches(node: &N) -> bool {
325 node.identity().matches("integer_literal", true)
326 }
327 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
328 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
329 return Err(::m2_syn::ReconstructError::wrong_node(
330 "integer_literal",
331 true,
332 node.identity(),
333 ));
334 }
335 Ok(Self::new(node.text(), node.span()))
336 }
337}
338#[derive(Debug, ::m2_syn::Spanned)]
339pub struct RawStringContent {
340 pub text: String,
341 span: ::m2_syn::Span,
342}
343impl RawStringContent {
344 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
345 Self {
346 text: text.into(),
347 span,
348 }
349 }
350}
351impl ::m2_syn::ToTokens for RawStringContent {
352 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
353 output.push_ident(::m2_syn::IdentToken::new(
354 &self.text,
355 ::m2_syn::Spanned::span(self),
356 ));
357 }
358}
359impl ::m2_syn::PrettyTree for RawStringContent {
360 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
361 ::m2_syn::PrettyNode::token(
362 stringify!(RawStringContent),
363 &self.text,
364 ::m2_syn::Spanned::span(self),
365 )
366 }
367}
368impl<N> ::m2_syn::Reconstruct<N> for RawStringContent
369where
370 N: ::m2_syn::ExternalCstNode,
371{
372 fn matches(node: &N) -> bool {
373 node.identity().matches("raw_string_content", true)
374 }
375 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
376 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
377 return Err(::m2_syn::ReconstructError::wrong_node(
378 "raw_string_content",
379 true,
380 node.identity(),
381 ));
382 }
383 Ok(Self::new(node.text(), node.span()))
384 }
385}
386#[derive(Debug, ::m2_syn::Spanned)]
387pub struct StringContent {
388 pub text: String,
389 span: ::m2_syn::Span,
390}
391impl StringContent {
392 pub fn new(text: impl Into<String>, span: ::m2_syn::Span) -> Self {
393 Self {
394 text: text.into(),
395 span,
396 }
397 }
398}
399impl ::m2_syn::ToTokens for StringContent {
400 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
401 output.push_ident(::m2_syn::IdentToken::new(
402 &self.text,
403 ::m2_syn::Spanned::span(self),
404 ));
405 }
406}
407impl ::m2_syn::PrettyTree for StringContent {
408 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
409 ::m2_syn::PrettyNode::token(
410 stringify!(StringContent),
411 &self.text,
412 ::m2_syn::Spanned::span(self),
413 )
414 }
415}
416impl<N> ::m2_syn::Reconstruct<N> for StringContent
417where
418 N: ::m2_syn::ExternalCstNode,
419{
420 fn matches(node: &N) -> bool {
421 node.identity().matches("string_content", true)
422 }
423 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
424 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
425 return Err(::m2_syn::ReconstructError::wrong_node(
426 "string_content",
427 true,
428 node.identity(),
429 ));
430 }
431 Ok(Self::new(node.text(), node.span()))
432 }
433}
434#[derive(Debug, ::m2_syn::Spanned)]
435pub struct SourceFile {
436 pub elements: ::std::vec::Vec<AnyCell>,
437}
438impl SourceFile {
439 pub fn new(elements: ::std::vec::Vec<AnyCell>) -> Self {
440 Self { elements }
441 }
442}
443impl ::m2_syn::ToTokens for SourceFile {
444 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
445 let mut contents = ::m2_syn::TokenStream::new();
446 {
447 let mut field_output = ::m2_syn::TokenStream::new();
448 for (index, value) in self.elements.iter().enumerate() {
449 if index != 0 {
450 field_output.push_trivia(::m2_syn::Trivia::new(
451 ::m2_syn::TriviaKind::Whitespace,
452 "\n",
453 ::m2_syn::Span::detached(),
454 ));
455 }
456 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
457 }
458 if !field_output.is_empty() {
459 if !contents.is_empty()
460 && !contents.ends_with_whitespace()
461 && !field_output.starts_with_whitespace()
462 {
463 contents.push_trivia(::m2_syn::Trivia::new(
464 ::m2_syn::TriviaKind::Whitespace,
465 " ",
466 ::m2_syn::Span::detached(),
467 ));
468 }
469 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
470 }
471 }
472 ::m2_syn::ToTokens::to_tokens(&contents, output);
473 }
474}
475impl ::m2_syn::PrettyTree for SourceFile {
476 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
477 let mut node =
478 ::m2_syn::PrettyNode::syntax(stringify!(SourceFile), ::m2_syn::Spanned::span(self));
479 node.push("elements", &self.elements);
480 node
481 }
482}
483impl<N> ::m2_syn::Reconstruct<N> for SourceFile
484where
485 N: ::m2_syn::ExternalCstNode,
486{
487 fn matches(node: &N) -> bool {
488 node.identity().matches("source_file", true)
489 }
490 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
491 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
492 return Err(::m2_syn::ReconstructError::wrong_node(
493 "source_file",
494 true,
495 node.identity(),
496 ));
497 }
498 let mut children = ::m2_syn::ChildCursor::new(&node);
499 let elements = children
500 .repeated_matching::<AnyCell>()
501 .into_iter()
502 .map(|node| {
503 let value = <AnyCell as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
504 Ok::<_, ::m2_syn::ReconstructError>(value)
505 })
506 .collect::<Result<::std::vec::Vec<_>, _>>()?;
507 Ok(Self { elements })
508 }
509}
510#[derive(Debug, ::m2_syn::Spanned)]
511pub struct ExpressionCell {
512 pub value: ::std::boxed::Box<Expr>,
513}
514impl ExpressionCell {
515 pub fn new(value: Expr) -> Self {
516 {
517 let value = ::std::boxed::Box::new(value);
518 Self { value }
519 }
520 }
521}
522impl ::m2_syn::ToTokens for ExpressionCell {
523 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
524 let mut contents = ::m2_syn::TokenStream::new();
525 {
526 let mut field_output = ::m2_syn::TokenStream::new();
527 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
528 if !field_output.is_empty() {
529 if !contents.is_empty()
530 && !contents.ends_with_whitespace()
531 && !field_output.starts_with_whitespace()
532 {
533 contents.push_trivia(::m2_syn::Trivia::new(
534 ::m2_syn::TriviaKind::Whitespace,
535 " ",
536 ::m2_syn::Span::detached(),
537 ));
538 }
539 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
540 }
541 }
542 ::m2_syn::ToTokens::to_tokens(&contents, output);
543 }
544}
545impl ::m2_syn::PrettyTree for ExpressionCell {
546 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
547 let mut node =
548 ::m2_syn::PrettyNode::syntax(stringify!(ExpressionCell), ::m2_syn::Spanned::span(self));
549 node.push("value", &self.value);
550 node
551 }
552}
553impl<N> ::m2_syn::Reconstruct<N> for ExpressionCell
554where
555 N: ::m2_syn::ExternalCstNode,
556{
557 fn matches(node: &N) -> bool {
558 node.identity().matches("cell", true)
559 && node.children().any(|child| {
560 child.field.is_none() && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
561 })
562 }
563 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
564 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
565 return Err(::m2_syn::ReconstructError::wrong_node(
566 "cell",
567 true,
568 node.identity(),
569 ));
570 }
571 let mut children = ::m2_syn::ChildCursor::new(&node);
572 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
573 children.required_matching::<Expr>()?,
574 )?);
575 Ok(Self { value })
576 }
577}
578#[derive(Debug, ::m2_syn::Spanned)]
579pub struct SequenceCell {
580 pub value: ::std::boxed::Box<NakedSequence>,
581}
582impl SequenceCell {
583 pub fn new(value: NakedSequence) -> Self {
584 {
585 let value = ::std::boxed::Box::new(value);
586 Self { value }
587 }
588 }
589}
590impl ::m2_syn::ToTokens for SequenceCell {
591 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
592 let mut contents = ::m2_syn::TokenStream::new();
593 {
594 let mut field_output = ::m2_syn::TokenStream::new();
595 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
596 if !field_output.is_empty() {
597 if !contents.is_empty()
598 && !contents.ends_with_whitespace()
599 && !field_output.starts_with_whitespace()
600 {
601 contents.push_trivia(::m2_syn::Trivia::new(
602 ::m2_syn::TriviaKind::Whitespace,
603 " ",
604 ::m2_syn::Span::detached(),
605 ));
606 }
607 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
608 }
609 }
610 ::m2_syn::ToTokens::to_tokens(&contents, output);
611 }
612}
613impl ::m2_syn::PrettyTree for SequenceCell {
614 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
615 let mut node =
616 ::m2_syn::PrettyNode::syntax(stringify!(SequenceCell), ::m2_syn::Spanned::span(self));
617 node.push("value", &self.value);
618 node
619 }
620}
621impl<N> ::m2_syn::Reconstruct<N> for SequenceCell
622where
623 N: ::m2_syn::ExternalCstNode,
624{
625 fn matches(node: &N) -> bool {
626 node.identity().matches("cell", true)
627 && node.children().any(|child| {
628 child.field.is_none()
629 && <NakedSequence as ::m2_syn::Reconstruct<N>>::matches(&child.node)
630 })
631 }
632 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
633 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
634 return Err(::m2_syn::ReconstructError::wrong_node(
635 "cell",
636 true,
637 node.identity(),
638 ));
639 }
640 let mut children = ::m2_syn::ChildCursor::new(&node);
641 let value =
642 ::std::boxed::Box::new(<NakedSequence as ::m2_syn::Reconstruct<N>>::reconstruct(
643 children.required_matching::<NakedSequence>()?,
644 )?);
645 Ok(Self { value })
646 }
647}
648#[derive(Debug, ::m2_syn::Spanned)]
649pub struct NakedSequence {
650 pub elements: ::m2_syn::Punctuated<Component>,
651}
652impl NakedSequence {
653 pub fn new(elements: ::m2_syn::Punctuated<Component>) -> Self {
654 Self { elements }
655 }
656}
657impl ::m2_syn::ToTokens for NakedSequence {
658 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
659 let mut contents = ::m2_syn::TokenStream::new();
660 {
661 let mut field_output = ::m2_syn::TokenStream::new();
662 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
663 if !field_output.is_empty() {
664 if !contents.is_empty()
665 && !contents.ends_with_whitespace()
666 && !field_output.starts_with_whitespace()
667 {
668 contents.push_trivia(::m2_syn::Trivia::new(
669 ::m2_syn::TriviaKind::Whitespace,
670 " ",
671 ::m2_syn::Span::detached(),
672 ));
673 }
674 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
675 }
676 }
677 ::m2_syn::ToTokens::to_tokens(&contents, output);
678 }
679}
680impl ::m2_syn::PrettyTree for NakedSequence {
681 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
682 let mut node =
683 ::m2_syn::PrettyNode::syntax(stringify!(NakedSequence), ::m2_syn::Spanned::span(self));
684 node.push("elements", &self.elements);
685 node
686 }
687}
688impl<N> ::m2_syn::Reconstruct<N> for NakedSequence
689where
690 N: ::m2_syn::ExternalCstNode,
691{
692 fn matches(node: &N) -> bool {
693 node.identity().matches("naked_sequence", true)
694 }
695 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
696 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
697 return Err(::m2_syn::ReconstructError::wrong_node(
698 "naked_sequence",
699 true,
700 node.identity(),
701 ));
702 }
703 let mut children = ::m2_syn::ChildCursor::new(&node);
704 let elements = children
705 .repeated_matching::<Component>()
706 .into_iter()
707 .map(|node| {
708 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
709 Ok::<_, ::m2_syn::ReconstructError>(value)
710 })
711 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
712 Ok(Self { elements })
713 }
714}
715#[derive(Debug, ::m2_syn::Spanned)]
716pub struct MutedCell {
717 pub elements: ::m2_syn::Punctuated<Component>,
718 pub semicolon: Token![;],
719}
720impl MutedCell {
721 pub fn new(elements: ::m2_syn::Punctuated<Component>, semicolon: Token![;]) -> Self {
722 Self {
723 elements,
724 semicolon,
725 }
726 }
727}
728impl ::m2_syn::ToTokens for MutedCell {
729 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
730 let mut contents = ::m2_syn::TokenStream::new();
731 {
732 let mut field_output = ::m2_syn::TokenStream::new();
733 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
734 if !field_output.is_empty() {
735 if !contents.is_empty()
736 && !contents.ends_with_whitespace()
737 && !field_output.starts_with_whitespace()
738 {
739 contents.push_trivia(::m2_syn::Trivia::new(
740 ::m2_syn::TriviaKind::Whitespace,
741 " ",
742 ::m2_syn::Span::detached(),
743 ));
744 }
745 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
746 }
747 }
748 {
749 let mut field_output = ::m2_syn::TokenStream::new();
750 ::m2_syn::ToTokens::to_tokens(&self.semicolon, &mut field_output);
751 if !field_output.is_empty() {
752 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
753 }
754 }
755 ::m2_syn::ToTokens::to_tokens(&contents, output);
756 }
757}
758impl ::m2_syn::PrettyTree for MutedCell {
759 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
760 let mut node =
761 ::m2_syn::PrettyNode::syntax(stringify!(MutedCell), ::m2_syn::Spanned::span(self));
762 node.push("elements", &self.elements);
763 node.push("semicolon", &self.semicolon);
764 node
765 }
766}
767impl<N> ::m2_syn::Reconstruct<N> for MutedCell
768where
769 N: ::m2_syn::ExternalCstNode,
770{
771 fn matches(node: &N) -> bool {
772 node.identity().matches("muted", true)
773 && node.children().any(|child| {
774 child.field.is_none()
775 && <Token![;] as ::m2_syn::Reconstruct<N>>::matches(&child.node)
776 })
777 }
778 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
779 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
780 return Err(::m2_syn::ReconstructError::wrong_node(
781 "muted",
782 true,
783 node.identity(),
784 ));
785 }
786 let mut children = ::m2_syn::ChildCursor::new(&node);
787 let elements = children
788 .repeated_matching::<Component>()
789 .into_iter()
790 .map(|node| {
791 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
792 Ok::<_, ::m2_syn::ReconstructError>(value)
793 })
794 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
795 let semicolon = <Token![;] as ::m2_syn::Reconstruct<N>>::reconstruct(
796 children.required_matching::<Token![;]>()?,
797 )?;
798 Ok(Self {
799 elements,
800 semicolon,
801 })
802 }
803}
804#[derive(Debug, ::m2_syn::Spanned)]
805pub struct MutedGroup {
806 pub elements: ::m2_syn::Punctuated<Component>,
807 pub semicolon: Token![;],
808}
809impl MutedGroup {
810 pub fn new(elements: ::m2_syn::Punctuated<Component>, semicolon: Token![;]) -> Self {
811 Self {
812 elements,
813 semicolon,
814 }
815 }
816}
817impl ::m2_syn::ToTokens for MutedGroup {
818 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
819 let mut contents = ::m2_syn::TokenStream::new();
820 {
821 let mut field_output = ::m2_syn::TokenStream::new();
822 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
823 if !field_output.is_empty() {
824 if !contents.is_empty()
825 && !contents.ends_with_whitespace()
826 && !field_output.starts_with_whitespace()
827 {
828 contents.push_trivia(::m2_syn::Trivia::new(
829 ::m2_syn::TriviaKind::Whitespace,
830 " ",
831 ::m2_syn::Span::detached(),
832 ));
833 }
834 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
835 }
836 }
837 {
838 let mut field_output = ::m2_syn::TokenStream::new();
839 ::m2_syn::ToTokens::to_tokens(&self.semicolon, &mut field_output);
840 if !field_output.is_empty() {
841 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
842 }
843 }
844 ::m2_syn::ToTokens::to_tokens(&contents, output);
845 }
846}
847impl ::m2_syn::PrettyTree for MutedGroup {
848 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
849 let mut node =
850 ::m2_syn::PrettyNode::syntax(stringify!(MutedGroup), ::m2_syn::Spanned::span(self));
851 node.push("elements", &self.elements);
852 node.push("semicolon", &self.semicolon);
853 node
854 }
855}
856impl<N> ::m2_syn::Reconstruct<N> for MutedGroup
857where
858 N: ::m2_syn::ExternalCstNode,
859{
860 fn matches(node: &N) -> bool {
861 node.identity().matches("muted", true)
862 && node.children().any(|child| {
863 child.field.is_none()
864 && <Token![;] as ::m2_syn::Reconstruct<N>>::matches(&child.node)
865 })
866 }
867 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
868 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
869 return Err(::m2_syn::ReconstructError::wrong_node(
870 "muted",
871 true,
872 node.identity(),
873 ));
874 }
875 let mut children = ::m2_syn::ChildCursor::new(&node);
876 let elements = children
877 .repeated_matching::<Component>()
878 .into_iter()
879 .map(|node| {
880 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
881 Ok::<_, ::m2_syn::ReconstructError>(value)
882 })
883 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
884 let semicolon = <Token![;] as ::m2_syn::Reconstruct<N>>::reconstruct(
885 children.required_matching::<Token![;]>()?,
886 )?;
887 Ok(Self {
888 elements,
889 semicolon,
890 })
891 }
892}
893#[derive(Debug, ::m2_syn::Spanned)]
894pub struct Array {
895 pub muted: ::std::vec::Vec<MutedGroup>,
896 pub elements: ::m2_syn::Punctuated<Component>,
897 pub delimiter: Delimiter![[]],
898}
899impl Array {
900 pub fn new(
901 muted: ::std::vec::Vec<MutedGroup>,
902 elements: ::m2_syn::Punctuated<Component>,
903 ) -> Self {
904 let span = ::m2_syn::Span::join_all([
905 ::m2_syn::Spanned::span(&muted),
906 ::m2_syn::Spanned::span(&elements),
907 ]);
908 {
909 let delimiter = <Delimiter![[]] as ::m2_syn::DelimiterToken>::new(span);
910 Self {
911 muted,
912 elements,
913 delimiter,
914 }
915 }
916 }
917}
918impl ::m2_syn::ToTokens for Array {
919 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
920 let mut contents = ::m2_syn::TokenStream::new();
921 {
922 let mut field_output = ::m2_syn::TokenStream::new();
923 for (index, value) in self.muted.iter().enumerate() {
924 if index != 0 {
925 field_output.push_trivia(::m2_syn::Trivia::new(
926 ::m2_syn::TriviaKind::Whitespace,
927 " ",
928 ::m2_syn::Span::detached(),
929 ));
930 }
931 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
932 }
933 if !field_output.is_empty() {
934 if !contents.is_empty()
935 && !contents.ends_with_whitespace()
936 && !field_output.starts_with_whitespace()
937 {
938 contents.push_trivia(::m2_syn::Trivia::new(
939 ::m2_syn::TriviaKind::Whitespace,
940 " ",
941 ::m2_syn::Span::detached(),
942 ));
943 }
944 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
945 }
946 }
947 {
948 let mut field_output = ::m2_syn::TokenStream::new();
949 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
950 if !field_output.is_empty() {
951 if !contents.is_empty()
952 && !contents.ends_with_whitespace()
953 && !field_output.starts_with_whitespace()
954 {
955 contents.push_trivia(::m2_syn::Trivia::new(
956 ::m2_syn::TriviaKind::Whitespace,
957 " ",
958 ::m2_syn::Span::detached(),
959 ));
960 }
961 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
962 }
963 }
964 ::m2_syn::DelimiterToken::surround(&self.delimiter, output, contents);
965 }
966}
967impl ::m2_syn::PrettyTree for Array {
968 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
969 let mut node =
970 ::m2_syn::PrettyNode::syntax(stringify!(Array), ::m2_syn::Spanned::span(self));
971 node.push("muted", &self.muted);
972 node.push("elements", &self.elements);
973 node.push("delimiter", self.delimiter);
974 node
975 }
976}
977impl<N> ::m2_syn::Reconstruct<N> for Array
978where
979 N: ::m2_syn::ExternalCstNode,
980{
981 fn matches(node: &N) -> bool {
982 node.identity().matches("array", true)
983 }
984 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
985 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
986 return Err(::m2_syn::ReconstructError::wrong_node(
987 "array",
988 true,
989 node.identity(),
990 ));
991 }
992 let span = node.span();
993 let mut children = ::m2_syn::ChildCursor::new(&node);
994 let muted = children
995 .repeated_matching::<MutedGroup>()
996 .into_iter()
997 .map(|node| {
998 let value = <MutedGroup as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
999 Ok::<_, ::m2_syn::ReconstructError>(value)
1000 })
1001 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1002 let elements = children
1003 .repeated_matching::<Component>()
1004 .into_iter()
1005 .map(|node| {
1006 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1007 Ok::<_, ::m2_syn::ReconstructError>(value)
1008 })
1009 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
1010 Ok({
1011 let delimiter = <Delimiter![[]] as ::m2_syn::DelimiterToken>::new(span);
1012 Self {
1013 muted,
1014 elements,
1015 delimiter,
1016 }
1017 })
1018 }
1019}
1020#[derive(Debug, ::m2_syn::Spanned)]
1021pub struct List {
1022 pub muted: ::std::vec::Vec<MutedGroup>,
1023 pub elements: ::m2_syn::Punctuated<Component>,
1024 pub delimiter: Delimiter![{}],
1025}
1026impl List {
1027 pub fn new(
1028 muted: ::std::vec::Vec<MutedGroup>,
1029 elements: ::m2_syn::Punctuated<Component>,
1030 ) -> Self {
1031 let span = ::m2_syn::Span::join_all([
1032 ::m2_syn::Spanned::span(&muted),
1033 ::m2_syn::Spanned::span(&elements),
1034 ]);
1035 {
1036 let delimiter = <Delimiter![{}] as ::m2_syn::DelimiterToken>::new(span);
1037 Self {
1038 muted,
1039 elements,
1040 delimiter,
1041 }
1042 }
1043 }
1044}
1045impl ::m2_syn::ToTokens for List {
1046 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1047 let mut contents = ::m2_syn::TokenStream::new();
1048 {
1049 let mut field_output = ::m2_syn::TokenStream::new();
1050 for (index, value) in self.muted.iter().enumerate() {
1051 if index != 0 {
1052 field_output.push_trivia(::m2_syn::Trivia::new(
1053 ::m2_syn::TriviaKind::Whitespace,
1054 " ",
1055 ::m2_syn::Span::detached(),
1056 ));
1057 }
1058 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1059 }
1060 if !field_output.is_empty() {
1061 if !contents.is_empty()
1062 && !contents.ends_with_whitespace()
1063 && !field_output.starts_with_whitespace()
1064 {
1065 contents.push_trivia(::m2_syn::Trivia::new(
1066 ::m2_syn::TriviaKind::Whitespace,
1067 " ",
1068 ::m2_syn::Span::detached(),
1069 ));
1070 }
1071 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1072 }
1073 }
1074 {
1075 let mut field_output = ::m2_syn::TokenStream::new();
1076 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
1077 if !field_output.is_empty() {
1078 if !contents.is_empty()
1079 && !contents.ends_with_whitespace()
1080 && !field_output.starts_with_whitespace()
1081 {
1082 contents.push_trivia(::m2_syn::Trivia::new(
1083 ::m2_syn::TriviaKind::Whitespace,
1084 " ",
1085 ::m2_syn::Span::detached(),
1086 ));
1087 }
1088 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1089 }
1090 }
1091 ::m2_syn::DelimiterToken::surround(&self.delimiter, output, contents);
1092 }
1093}
1094impl ::m2_syn::PrettyTree for List {
1095 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1096 let mut node =
1097 ::m2_syn::PrettyNode::syntax(stringify!(List), ::m2_syn::Spanned::span(self));
1098 node.push("muted", &self.muted);
1099 node.push("elements", &self.elements);
1100 node.push("delimiter", self.delimiter);
1101 node
1102 }
1103}
1104impl<N> ::m2_syn::Reconstruct<N> for List
1105where
1106 N: ::m2_syn::ExternalCstNode,
1107{
1108 fn matches(node: &N) -> bool {
1109 node.identity().matches("list", true)
1110 }
1111 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1112 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1113 return Err(::m2_syn::ReconstructError::wrong_node(
1114 "list",
1115 true,
1116 node.identity(),
1117 ));
1118 }
1119 let span = node.span();
1120 let mut children = ::m2_syn::ChildCursor::new(&node);
1121 let muted = children
1122 .repeated_matching::<MutedGroup>()
1123 .into_iter()
1124 .map(|node| {
1125 let value = <MutedGroup as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1126 Ok::<_, ::m2_syn::ReconstructError>(value)
1127 })
1128 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1129 let elements = children
1130 .repeated_matching::<Component>()
1131 .into_iter()
1132 .map(|node| {
1133 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1134 Ok::<_, ::m2_syn::ReconstructError>(value)
1135 })
1136 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
1137 Ok({
1138 let delimiter = <Delimiter![{}] as ::m2_syn::DelimiterToken>::new(span);
1139 Self {
1140 muted,
1141 elements,
1142 delimiter,
1143 }
1144 })
1145 }
1146}
1147#[derive(Debug, ::m2_syn::Spanned)]
1148pub struct AngleBarList {
1149 pub muted: ::std::vec::Vec<MutedGroup>,
1150 pub elements: ::m2_syn::Punctuated<Component>,
1151 pub delimiter: Delimiter![<| |>],
1152}
1153impl AngleBarList {
1154 pub fn new(
1155 muted: ::std::vec::Vec<MutedGroup>,
1156 elements: ::m2_syn::Punctuated<Component>,
1157 ) -> Self {
1158 let span = ::m2_syn::Span::join_all([
1159 ::m2_syn::Spanned::span(&muted),
1160 ::m2_syn::Spanned::span(&elements),
1161 ]);
1162 {
1163 let delimiter = <Delimiter![<| |>] as ::m2_syn::DelimiterToken>::new(span);
1164 Self {
1165 muted,
1166 elements,
1167 delimiter,
1168 }
1169 }
1170 }
1171}
1172impl ::m2_syn::ToTokens for AngleBarList {
1173 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1174 let mut contents = ::m2_syn::TokenStream::new();
1175 {
1176 let mut field_output = ::m2_syn::TokenStream::new();
1177 for (index, value) in self.muted.iter().enumerate() {
1178 if index != 0 {
1179 field_output.push_trivia(::m2_syn::Trivia::new(
1180 ::m2_syn::TriviaKind::Whitespace,
1181 " ",
1182 ::m2_syn::Span::detached(),
1183 ));
1184 }
1185 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1186 }
1187 if !field_output.is_empty() {
1188 if !contents.is_empty()
1189 && !contents.ends_with_whitespace()
1190 && !field_output.starts_with_whitespace()
1191 {
1192 contents.push_trivia(::m2_syn::Trivia::new(
1193 ::m2_syn::TriviaKind::Whitespace,
1194 " ",
1195 ::m2_syn::Span::detached(),
1196 ));
1197 }
1198 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1199 }
1200 }
1201 {
1202 let mut field_output = ::m2_syn::TokenStream::new();
1203 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
1204 if !field_output.is_empty() {
1205 if !contents.is_empty()
1206 && !contents.ends_with_whitespace()
1207 && !field_output.starts_with_whitespace()
1208 {
1209 contents.push_trivia(::m2_syn::Trivia::new(
1210 ::m2_syn::TriviaKind::Whitespace,
1211 " ",
1212 ::m2_syn::Span::detached(),
1213 ));
1214 }
1215 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1216 }
1217 }
1218 ::m2_syn::DelimiterToken::surround(&self.delimiter, output, contents);
1219 }
1220}
1221impl ::m2_syn::PrettyTree for AngleBarList {
1222 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1223 let mut node =
1224 ::m2_syn::PrettyNode::syntax(stringify!(AngleBarList), ::m2_syn::Spanned::span(self));
1225 node.push("muted", &self.muted);
1226 node.push("elements", &self.elements);
1227 node.push("delimiter", self.delimiter);
1228 node
1229 }
1230}
1231impl<N> ::m2_syn::Reconstruct<N> for AngleBarList
1232where
1233 N: ::m2_syn::ExternalCstNode,
1234{
1235 fn matches(node: &N) -> bool {
1236 node.identity().matches("angle_bar_list", true)
1237 }
1238 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1239 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1240 return Err(::m2_syn::ReconstructError::wrong_node(
1241 "angle_bar_list",
1242 true,
1243 node.identity(),
1244 ));
1245 }
1246 let span = node.span();
1247 let mut children = ::m2_syn::ChildCursor::new(&node);
1248 let muted = children
1249 .repeated_matching::<MutedGroup>()
1250 .into_iter()
1251 .map(|node| {
1252 let value = <MutedGroup as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1253 Ok::<_, ::m2_syn::ReconstructError>(value)
1254 })
1255 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1256 let elements = children
1257 .repeated_matching::<Component>()
1258 .into_iter()
1259 .map(|node| {
1260 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1261 Ok::<_, ::m2_syn::ReconstructError>(value)
1262 })
1263 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
1264 Ok({
1265 let delimiter = <Delimiter![<| |>] as ::m2_syn::DelimiterToken>::new(span);
1266 Self {
1267 muted,
1268 elements,
1269 delimiter,
1270 }
1271 })
1272 }
1273}
1274#[derive(Debug, ::m2_syn::Spanned)]
1275pub struct Sequence {
1276 pub muted: ::std::vec::Vec<MutedGroup>,
1277 pub elements: ::m2_syn::Punctuated<Component>,
1278 pub delimiter: Delimiter![()],
1279}
1280impl Sequence {
1281 pub fn new(
1282 muted: ::std::vec::Vec<MutedGroup>,
1283 elements: ::m2_syn::Punctuated<Component>,
1284 ) -> Self {
1285 let span = ::m2_syn::Span::join_all([
1286 ::m2_syn::Spanned::span(&muted),
1287 ::m2_syn::Spanned::span(&elements),
1288 ]);
1289 {
1290 let delimiter = <Delimiter![()] as ::m2_syn::DelimiterToken>::new(span);
1291 Self {
1292 muted,
1293 elements,
1294 delimiter,
1295 }
1296 }
1297 }
1298}
1299impl ::m2_syn::ToTokens for Sequence {
1300 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1301 let mut contents = ::m2_syn::TokenStream::new();
1302 {
1303 let mut field_output = ::m2_syn::TokenStream::new();
1304 for (index, value) in self.muted.iter().enumerate() {
1305 if index != 0 {
1306 field_output.push_trivia(::m2_syn::Trivia::new(
1307 ::m2_syn::TriviaKind::Whitespace,
1308 " ",
1309 ::m2_syn::Span::detached(),
1310 ));
1311 }
1312 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1313 }
1314 if !field_output.is_empty() {
1315 if !contents.is_empty()
1316 && !contents.ends_with_whitespace()
1317 && !field_output.starts_with_whitespace()
1318 {
1319 contents.push_trivia(::m2_syn::Trivia::new(
1320 ::m2_syn::TriviaKind::Whitespace,
1321 " ",
1322 ::m2_syn::Span::detached(),
1323 ));
1324 }
1325 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1326 }
1327 }
1328 {
1329 let mut field_output = ::m2_syn::TokenStream::new();
1330 ::m2_syn::ToTokens::to_tokens(&self.elements, &mut field_output);
1331 if !field_output.is_empty() {
1332 if !contents.is_empty()
1333 && !contents.ends_with_whitespace()
1334 && !field_output.starts_with_whitespace()
1335 {
1336 contents.push_trivia(::m2_syn::Trivia::new(
1337 ::m2_syn::TriviaKind::Whitespace,
1338 " ",
1339 ::m2_syn::Span::detached(),
1340 ));
1341 }
1342 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1343 }
1344 }
1345 ::m2_syn::DelimiterToken::surround(&self.delimiter, output, contents);
1346 }
1347}
1348impl ::m2_syn::PrettyTree for Sequence {
1349 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1350 let mut node =
1351 ::m2_syn::PrettyNode::syntax(stringify!(Sequence), ::m2_syn::Spanned::span(self));
1352 node.push("muted", &self.muted);
1353 node.push("elements", &self.elements);
1354 node.push("delimiter", self.delimiter);
1355 node
1356 }
1357}
1358impl<N> ::m2_syn::Reconstruct<N> for Sequence
1359where
1360 N: ::m2_syn::ExternalCstNode,
1361{
1362 fn matches(node: &N) -> bool {
1363 node.identity().matches("sequence", true)
1364 }
1365 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1366 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1367 return Err(::m2_syn::ReconstructError::wrong_node(
1368 "sequence",
1369 true,
1370 node.identity(),
1371 ));
1372 }
1373 let span = node.span();
1374 let mut children = ::m2_syn::ChildCursor::new(&node);
1375 let muted = children
1376 .repeated_matching::<MutedGroup>()
1377 .into_iter()
1378 .map(|node| {
1379 let value = <MutedGroup as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1380 Ok::<_, ::m2_syn::ReconstructError>(value)
1381 })
1382 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1383 let elements = children
1384 .repeated_matching::<Component>()
1385 .into_iter()
1386 .map(|node| {
1387 let value = <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1388 Ok::<_, ::m2_syn::ReconstructError>(value)
1389 })
1390 .collect::<Result<::m2_syn::Punctuated<_>, _>>()?;
1391 Ok({
1392 let delimiter = <Delimiter![()] as ::m2_syn::DelimiterToken>::new(span);
1393 Self {
1394 muted,
1395 elements,
1396 delimiter,
1397 }
1398 })
1399 }
1400}
1401#[derive(Debug, ::m2_syn::Spanned)]
1402pub struct ParenthesizedExpression {
1403 pub muted: ::std::vec::Vec<MutedGroup>,
1404 pub value: ::std::option::Option<::std::boxed::Box<Expr>>,
1405 pub delimiter: Delimiter![()],
1406}
1407impl ParenthesizedExpression {
1408 pub fn new(muted: ::std::vec::Vec<MutedGroup>, value: ::std::option::Option<Expr>) -> Self {
1409 let span = ::m2_syn::Span::join_all([
1410 ::m2_syn::Spanned::span(&muted),
1411 ::m2_syn::Spanned::span(&value),
1412 ]);
1413 {
1414 let value = value.map(::std::boxed::Box::new);
1415 {
1416 let delimiter = <Delimiter![()] as ::m2_syn::DelimiterToken>::new(span);
1417 Self {
1418 muted,
1419 value,
1420 delimiter,
1421 }
1422 }
1423 }
1424 }
1425}
1426impl ::m2_syn::ToTokens for ParenthesizedExpression {
1427 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1428 let mut contents = ::m2_syn::TokenStream::new();
1429 {
1430 let mut field_output = ::m2_syn::TokenStream::new();
1431 for (index, value) in self.muted.iter().enumerate() {
1432 if index != 0 {
1433 field_output.push_trivia(::m2_syn::Trivia::new(
1434 ::m2_syn::TriviaKind::Whitespace,
1435 " ",
1436 ::m2_syn::Span::detached(),
1437 ));
1438 }
1439 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1440 }
1441 if !field_output.is_empty() {
1442 if !contents.is_empty()
1443 && !contents.ends_with_whitespace()
1444 && !field_output.starts_with_whitespace()
1445 {
1446 contents.push_trivia(::m2_syn::Trivia::new(
1447 ::m2_syn::TriviaKind::Whitespace,
1448 " ",
1449 ::m2_syn::Span::detached(),
1450 ));
1451 }
1452 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1453 }
1454 }
1455 {
1456 let mut field_output = ::m2_syn::TokenStream::new();
1457 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
1458 if !field_output.is_empty() {
1459 if !contents.is_empty()
1460 && !contents.ends_with_whitespace()
1461 && !field_output.starts_with_whitespace()
1462 {
1463 contents.push_trivia(::m2_syn::Trivia::new(
1464 ::m2_syn::TriviaKind::Whitespace,
1465 " ",
1466 ::m2_syn::Span::detached(),
1467 ));
1468 }
1469 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1470 }
1471 }
1472 ::m2_syn::DelimiterToken::surround(&self.delimiter, output, contents);
1473 }
1474}
1475impl ::m2_syn::PrettyTree for ParenthesizedExpression {
1476 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1477 let mut node = ::m2_syn::PrettyNode::syntax(
1478 stringify!(ParenthesizedExpression),
1479 ::m2_syn::Spanned::span(self),
1480 );
1481 node.push("muted", &self.muted);
1482 node.push("value", &self.value);
1483 node.push("delimiter", self.delimiter);
1484 node
1485 }
1486}
1487impl<N> ::m2_syn::Reconstruct<N> for ParenthesizedExpression
1488where
1489 N: ::m2_syn::ExternalCstNode,
1490{
1491 fn matches(node: &N) -> bool {
1492 node.identity().matches("parenthesized_expression", true)
1493 }
1494 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1495 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1496 return Err(::m2_syn::ReconstructError::wrong_node(
1497 "parenthesized_expression",
1498 true,
1499 node.identity(),
1500 ));
1501 }
1502 let span = node.span();
1503 let mut children = ::m2_syn::ChildCursor::new(&node);
1504 let muted = children
1505 .repeated_matching::<MutedGroup>()
1506 .into_iter()
1507 .map(|node| {
1508 let value = <MutedGroup as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1509 Ok::<_, ::m2_syn::ReconstructError>(value)
1510 })
1511 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1512 let value = children
1513 .optional_matching::<Expr>()
1514 .map(|node| {
1515 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1516 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
1517 })
1518 .transpose()?;
1519 Ok({
1520 let delimiter = <Delimiter![()] as ::m2_syn::DelimiterToken>::new(span);
1521 Self {
1522 muted,
1523 value,
1524 delimiter,
1525 }
1526 })
1527 }
1528}
1529#[derive(Debug, ::m2_syn::Spanned)]
1530pub struct StringLiteral {
1531 pub elements: ::std::vec::Vec<StringElement>,
1532}
1533impl StringLiteral {
1534 pub fn new(elements: ::std::vec::Vec<StringElement>) -> Self {
1535 Self { elements }
1536 }
1537}
1538impl ::m2_syn::ToTokens for StringLiteral {
1539 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1540 let mut contents = ::m2_syn::TokenStream::new();
1541 {
1542 let mut field_output = ::m2_syn::TokenStream::new();
1543 for value in &self.elements {
1544 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1545 }
1546 if !field_output.is_empty() {
1547 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1548 }
1549 }
1550 output.push_literal(::m2_syn::Literal::new(
1551 ::m2_syn::LiteralKind::String,
1552 ::std::format!("\"{}\"", contents),
1553 ::m2_syn::Spanned::span(self),
1554 ));
1555 }
1556}
1557impl ::m2_syn::PrettyTree for StringLiteral {
1558 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1559 let mut node =
1560 ::m2_syn::PrettyNode::syntax(stringify!(StringLiteral), ::m2_syn::Spanned::span(self));
1561 node.push("elements", &self.elements);
1562 node
1563 }
1564}
1565impl<N> ::m2_syn::Reconstruct<N> for StringLiteral
1566where
1567 N: ::m2_syn::ExternalCstNode,
1568{
1569 fn matches(node: &N) -> bool {
1570 node.identity().matches("string_literal", true)
1571 }
1572 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1573 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1574 return Err(::m2_syn::ReconstructError::wrong_node(
1575 "string_literal",
1576 true,
1577 node.identity(),
1578 ));
1579 }
1580 let mut children = ::m2_syn::ChildCursor::new(&node);
1581 let elements = children
1582 .repeated_matching::<StringElement>()
1583 .into_iter()
1584 .map(|node| {
1585 let value = <StringElement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1586 Ok::<_, ::m2_syn::ReconstructError>(value)
1587 })
1588 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1589 Ok(Self { elements })
1590 }
1591}
1592#[derive(Debug, ::m2_syn::Spanned)]
1593pub struct RawStringLiteral {
1594 pub elements: ::std::vec::Vec<RawStringElement>,
1595}
1596impl RawStringLiteral {
1597 pub fn new(elements: ::std::vec::Vec<RawStringElement>) -> Self {
1598 Self { elements }
1599 }
1600}
1601impl ::m2_syn::ToTokens for RawStringLiteral {
1602 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1603 let mut contents = ::m2_syn::TokenStream::new();
1604 {
1605 let mut field_output = ::m2_syn::TokenStream::new();
1606 for value in &self.elements {
1607 ::m2_syn::ToTokens::to_tokens(value, &mut field_output);
1608 }
1609 if !field_output.is_empty() {
1610 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1611 }
1612 }
1613 output.push_literal(::m2_syn::Literal::new(
1614 ::m2_syn::LiteralKind::RawString,
1615 ::std::format!("///{}///", contents),
1616 ::m2_syn::Spanned::span(self),
1617 ));
1618 }
1619}
1620impl ::m2_syn::PrettyTree for RawStringLiteral {
1621 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1622 let mut node = ::m2_syn::PrettyNode::syntax(
1623 stringify!(RawStringLiteral),
1624 ::m2_syn::Spanned::span(self),
1625 );
1626 node.push("elements", &self.elements);
1627 node
1628 }
1629}
1630impl<N> ::m2_syn::Reconstruct<N> for RawStringLiteral
1631where
1632 N: ::m2_syn::ExternalCstNode,
1633{
1634 fn matches(node: &N) -> bool {
1635 node.identity().matches("raw_string_literal", true)
1636 }
1637 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1638 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1639 return Err(::m2_syn::ReconstructError::wrong_node(
1640 "raw_string_literal",
1641 true,
1642 node.identity(),
1643 ));
1644 }
1645 let mut children = ::m2_syn::ChildCursor::new(&node);
1646 let elements = children
1647 .repeated_matching::<RawStringElement>()
1648 .into_iter()
1649 .map(|node| {
1650 let value = <RawStringElement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
1651 Ok::<_, ::m2_syn::ReconstructError>(value)
1652 })
1653 .collect::<Result<::std::vec::Vec<_>, _>>()?;
1654 Ok(Self { elements })
1655 }
1656}
1657#[derive(Debug, ::m2_syn::Spanned)]
1658pub struct BinaryExpression {
1659 pub left: ::std::boxed::Box<Expr>,
1660 pub operator: BinaryOperator,
1661 pub right: ::std::boxed::Box<Expr>,
1662}
1663impl BinaryExpression {
1664 pub fn new(left: Expr, operator: BinaryOperator, right: Expr) -> Self {
1665 {
1666 let left = ::std::boxed::Box::new(left);
1667 let right = ::std::boxed::Box::new(right);
1668 Self {
1669 left,
1670 operator,
1671 right,
1672 }
1673 }
1674 }
1675}
1676impl ::m2_syn::ToTokens for BinaryExpression {
1677 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1678 let mut contents = ::m2_syn::TokenStream::new();
1679 {
1680 let mut field_output = ::m2_syn::TokenStream::new();
1681 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
1682 if !field_output.is_empty() {
1683 if !contents.is_empty()
1684 && !contents.ends_with_whitespace()
1685 && !field_output.starts_with_whitespace()
1686 {
1687 contents.push_trivia(::m2_syn::Trivia::new(
1688 ::m2_syn::TriviaKind::Whitespace,
1689 " ",
1690 ::m2_syn::Span::detached(),
1691 ));
1692 }
1693 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1694 }
1695 }
1696 {
1697 let mut field_output = ::m2_syn::TokenStream::new();
1698 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
1699 if !field_output.is_empty() {
1700 if !contents.is_empty()
1701 && !contents.ends_with_whitespace()
1702 && !field_output.starts_with_whitespace()
1703 {
1704 contents.push_trivia(::m2_syn::Trivia::new(
1705 ::m2_syn::TriviaKind::Whitespace,
1706 " ",
1707 ::m2_syn::Span::detached(),
1708 ));
1709 }
1710 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1711 }
1712 }
1713 {
1714 let mut field_output = ::m2_syn::TokenStream::new();
1715 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
1716 if !field_output.is_empty() {
1717 if !contents.is_empty()
1718 && !contents.ends_with_whitespace()
1719 && !field_output.starts_with_whitespace()
1720 {
1721 contents.push_trivia(::m2_syn::Trivia::new(
1722 ::m2_syn::TriviaKind::Whitespace,
1723 " ",
1724 ::m2_syn::Span::detached(),
1725 ));
1726 }
1727 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1728 }
1729 }
1730 ::m2_syn::ToTokens::to_tokens(&contents, output);
1731 }
1732}
1733impl ::m2_syn::PrettyTree for BinaryExpression {
1734 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1735 let mut node = ::m2_syn::PrettyNode::syntax(
1736 stringify!(BinaryExpression),
1737 ::m2_syn::Spanned::span(self),
1738 );
1739 node.push("left", &self.left);
1740 node.push("operator", &self.operator);
1741 node.push("right", &self.right);
1742 node
1743 }
1744}
1745impl<N> ::m2_syn::Reconstruct<N> for BinaryExpression
1746where
1747 N: ::m2_syn::ExternalCstNode,
1748{
1749 fn matches(node: &N) -> bool {
1750 node.identity().matches("binary_expression", true)
1751 }
1752 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1753 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1754 return Err(::m2_syn::ReconstructError::wrong_node(
1755 "binary_expression",
1756 true,
1757 node.identity(),
1758 ));
1759 }
1760 let mut children = ::m2_syn::ChildCursor::new(&node);
1761 let left = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
1762 children.required_field("left")?,
1763 )?);
1764 let operator = <BinaryOperator as ::m2_syn::Reconstruct<N>>::reconstruct(
1765 children.required_field("operator")?,
1766 )?;
1767 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
1768 children.required_field("right")?,
1769 )?);
1770 Ok(Self {
1771 left,
1772 operator,
1773 right,
1774 })
1775 }
1776}
1777#[derive(Debug, ::m2_syn::Spanned)]
1778pub struct AdjacentExpression {
1779 pub left: ::std::boxed::Box<Expr>,
1780 pub right: ::std::boxed::Box<Expr>,
1781}
1782impl AdjacentExpression {
1783 pub fn new(left: Expr, right: Expr) -> Self {
1784 {
1785 let left = ::std::boxed::Box::new(left);
1786 let right = ::std::boxed::Box::new(right);
1787 Self { left, right }
1788 }
1789 }
1790}
1791impl ::m2_syn::ToTokens for AdjacentExpression {
1792 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1793 let mut contents = ::m2_syn::TokenStream::new();
1794 {
1795 let mut field_output = ::m2_syn::TokenStream::new();
1796 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
1797 if !field_output.is_empty() {
1798 if !contents.is_empty()
1799 && !contents.ends_with_whitespace()
1800 && !field_output.starts_with_whitespace()
1801 {
1802 contents.push_trivia(::m2_syn::Trivia::new(
1803 ::m2_syn::TriviaKind::Whitespace,
1804 " ",
1805 ::m2_syn::Span::detached(),
1806 ));
1807 }
1808 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1809 }
1810 }
1811 {
1812 let mut field_output = ::m2_syn::TokenStream::new();
1813 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
1814 if !field_output.is_empty() {
1815 if !contents.is_empty()
1816 && !contents.ends_with_whitespace()
1817 && !field_output.starts_with_whitespace()
1818 {
1819 contents.push_trivia(::m2_syn::Trivia::new(
1820 ::m2_syn::TriviaKind::Whitespace,
1821 " ",
1822 ::m2_syn::Span::detached(),
1823 ));
1824 }
1825 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1826 }
1827 }
1828 ::m2_syn::ToTokens::to_tokens(&contents, output);
1829 }
1830}
1831impl ::m2_syn::PrettyTree for AdjacentExpression {
1832 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1833 let mut node = ::m2_syn::PrettyNode::syntax(
1834 stringify!(AdjacentExpression),
1835 ::m2_syn::Spanned::span(self),
1836 );
1837 node.push("left", &self.left);
1838 node.push("right", &self.right);
1839 node
1840 }
1841}
1842impl<N> ::m2_syn::Reconstruct<N> for AdjacentExpression
1843where
1844 N: ::m2_syn::ExternalCstNode,
1845{
1846 fn matches(node: &N) -> bool {
1847 node.identity().matches("adjacent_expression", true)
1848 && node.children().any(|child| {
1849 child.field == Some("left")
1850 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
1851 })
1852 && node.children().any(|child| {
1853 child.field == Some("right")
1854 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
1855 })
1856 }
1857 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1858 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1859 return Err(::m2_syn::ReconstructError::wrong_node(
1860 "adjacent_expression",
1861 true,
1862 node.identity(),
1863 ));
1864 }
1865 let mut children = ::m2_syn::ChildCursor::new(&node);
1866 let left = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
1867 children.required_field("left")?,
1868 )?);
1869 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
1870 children.required_field("right")?,
1871 )?);
1872 Ok(Self { left, right })
1873 }
1874}
1875#[derive(Debug, ::m2_syn::Spanned)]
1876pub struct PrefixExpression {
1877 pub operator: PrefixOperator,
1878 pub operand: ::std::boxed::Box<Expr>,
1879}
1880impl PrefixExpression {
1881 pub fn new(operator: PrefixOperator, operand: Expr) -> Self {
1882 {
1883 let operand = ::std::boxed::Box::new(operand);
1884 Self { operator, operand }
1885 }
1886 }
1887}
1888impl ::m2_syn::ToTokens for PrefixExpression {
1889 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1890 let mut contents = ::m2_syn::TokenStream::new();
1891 {
1892 let mut field_output = ::m2_syn::TokenStream::new();
1893 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
1894 if !field_output.is_empty() {
1895 if !contents.is_empty()
1896 && !contents.ends_with_whitespace()
1897 && !field_output.starts_with_whitespace()
1898 {
1899 contents.push_trivia(::m2_syn::Trivia::new(
1900 ::m2_syn::TriviaKind::Whitespace,
1901 " ",
1902 ::m2_syn::Span::detached(),
1903 ));
1904 }
1905 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1906 }
1907 }
1908 {
1909 let mut field_output = ::m2_syn::TokenStream::new();
1910 ::m2_syn::ToTokens::to_tokens(&self.operand, &mut field_output);
1911 if !field_output.is_empty() {
1912 if !contents.is_empty()
1913 && !contents.ends_with_whitespace()
1914 && !field_output.starts_with_whitespace()
1915 {
1916 contents.push_trivia(::m2_syn::Trivia::new(
1917 ::m2_syn::TriviaKind::Whitespace,
1918 " ",
1919 ::m2_syn::Span::detached(),
1920 ));
1921 }
1922 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1923 }
1924 }
1925 ::m2_syn::ToTokens::to_tokens(&contents, output);
1926 }
1927}
1928impl ::m2_syn::PrettyTree for PrefixExpression {
1929 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
1930 let mut node = ::m2_syn::PrettyNode::syntax(
1931 stringify!(PrefixExpression),
1932 ::m2_syn::Spanned::span(self),
1933 );
1934 node.push("operator", &self.operator);
1935 node.push("operand", &self.operand);
1936 node
1937 }
1938}
1939impl<N> ::m2_syn::Reconstruct<N> for PrefixExpression
1940where
1941 N: ::m2_syn::ExternalCstNode,
1942{
1943 fn matches(node: &N) -> bool {
1944 node.identity().matches("prefix_expression", true)
1945 }
1946 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
1947 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
1948 return Err(::m2_syn::ReconstructError::wrong_node(
1949 "prefix_expression",
1950 true,
1951 node.identity(),
1952 ));
1953 }
1954 let mut children = ::m2_syn::ChildCursor::new(&node);
1955 let operator = <PrefixOperator as ::m2_syn::Reconstruct<N>>::reconstruct(
1956 children.required_field("operator")?,
1957 )?;
1958 let operand = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
1959 children.required_field("operand")?,
1960 )?);
1961 Ok(Self { operator, operand })
1962 }
1963}
1964#[derive(Debug, ::m2_syn::Spanned)]
1965pub struct PostfixExpression {
1966 pub operand: ::std::boxed::Box<Expr>,
1967 pub operator: PostfixOperator,
1968}
1969impl PostfixExpression {
1970 pub fn new(operand: Expr, operator: PostfixOperator) -> Self {
1971 {
1972 let operand = ::std::boxed::Box::new(operand);
1973 Self { operand, operator }
1974 }
1975 }
1976}
1977impl ::m2_syn::ToTokens for PostfixExpression {
1978 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
1979 let mut contents = ::m2_syn::TokenStream::new();
1980 {
1981 let mut field_output = ::m2_syn::TokenStream::new();
1982 ::m2_syn::ToTokens::to_tokens(&self.operand, &mut field_output);
1983 if !field_output.is_empty() {
1984 if !contents.is_empty()
1985 && !contents.ends_with_whitespace()
1986 && !field_output.starts_with_whitespace()
1987 {
1988 contents.push_trivia(::m2_syn::Trivia::new(
1989 ::m2_syn::TriviaKind::Whitespace,
1990 " ",
1991 ::m2_syn::Span::detached(),
1992 ));
1993 }
1994 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
1995 }
1996 }
1997 {
1998 let mut field_output = ::m2_syn::TokenStream::new();
1999 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2000 if !field_output.is_empty() {
2001 if !contents.is_empty()
2002 && !contents.ends_with_whitespace()
2003 && !field_output.starts_with_whitespace()
2004 {
2005 contents.push_trivia(::m2_syn::Trivia::new(
2006 ::m2_syn::TriviaKind::Whitespace,
2007 " ",
2008 ::m2_syn::Span::detached(),
2009 ));
2010 }
2011 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2012 }
2013 }
2014 ::m2_syn::ToTokens::to_tokens(&contents, output);
2015 }
2016}
2017impl ::m2_syn::PrettyTree for PostfixExpression {
2018 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2019 let mut node = ::m2_syn::PrettyNode::syntax(
2020 stringify!(PostfixExpression),
2021 ::m2_syn::Spanned::span(self),
2022 );
2023 node.push("operand", &self.operand);
2024 node.push("operator", &self.operator);
2025 node
2026 }
2027}
2028impl<N> ::m2_syn::Reconstruct<N> for PostfixExpression
2029where
2030 N: ::m2_syn::ExternalCstNode,
2031{
2032 fn matches(node: &N) -> bool {
2033 node.identity().matches("postfix_expression", true)
2034 }
2035 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2036 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2037 return Err(::m2_syn::ReconstructError::wrong_node(
2038 "postfix_expression",
2039 true,
2040 node.identity(),
2041 ));
2042 }
2043 let mut children = ::m2_syn::ChildCursor::new(&node);
2044 let operand = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2045 children.required_field("operand")?,
2046 )?);
2047 let operator = <PostfixOperator as ::m2_syn::Reconstruct<N>>::reconstruct(
2048 children.required_field("operator")?,
2049 )?;
2050 Ok(Self { operand, operator })
2051 }
2052}
2053#[derive(Debug, ::m2_syn::Spanned)]
2054pub struct LambdaExpression {
2055 pub parameters: ::std::boxed::Box<LambdaParameters>,
2056 pub operator: Token![->],
2057 pub body: ::std::boxed::Box<Expr>,
2058}
2059impl LambdaExpression {
2060 pub fn new(parameters: LambdaParameters, operator: Token![->], body: Expr) -> Self {
2061 {
2062 let parameters = ::std::boxed::Box::new(parameters);
2063 let body = ::std::boxed::Box::new(body);
2064 Self {
2065 parameters,
2066 operator,
2067 body,
2068 }
2069 }
2070 }
2071}
2072impl ::m2_syn::ToTokens for LambdaExpression {
2073 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2074 let mut contents = ::m2_syn::TokenStream::new();
2075 {
2076 let mut field_output = ::m2_syn::TokenStream::new();
2077 ::m2_syn::ToTokens::to_tokens(&self.parameters, &mut field_output);
2078 if !field_output.is_empty() {
2079 if !contents.is_empty()
2080 && !contents.ends_with_whitespace()
2081 && !field_output.starts_with_whitespace()
2082 {
2083 contents.push_trivia(::m2_syn::Trivia::new(
2084 ::m2_syn::TriviaKind::Whitespace,
2085 " ",
2086 ::m2_syn::Span::detached(),
2087 ));
2088 }
2089 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2090 }
2091 }
2092 {
2093 let mut field_output = ::m2_syn::TokenStream::new();
2094 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2095 if !field_output.is_empty() {
2096 if !contents.is_empty()
2097 && !contents.ends_with_whitespace()
2098 && !field_output.starts_with_whitespace()
2099 {
2100 contents.push_trivia(::m2_syn::Trivia::new(
2101 ::m2_syn::TriviaKind::Whitespace,
2102 " ",
2103 ::m2_syn::Span::detached(),
2104 ));
2105 }
2106 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2107 }
2108 }
2109 {
2110 let mut field_output = ::m2_syn::TokenStream::new();
2111 ::m2_syn::ToTokens::to_tokens(&self.body, &mut field_output);
2112 if !field_output.is_empty() {
2113 if !contents.is_empty()
2114 && !contents.ends_with_whitespace()
2115 && !field_output.starts_with_whitespace()
2116 {
2117 contents.push_trivia(::m2_syn::Trivia::new(
2118 ::m2_syn::TriviaKind::Whitespace,
2119 " ",
2120 ::m2_syn::Span::detached(),
2121 ));
2122 }
2123 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2124 }
2125 }
2126 ::m2_syn::ToTokens::to_tokens(&contents, output);
2127 }
2128}
2129impl ::m2_syn::PrettyTree for LambdaExpression {
2130 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2131 let mut node = ::m2_syn::PrettyNode::syntax(
2132 stringify!(LambdaExpression),
2133 ::m2_syn::Spanned::span(self),
2134 );
2135 node.push("parameters", &self.parameters);
2136 node.push("operator", &self.operator);
2137 node.push("body", &self.body);
2138 node
2139 }
2140}
2141impl<N> ::m2_syn::Reconstruct<N> for LambdaExpression
2142where
2143 N: ::m2_syn::ExternalCstNode,
2144{
2145 fn matches(node: &N) -> bool {
2146 node.identity().matches("lambda_expression", true)
2147 }
2148 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2149 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2150 return Err(::m2_syn::ReconstructError::wrong_node(
2151 "lambda_expression",
2152 true,
2153 node.identity(),
2154 ));
2155 }
2156 let mut children = ::m2_syn::ChildCursor::new(&node);
2157 let parameters =
2158 ::std::boxed::Box::new(<LambdaParameters as ::m2_syn::Reconstruct<N>>::reconstruct(
2159 children.required_field("parameters")?,
2160 )?);
2161 let operator = <Token![->] as ::m2_syn::Reconstruct<N>>::reconstruct(
2162 children.required_field("operator")?,
2163 )?;
2164 let body = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2165 children.required_field("body")?,
2166 )?);
2167 Ok(Self {
2168 parameters,
2169 operator,
2170 body,
2171 })
2172 }
2173}
2174#[derive(Debug, ::m2_syn::Spanned)]
2175pub struct Assignment {
2176 pub left: ::std::boxed::Box<Symbol>,
2177 pub operator: Token![=],
2178 pub right: ::std::boxed::Box<Expr>,
2179}
2180impl Assignment {
2181 pub fn new(left: Symbol, operator: Token![=], right: Expr) -> Self {
2182 {
2183 let left = ::std::boxed::Box::new(left);
2184 let right = ::std::boxed::Box::new(right);
2185 Self {
2186 left,
2187 operator,
2188 right,
2189 }
2190 }
2191 }
2192}
2193impl ::m2_syn::ToTokens for Assignment {
2194 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2195 let mut contents = ::m2_syn::TokenStream::new();
2196 {
2197 let mut field_output = ::m2_syn::TokenStream::new();
2198 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2199 if !field_output.is_empty() {
2200 if !contents.is_empty()
2201 && !contents.ends_with_whitespace()
2202 && !field_output.starts_with_whitespace()
2203 {
2204 contents.push_trivia(::m2_syn::Trivia::new(
2205 ::m2_syn::TriviaKind::Whitespace,
2206 " ",
2207 ::m2_syn::Span::detached(),
2208 ));
2209 }
2210 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2211 }
2212 }
2213 {
2214 let mut field_output = ::m2_syn::TokenStream::new();
2215 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2216 if !field_output.is_empty() {
2217 if !contents.is_empty()
2218 && !contents.ends_with_whitespace()
2219 && !field_output.starts_with_whitespace()
2220 {
2221 contents.push_trivia(::m2_syn::Trivia::new(
2222 ::m2_syn::TriviaKind::Whitespace,
2223 " ",
2224 ::m2_syn::Span::detached(),
2225 ));
2226 }
2227 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2228 }
2229 }
2230 {
2231 let mut field_output = ::m2_syn::TokenStream::new();
2232 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2233 if !field_output.is_empty() {
2234 if !contents.is_empty()
2235 && !contents.ends_with_whitespace()
2236 && !field_output.starts_with_whitespace()
2237 {
2238 contents.push_trivia(::m2_syn::Trivia::new(
2239 ::m2_syn::TriviaKind::Whitespace,
2240 " ",
2241 ::m2_syn::Span::detached(),
2242 ));
2243 }
2244 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2245 }
2246 }
2247 ::m2_syn::ToTokens::to_tokens(&contents, output);
2248 }
2249}
2250impl ::m2_syn::PrettyTree for Assignment {
2251 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2252 let mut node =
2253 ::m2_syn::PrettyNode::syntax(stringify!(Assignment), ::m2_syn::Spanned::span(self));
2254 node.push("left", &self.left);
2255 node.push("operator", &self.operator);
2256 node.push("right", &self.right);
2257 node
2258 }
2259}
2260impl<N> ::m2_syn::Reconstruct<N> for Assignment
2261where
2262 N: ::m2_syn::ExternalCstNode,
2263{
2264 fn matches(node: &N) -> bool {
2265 node.identity().matches("assignment", true)
2266 && node.children().any(|child| {
2267 child.field == Some("left")
2268 && <Symbol as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2269 })
2270 && node.children().any(|child| {
2271 child.field == Some("operator")
2272 && <Token![=] as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2273 })
2274 && node.children().any(|child| {
2275 child.field == Some("right")
2276 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2277 })
2278 }
2279 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2280 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2281 return Err(::m2_syn::ReconstructError::wrong_node(
2282 "assignment",
2283 true,
2284 node.identity(),
2285 ));
2286 }
2287 let mut children = ::m2_syn::ChildCursor::new(&node);
2288 let left = ::std::boxed::Box::new(<Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(
2289 children.required_field("left")?,
2290 )?);
2291 let operator = <Token![=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2292 children.required_field("operator")?,
2293 )?;
2294 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2295 children.required_field("right")?,
2296 )?);
2297 Ok(Self {
2298 left,
2299 operator,
2300 right,
2301 })
2302 }
2303}
2304#[derive(Debug, ::m2_syn::Spanned)]
2305pub struct LocalAssignment {
2306 pub left: ::std::boxed::Box<Symbol>,
2307 pub operator: Token![:=],
2308 pub right: ::std::boxed::Box<Expr>,
2309}
2310impl LocalAssignment {
2311 pub fn new(left: Symbol, operator: Token![:=], right: Expr) -> Self {
2312 {
2313 let left = ::std::boxed::Box::new(left);
2314 let right = ::std::boxed::Box::new(right);
2315 Self {
2316 left,
2317 operator,
2318 right,
2319 }
2320 }
2321 }
2322}
2323impl ::m2_syn::ToTokens for LocalAssignment {
2324 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2325 let mut contents = ::m2_syn::TokenStream::new();
2326 {
2327 let mut field_output = ::m2_syn::TokenStream::new();
2328 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2329 if !field_output.is_empty() {
2330 if !contents.is_empty()
2331 && !contents.ends_with_whitespace()
2332 && !field_output.starts_with_whitespace()
2333 {
2334 contents.push_trivia(::m2_syn::Trivia::new(
2335 ::m2_syn::TriviaKind::Whitespace,
2336 " ",
2337 ::m2_syn::Span::detached(),
2338 ));
2339 }
2340 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2341 }
2342 }
2343 {
2344 let mut field_output = ::m2_syn::TokenStream::new();
2345 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2346 if !field_output.is_empty() {
2347 if !contents.is_empty()
2348 && !contents.ends_with_whitespace()
2349 && !field_output.starts_with_whitespace()
2350 {
2351 contents.push_trivia(::m2_syn::Trivia::new(
2352 ::m2_syn::TriviaKind::Whitespace,
2353 " ",
2354 ::m2_syn::Span::detached(),
2355 ));
2356 }
2357 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2358 }
2359 }
2360 {
2361 let mut field_output = ::m2_syn::TokenStream::new();
2362 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2363 if !field_output.is_empty() {
2364 if !contents.is_empty()
2365 && !contents.ends_with_whitespace()
2366 && !field_output.starts_with_whitespace()
2367 {
2368 contents.push_trivia(::m2_syn::Trivia::new(
2369 ::m2_syn::TriviaKind::Whitespace,
2370 " ",
2371 ::m2_syn::Span::detached(),
2372 ));
2373 }
2374 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2375 }
2376 }
2377 ::m2_syn::ToTokens::to_tokens(&contents, output);
2378 }
2379}
2380impl ::m2_syn::PrettyTree for LocalAssignment {
2381 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2382 let mut node = ::m2_syn::PrettyNode::syntax(
2383 stringify!(LocalAssignment),
2384 ::m2_syn::Spanned::span(self),
2385 );
2386 node.push("left", &self.left);
2387 node.push("operator", &self.operator);
2388 node.push("right", &self.right);
2389 node
2390 }
2391}
2392impl<N> ::m2_syn::Reconstruct<N> for LocalAssignment
2393where
2394 N: ::m2_syn::ExternalCstNode,
2395{
2396 fn matches(node: &N) -> bool {
2397 node.identity().matches("local_assignment", true)
2398 && node.children().any(|child| {
2399 child.field == Some("left")
2400 && <Symbol as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2401 })
2402 && node.children().any(|child| {
2403 child.field == Some("operator")
2404 && <Token![:=] as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2405 })
2406 && node.children().any(|child| {
2407 child.field == Some("right")
2408 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
2409 })
2410 }
2411 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2412 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2413 return Err(::m2_syn::ReconstructError::wrong_node(
2414 "local_assignment",
2415 true,
2416 node.identity(),
2417 ));
2418 }
2419 let mut children = ::m2_syn::ChildCursor::new(&node);
2420 let left = ::std::boxed::Box::new(<Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(
2421 children.required_field("left")?,
2422 )?);
2423 let operator = <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2424 children.required_field("operator")?,
2425 )?;
2426 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2427 children.required_field("right")?,
2428 )?);
2429 Ok(Self {
2430 left,
2431 operator,
2432 right,
2433 })
2434 }
2435}
2436#[derive(Debug, ::m2_syn::Spanned)]
2437pub struct BinaryAssignment {
2438 pub left: ::std::boxed::Box<BinaryExpression>,
2439 pub operator: Token![=],
2440 pub right: ::std::boxed::Box<Expr>,
2441}
2442impl BinaryAssignment {
2443 pub fn new(left: BinaryExpression, operator: Token![=], right: Expr) -> Self {
2444 {
2445 let left = ::std::boxed::Box::new(left);
2446 let right = ::std::boxed::Box::new(right);
2447 Self {
2448 left,
2449 operator,
2450 right,
2451 }
2452 }
2453 }
2454}
2455impl ::m2_syn::ToTokens for BinaryAssignment {
2456 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2457 let mut contents = ::m2_syn::TokenStream::new();
2458 {
2459 let mut field_output = ::m2_syn::TokenStream::new();
2460 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2461 if !field_output.is_empty() {
2462 if !contents.is_empty()
2463 && !contents.ends_with_whitespace()
2464 && !field_output.starts_with_whitespace()
2465 {
2466 contents.push_trivia(::m2_syn::Trivia::new(
2467 ::m2_syn::TriviaKind::Whitespace,
2468 " ",
2469 ::m2_syn::Span::detached(),
2470 ));
2471 }
2472 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2473 }
2474 }
2475 {
2476 let mut field_output = ::m2_syn::TokenStream::new();
2477 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2478 if !field_output.is_empty() {
2479 if !contents.is_empty()
2480 && !contents.ends_with_whitespace()
2481 && !field_output.starts_with_whitespace()
2482 {
2483 contents.push_trivia(::m2_syn::Trivia::new(
2484 ::m2_syn::TriviaKind::Whitespace,
2485 " ",
2486 ::m2_syn::Span::detached(),
2487 ));
2488 }
2489 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2490 }
2491 }
2492 {
2493 let mut field_output = ::m2_syn::TokenStream::new();
2494 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2495 if !field_output.is_empty() {
2496 if !contents.is_empty()
2497 && !contents.ends_with_whitespace()
2498 && !field_output.starts_with_whitespace()
2499 {
2500 contents.push_trivia(::m2_syn::Trivia::new(
2501 ::m2_syn::TriviaKind::Whitespace,
2502 " ",
2503 ::m2_syn::Span::detached(),
2504 ));
2505 }
2506 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2507 }
2508 }
2509 ::m2_syn::ToTokens::to_tokens(&contents, output);
2510 }
2511}
2512impl ::m2_syn::PrettyTree for BinaryAssignment {
2513 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2514 let mut node = ::m2_syn::PrettyNode::syntax(
2515 stringify!(BinaryAssignment),
2516 ::m2_syn::Spanned::span(self),
2517 );
2518 node.push("left", &self.left);
2519 node.push("operator", &self.operator);
2520 node.push("right", &self.right);
2521 node
2522 }
2523}
2524impl<N> ::m2_syn::Reconstruct<N> for BinaryAssignment
2525where
2526 N: ::m2_syn::ExternalCstNode,
2527{
2528 fn matches(node: &N) -> bool {
2529 node.identity().matches("binary_assignment", true)
2530 }
2531 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2532 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2533 return Err(::m2_syn::ReconstructError::wrong_node(
2534 "binary_assignment",
2535 true,
2536 node.identity(),
2537 ));
2538 }
2539 let mut children = ::m2_syn::ChildCursor::new(&node);
2540 let left =
2541 ::std::boxed::Box::new(<BinaryExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
2542 children.required_field("left")?,
2543 )?);
2544 let operator = <Token![=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2545 children.required_field("operator")?,
2546 )?;
2547 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2548 children.required_field("right")?,
2549 )?);
2550 Ok(Self {
2551 left,
2552 operator,
2553 right,
2554 })
2555 }
2556}
2557#[derive(Debug, ::m2_syn::Spanned)]
2558pub struct BinaryInstallation {
2559 pub left: ::std::boxed::Box<BinaryExpression>,
2560 pub operator: Token![:=],
2561 pub right: ::std::boxed::Box<Expr>,
2562}
2563impl BinaryInstallation {
2564 pub fn new(left: BinaryExpression, operator: Token![:=], right: Expr) -> Self {
2565 {
2566 let left = ::std::boxed::Box::new(left);
2567 let right = ::std::boxed::Box::new(right);
2568 Self {
2569 left,
2570 operator,
2571 right,
2572 }
2573 }
2574 }
2575}
2576impl ::m2_syn::ToTokens for BinaryInstallation {
2577 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2578 let mut contents = ::m2_syn::TokenStream::new();
2579 {
2580 let mut field_output = ::m2_syn::TokenStream::new();
2581 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2582 if !field_output.is_empty() {
2583 if !contents.is_empty()
2584 && !contents.ends_with_whitespace()
2585 && !field_output.starts_with_whitespace()
2586 {
2587 contents.push_trivia(::m2_syn::Trivia::new(
2588 ::m2_syn::TriviaKind::Whitespace,
2589 " ",
2590 ::m2_syn::Span::detached(),
2591 ));
2592 }
2593 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2594 }
2595 }
2596 {
2597 let mut field_output = ::m2_syn::TokenStream::new();
2598 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2599 if !field_output.is_empty() {
2600 if !contents.is_empty()
2601 && !contents.ends_with_whitespace()
2602 && !field_output.starts_with_whitespace()
2603 {
2604 contents.push_trivia(::m2_syn::Trivia::new(
2605 ::m2_syn::TriviaKind::Whitespace,
2606 " ",
2607 ::m2_syn::Span::detached(),
2608 ));
2609 }
2610 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2611 }
2612 }
2613 {
2614 let mut field_output = ::m2_syn::TokenStream::new();
2615 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2616 if !field_output.is_empty() {
2617 if !contents.is_empty()
2618 && !contents.ends_with_whitespace()
2619 && !field_output.starts_with_whitespace()
2620 {
2621 contents.push_trivia(::m2_syn::Trivia::new(
2622 ::m2_syn::TriviaKind::Whitespace,
2623 " ",
2624 ::m2_syn::Span::detached(),
2625 ));
2626 }
2627 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2628 }
2629 }
2630 ::m2_syn::ToTokens::to_tokens(&contents, output);
2631 }
2632}
2633impl ::m2_syn::PrettyTree for BinaryInstallation {
2634 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2635 let mut node = ::m2_syn::PrettyNode::syntax(
2636 stringify!(BinaryInstallation),
2637 ::m2_syn::Spanned::span(self),
2638 );
2639 node.push("left", &self.left);
2640 node.push("operator", &self.operator);
2641 node.push("right", &self.right);
2642 node
2643 }
2644}
2645impl<N> ::m2_syn::Reconstruct<N> for BinaryInstallation
2646where
2647 N: ::m2_syn::ExternalCstNode,
2648{
2649 fn matches(node: &N) -> bool {
2650 node.identity().matches("binary_installation", true)
2651 }
2652 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2653 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2654 return Err(::m2_syn::ReconstructError::wrong_node(
2655 "binary_installation",
2656 true,
2657 node.identity(),
2658 ));
2659 }
2660 let mut children = ::m2_syn::ChildCursor::new(&node);
2661 let left =
2662 ::std::boxed::Box::new(<BinaryExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
2663 children.required_field("left")?,
2664 )?);
2665 let operator = <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2666 children.required_field("operator")?,
2667 )?;
2668 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2669 children.required_field("right")?,
2670 )?);
2671 Ok(Self {
2672 left,
2673 operator,
2674 right,
2675 })
2676 }
2677}
2678#[derive(Debug, ::m2_syn::Spanned)]
2679pub struct PrefixAssignment {
2680 pub left: ::std::boxed::Box<PrefixExpression>,
2681 pub operator: Token![=],
2682 pub right: ::std::boxed::Box<Expr>,
2683}
2684impl PrefixAssignment {
2685 pub fn new(left: PrefixExpression, operator: Token![=], right: Expr) -> Self {
2686 {
2687 let left = ::std::boxed::Box::new(left);
2688 let right = ::std::boxed::Box::new(right);
2689 Self {
2690 left,
2691 operator,
2692 right,
2693 }
2694 }
2695 }
2696}
2697impl ::m2_syn::ToTokens for PrefixAssignment {
2698 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2699 let mut contents = ::m2_syn::TokenStream::new();
2700 {
2701 let mut field_output = ::m2_syn::TokenStream::new();
2702 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2703 if !field_output.is_empty() {
2704 if !contents.is_empty()
2705 && !contents.ends_with_whitespace()
2706 && !field_output.starts_with_whitespace()
2707 {
2708 contents.push_trivia(::m2_syn::Trivia::new(
2709 ::m2_syn::TriviaKind::Whitespace,
2710 " ",
2711 ::m2_syn::Span::detached(),
2712 ));
2713 }
2714 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2715 }
2716 }
2717 {
2718 let mut field_output = ::m2_syn::TokenStream::new();
2719 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2720 if !field_output.is_empty() {
2721 if !contents.is_empty()
2722 && !contents.ends_with_whitespace()
2723 && !field_output.starts_with_whitespace()
2724 {
2725 contents.push_trivia(::m2_syn::Trivia::new(
2726 ::m2_syn::TriviaKind::Whitespace,
2727 " ",
2728 ::m2_syn::Span::detached(),
2729 ));
2730 }
2731 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2732 }
2733 }
2734 {
2735 let mut field_output = ::m2_syn::TokenStream::new();
2736 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2737 if !field_output.is_empty() {
2738 if !contents.is_empty()
2739 && !contents.ends_with_whitespace()
2740 && !field_output.starts_with_whitespace()
2741 {
2742 contents.push_trivia(::m2_syn::Trivia::new(
2743 ::m2_syn::TriviaKind::Whitespace,
2744 " ",
2745 ::m2_syn::Span::detached(),
2746 ));
2747 }
2748 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2749 }
2750 }
2751 ::m2_syn::ToTokens::to_tokens(&contents, output);
2752 }
2753}
2754impl ::m2_syn::PrettyTree for PrefixAssignment {
2755 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2756 let mut node = ::m2_syn::PrettyNode::syntax(
2757 stringify!(PrefixAssignment),
2758 ::m2_syn::Spanned::span(self),
2759 );
2760 node.push("left", &self.left);
2761 node.push("operator", &self.operator);
2762 node.push("right", &self.right);
2763 node
2764 }
2765}
2766impl<N> ::m2_syn::Reconstruct<N> for PrefixAssignment
2767where
2768 N: ::m2_syn::ExternalCstNode,
2769{
2770 fn matches(node: &N) -> bool {
2771 node.identity().matches("prefix_assignment", true)
2772 }
2773 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2774 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2775 return Err(::m2_syn::ReconstructError::wrong_node(
2776 "prefix_assignment",
2777 true,
2778 node.identity(),
2779 ));
2780 }
2781 let mut children = ::m2_syn::ChildCursor::new(&node);
2782 let left =
2783 ::std::boxed::Box::new(<PrefixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
2784 children.required_field("left")?,
2785 )?);
2786 let operator = <Token![=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2787 children.required_field("operator")?,
2788 )?;
2789 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2790 children.required_field("right")?,
2791 )?);
2792 Ok(Self {
2793 left,
2794 operator,
2795 right,
2796 })
2797 }
2798}
2799#[derive(Debug, ::m2_syn::Spanned)]
2800pub struct PrefixInstallation {
2801 pub left: ::std::boxed::Box<PrefixExpression>,
2802 pub operator: Token![:=],
2803 pub right: ::std::boxed::Box<Expr>,
2804}
2805impl PrefixInstallation {
2806 pub fn new(left: PrefixExpression, operator: Token![:=], right: Expr) -> Self {
2807 {
2808 let left = ::std::boxed::Box::new(left);
2809 let right = ::std::boxed::Box::new(right);
2810 Self {
2811 left,
2812 operator,
2813 right,
2814 }
2815 }
2816 }
2817}
2818impl ::m2_syn::ToTokens for PrefixInstallation {
2819 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2820 let mut contents = ::m2_syn::TokenStream::new();
2821 {
2822 let mut field_output = ::m2_syn::TokenStream::new();
2823 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2824 if !field_output.is_empty() {
2825 if !contents.is_empty()
2826 && !contents.ends_with_whitespace()
2827 && !field_output.starts_with_whitespace()
2828 {
2829 contents.push_trivia(::m2_syn::Trivia::new(
2830 ::m2_syn::TriviaKind::Whitespace,
2831 " ",
2832 ::m2_syn::Span::detached(),
2833 ));
2834 }
2835 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2836 }
2837 }
2838 {
2839 let mut field_output = ::m2_syn::TokenStream::new();
2840 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2841 if !field_output.is_empty() {
2842 if !contents.is_empty()
2843 && !contents.ends_with_whitespace()
2844 && !field_output.starts_with_whitespace()
2845 {
2846 contents.push_trivia(::m2_syn::Trivia::new(
2847 ::m2_syn::TriviaKind::Whitespace,
2848 " ",
2849 ::m2_syn::Span::detached(),
2850 ));
2851 }
2852 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2853 }
2854 }
2855 {
2856 let mut field_output = ::m2_syn::TokenStream::new();
2857 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2858 if !field_output.is_empty() {
2859 if !contents.is_empty()
2860 && !contents.ends_with_whitespace()
2861 && !field_output.starts_with_whitespace()
2862 {
2863 contents.push_trivia(::m2_syn::Trivia::new(
2864 ::m2_syn::TriviaKind::Whitespace,
2865 " ",
2866 ::m2_syn::Span::detached(),
2867 ));
2868 }
2869 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2870 }
2871 }
2872 ::m2_syn::ToTokens::to_tokens(&contents, output);
2873 }
2874}
2875impl ::m2_syn::PrettyTree for PrefixInstallation {
2876 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2877 let mut node = ::m2_syn::PrettyNode::syntax(
2878 stringify!(PrefixInstallation),
2879 ::m2_syn::Spanned::span(self),
2880 );
2881 node.push("left", &self.left);
2882 node.push("operator", &self.operator);
2883 node.push("right", &self.right);
2884 node
2885 }
2886}
2887impl<N> ::m2_syn::Reconstruct<N> for PrefixInstallation
2888where
2889 N: ::m2_syn::ExternalCstNode,
2890{
2891 fn matches(node: &N) -> bool {
2892 node.identity().matches("prefix_installation", true)
2893 }
2894 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
2895 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
2896 return Err(::m2_syn::ReconstructError::wrong_node(
2897 "prefix_installation",
2898 true,
2899 node.identity(),
2900 ));
2901 }
2902 let mut children = ::m2_syn::ChildCursor::new(&node);
2903 let left =
2904 ::std::boxed::Box::new(<PrefixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
2905 children.required_field("left")?,
2906 )?);
2907 let operator = <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(
2908 children.required_field("operator")?,
2909 )?;
2910 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
2911 children.required_field("right")?,
2912 )?);
2913 Ok(Self {
2914 left,
2915 operator,
2916 right,
2917 })
2918 }
2919}
2920#[derive(Debug, ::m2_syn::Spanned)]
2921pub struct PostfixAssignment {
2922 pub left: ::std::boxed::Box<PostfixExpression>,
2923 pub operator: Token![=],
2924 pub right: ::std::boxed::Box<Expr>,
2925}
2926impl PostfixAssignment {
2927 pub fn new(left: PostfixExpression, operator: Token![=], right: Expr) -> Self {
2928 {
2929 let left = ::std::boxed::Box::new(left);
2930 let right = ::std::boxed::Box::new(right);
2931 Self {
2932 left,
2933 operator,
2934 right,
2935 }
2936 }
2937 }
2938}
2939impl ::m2_syn::ToTokens for PostfixAssignment {
2940 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
2941 let mut contents = ::m2_syn::TokenStream::new();
2942 {
2943 let mut field_output = ::m2_syn::TokenStream::new();
2944 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
2945 if !field_output.is_empty() {
2946 if !contents.is_empty()
2947 && !contents.ends_with_whitespace()
2948 && !field_output.starts_with_whitespace()
2949 {
2950 contents.push_trivia(::m2_syn::Trivia::new(
2951 ::m2_syn::TriviaKind::Whitespace,
2952 " ",
2953 ::m2_syn::Span::detached(),
2954 ));
2955 }
2956 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2957 }
2958 }
2959 {
2960 let mut field_output = ::m2_syn::TokenStream::new();
2961 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
2962 if !field_output.is_empty() {
2963 if !contents.is_empty()
2964 && !contents.ends_with_whitespace()
2965 && !field_output.starts_with_whitespace()
2966 {
2967 contents.push_trivia(::m2_syn::Trivia::new(
2968 ::m2_syn::TriviaKind::Whitespace,
2969 " ",
2970 ::m2_syn::Span::detached(),
2971 ));
2972 }
2973 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2974 }
2975 }
2976 {
2977 let mut field_output = ::m2_syn::TokenStream::new();
2978 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
2979 if !field_output.is_empty() {
2980 if !contents.is_empty()
2981 && !contents.ends_with_whitespace()
2982 && !field_output.starts_with_whitespace()
2983 {
2984 contents.push_trivia(::m2_syn::Trivia::new(
2985 ::m2_syn::TriviaKind::Whitespace,
2986 " ",
2987 ::m2_syn::Span::detached(),
2988 ));
2989 }
2990 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
2991 }
2992 }
2993 ::m2_syn::ToTokens::to_tokens(&contents, output);
2994 }
2995}
2996impl ::m2_syn::PrettyTree for PostfixAssignment {
2997 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
2998 let mut node = ::m2_syn::PrettyNode::syntax(
2999 stringify!(PostfixAssignment),
3000 ::m2_syn::Spanned::span(self),
3001 );
3002 node.push("left", &self.left);
3003 node.push("operator", &self.operator);
3004 node.push("right", &self.right);
3005 node
3006 }
3007}
3008impl<N> ::m2_syn::Reconstruct<N> for PostfixAssignment
3009where
3010 N: ::m2_syn::ExternalCstNode,
3011{
3012 fn matches(node: &N) -> bool {
3013 node.identity().matches("postfix_assignment", true)
3014 }
3015 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3016 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3017 return Err(::m2_syn::ReconstructError::wrong_node(
3018 "postfix_assignment",
3019 true,
3020 node.identity(),
3021 ));
3022 }
3023 let mut children = ::m2_syn::ChildCursor::new(&node);
3024 let left = ::std::boxed::Box::new(
3025 <PostfixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
3026 children.required_field("left")?,
3027 )?,
3028 );
3029 let operator = <Token![=] as ::m2_syn::Reconstruct<N>>::reconstruct(
3030 children.required_field("operator")?,
3031 )?;
3032 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3033 children.required_field("right")?,
3034 )?);
3035 Ok(Self {
3036 left,
3037 operator,
3038 right,
3039 })
3040 }
3041}
3042#[derive(Debug, ::m2_syn::Spanned)]
3043pub struct PostfixInstallation {
3044 pub left: ::std::boxed::Box<PostfixExpression>,
3045 pub operator: Token![:=],
3046 pub right: ::std::boxed::Box<Expr>,
3047}
3048impl PostfixInstallation {
3049 pub fn new(left: PostfixExpression, operator: Token![:=], right: Expr) -> Self {
3050 {
3051 let left = ::std::boxed::Box::new(left);
3052 let right = ::std::boxed::Box::new(right);
3053 Self {
3054 left,
3055 operator,
3056 right,
3057 }
3058 }
3059 }
3060}
3061impl ::m2_syn::ToTokens for PostfixInstallation {
3062 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3063 let mut contents = ::m2_syn::TokenStream::new();
3064 {
3065 let mut field_output = ::m2_syn::TokenStream::new();
3066 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
3067 if !field_output.is_empty() {
3068 if !contents.is_empty()
3069 && !contents.ends_with_whitespace()
3070 && !field_output.starts_with_whitespace()
3071 {
3072 contents.push_trivia(::m2_syn::Trivia::new(
3073 ::m2_syn::TriviaKind::Whitespace,
3074 " ",
3075 ::m2_syn::Span::detached(),
3076 ));
3077 }
3078 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3079 }
3080 }
3081 {
3082 let mut field_output = ::m2_syn::TokenStream::new();
3083 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
3084 if !field_output.is_empty() {
3085 if !contents.is_empty()
3086 && !contents.ends_with_whitespace()
3087 && !field_output.starts_with_whitespace()
3088 {
3089 contents.push_trivia(::m2_syn::Trivia::new(
3090 ::m2_syn::TriviaKind::Whitespace,
3091 " ",
3092 ::m2_syn::Span::detached(),
3093 ));
3094 }
3095 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3096 }
3097 }
3098 {
3099 let mut field_output = ::m2_syn::TokenStream::new();
3100 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
3101 if !field_output.is_empty() {
3102 if !contents.is_empty()
3103 && !contents.ends_with_whitespace()
3104 && !field_output.starts_with_whitespace()
3105 {
3106 contents.push_trivia(::m2_syn::Trivia::new(
3107 ::m2_syn::TriviaKind::Whitespace,
3108 " ",
3109 ::m2_syn::Span::detached(),
3110 ));
3111 }
3112 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3113 }
3114 }
3115 ::m2_syn::ToTokens::to_tokens(&contents, output);
3116 }
3117}
3118impl ::m2_syn::PrettyTree for PostfixInstallation {
3119 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3120 let mut node = ::m2_syn::PrettyNode::syntax(
3121 stringify!(PostfixInstallation),
3122 ::m2_syn::Spanned::span(self),
3123 );
3124 node.push("left", &self.left);
3125 node.push("operator", &self.operator);
3126 node.push("right", &self.right);
3127 node
3128 }
3129}
3130impl<N> ::m2_syn::Reconstruct<N> for PostfixInstallation
3131where
3132 N: ::m2_syn::ExternalCstNode,
3133{
3134 fn matches(node: &N) -> bool {
3135 node.identity().matches("postfix_installation", true)
3136 }
3137 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3138 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3139 return Err(::m2_syn::ReconstructError::wrong_node(
3140 "postfix_installation",
3141 true,
3142 node.identity(),
3143 ));
3144 }
3145 let mut children = ::m2_syn::ChildCursor::new(&node);
3146 let left = ::std::boxed::Box::new(
3147 <PostfixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(
3148 children.required_field("left")?,
3149 )?,
3150 );
3151 let operator = <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(
3152 children.required_field("operator")?,
3153 )?;
3154 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3155 children.required_field("right")?,
3156 )?);
3157 Ok(Self {
3158 left,
3159 operator,
3160 right,
3161 })
3162 }
3163}
3164#[derive(Debug, ::m2_syn::Spanned)]
3165pub struct StructuredBinding {
3166 pub binding_pack: ::std::boxed::Box<BindingPack>,
3167 pub operator: Token![=],
3168 pub right: ::std::boxed::Box<Expr>,
3169}
3170impl StructuredBinding {
3171 pub fn new(binding_pack: BindingPack, operator: Token![=], right: Expr) -> Self {
3172 {
3173 let binding_pack = ::std::boxed::Box::new(binding_pack);
3174 let right = ::std::boxed::Box::new(right);
3175 Self {
3176 binding_pack,
3177 operator,
3178 right,
3179 }
3180 }
3181 }
3182}
3183impl ::m2_syn::ToTokens for StructuredBinding {
3184 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3185 let mut contents = ::m2_syn::TokenStream::new();
3186 {
3187 let mut field_output = ::m2_syn::TokenStream::new();
3188 ::m2_syn::ToTokens::to_tokens(&self.binding_pack, &mut field_output);
3189 if !field_output.is_empty() {
3190 if !contents.is_empty()
3191 && !contents.ends_with_whitespace()
3192 && !field_output.starts_with_whitespace()
3193 {
3194 contents.push_trivia(::m2_syn::Trivia::new(
3195 ::m2_syn::TriviaKind::Whitespace,
3196 " ",
3197 ::m2_syn::Span::detached(),
3198 ));
3199 }
3200 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3201 }
3202 }
3203 {
3204 let mut field_output = ::m2_syn::TokenStream::new();
3205 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
3206 if !field_output.is_empty() {
3207 if !contents.is_empty()
3208 && !contents.ends_with_whitespace()
3209 && !field_output.starts_with_whitespace()
3210 {
3211 contents.push_trivia(::m2_syn::Trivia::new(
3212 ::m2_syn::TriviaKind::Whitespace,
3213 " ",
3214 ::m2_syn::Span::detached(),
3215 ));
3216 }
3217 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3218 }
3219 }
3220 {
3221 let mut field_output = ::m2_syn::TokenStream::new();
3222 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
3223 if !field_output.is_empty() {
3224 if !contents.is_empty()
3225 && !contents.ends_with_whitespace()
3226 && !field_output.starts_with_whitespace()
3227 {
3228 contents.push_trivia(::m2_syn::Trivia::new(
3229 ::m2_syn::TriviaKind::Whitespace,
3230 " ",
3231 ::m2_syn::Span::detached(),
3232 ));
3233 }
3234 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3235 }
3236 }
3237 ::m2_syn::ToTokens::to_tokens(&contents, output);
3238 }
3239}
3240impl ::m2_syn::PrettyTree for StructuredBinding {
3241 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3242 let mut node = ::m2_syn::PrettyNode::syntax(
3243 stringify!(StructuredBinding),
3244 ::m2_syn::Spanned::span(self),
3245 );
3246 node.push("binding_pack", &self.binding_pack);
3247 node.push("operator", &self.operator);
3248 node.push("right", &self.right);
3249 node
3250 }
3251}
3252impl<N> ::m2_syn::Reconstruct<N> for StructuredBinding
3253where
3254 N: ::m2_syn::ExternalCstNode,
3255{
3256 fn matches(node: &N) -> bool {
3257 node.identity().matches("structured_binding", true)
3258 }
3259 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3260 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3261 return Err(::m2_syn::ReconstructError::wrong_node(
3262 "structured_binding",
3263 true,
3264 node.identity(),
3265 ));
3266 }
3267 let mut children = ::m2_syn::ChildCursor::new(&node);
3268 let binding_pack =
3269 ::std::boxed::Box::new(<BindingPack as ::m2_syn::Reconstruct<N>>::reconstruct(
3270 children.required_field("binding_pack")?,
3271 )?);
3272 let operator = <Token![=] as ::m2_syn::Reconstruct<N>>::reconstruct(
3273 children.required_field("operator")?,
3274 )?;
3275 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3276 children.required_field("right")?,
3277 )?);
3278 Ok(Self {
3279 binding_pack,
3280 operator,
3281 right,
3282 })
3283 }
3284}
3285#[derive(Debug, ::m2_syn::Spanned)]
3286pub struct LocalStructuredBinding {
3287 pub binding_pack: ::std::boxed::Box<BindingPack>,
3288 pub operator: Token![:=],
3289 pub right: ::std::boxed::Box<Expr>,
3290}
3291impl LocalStructuredBinding {
3292 pub fn new(binding_pack: BindingPack, operator: Token![:=], right: Expr) -> Self {
3293 {
3294 let binding_pack = ::std::boxed::Box::new(binding_pack);
3295 let right = ::std::boxed::Box::new(right);
3296 Self {
3297 binding_pack,
3298 operator,
3299 right,
3300 }
3301 }
3302 }
3303}
3304impl ::m2_syn::ToTokens for LocalStructuredBinding {
3305 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3306 let mut contents = ::m2_syn::TokenStream::new();
3307 {
3308 let mut field_output = ::m2_syn::TokenStream::new();
3309 ::m2_syn::ToTokens::to_tokens(&self.binding_pack, &mut field_output);
3310 if !field_output.is_empty() {
3311 if !contents.is_empty()
3312 && !contents.ends_with_whitespace()
3313 && !field_output.starts_with_whitespace()
3314 {
3315 contents.push_trivia(::m2_syn::Trivia::new(
3316 ::m2_syn::TriviaKind::Whitespace,
3317 " ",
3318 ::m2_syn::Span::detached(),
3319 ));
3320 }
3321 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3322 }
3323 }
3324 {
3325 let mut field_output = ::m2_syn::TokenStream::new();
3326 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
3327 if !field_output.is_empty() {
3328 if !contents.is_empty()
3329 && !contents.ends_with_whitespace()
3330 && !field_output.starts_with_whitespace()
3331 {
3332 contents.push_trivia(::m2_syn::Trivia::new(
3333 ::m2_syn::TriviaKind::Whitespace,
3334 " ",
3335 ::m2_syn::Span::detached(),
3336 ));
3337 }
3338 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3339 }
3340 }
3341 {
3342 let mut field_output = ::m2_syn::TokenStream::new();
3343 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
3344 if !field_output.is_empty() {
3345 if !contents.is_empty()
3346 && !contents.ends_with_whitespace()
3347 && !field_output.starts_with_whitespace()
3348 {
3349 contents.push_trivia(::m2_syn::Trivia::new(
3350 ::m2_syn::TriviaKind::Whitespace,
3351 " ",
3352 ::m2_syn::Span::detached(),
3353 ));
3354 }
3355 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3356 }
3357 }
3358 ::m2_syn::ToTokens::to_tokens(&contents, output);
3359 }
3360}
3361impl ::m2_syn::PrettyTree for LocalStructuredBinding {
3362 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3363 let mut node = ::m2_syn::PrettyNode::syntax(
3364 stringify!(LocalStructuredBinding),
3365 ::m2_syn::Spanned::span(self),
3366 );
3367 node.push("binding_pack", &self.binding_pack);
3368 node.push("operator", &self.operator);
3369 node.push("right", &self.right);
3370 node
3371 }
3372}
3373impl<N> ::m2_syn::Reconstruct<N> for LocalStructuredBinding
3374where
3375 N: ::m2_syn::ExternalCstNode,
3376{
3377 fn matches(node: &N) -> bool {
3378 node.identity().matches("local_structured_binding", true)
3379 }
3380 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3381 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3382 return Err(::m2_syn::ReconstructError::wrong_node(
3383 "local_structured_binding",
3384 true,
3385 node.identity(),
3386 ));
3387 }
3388 let mut children = ::m2_syn::ChildCursor::new(&node);
3389 let binding_pack =
3390 ::std::boxed::Box::new(<BindingPack as ::m2_syn::Reconstruct<N>>::reconstruct(
3391 children.required_field("binding_pack")?,
3392 )?);
3393 let operator = <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(
3394 children.required_field("operator")?,
3395 )?;
3396 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3397 children.required_field("right")?,
3398 )?);
3399 Ok(Self {
3400 binding_pack,
3401 operator,
3402 right,
3403 })
3404 }
3405}
3406#[derive(Debug, ::m2_syn::Spanned)]
3407pub struct EvaluatedAssignment {
3408 pub left: ::std::boxed::Box<Expr>,
3409 pub operator: Token![<-],
3410 pub right: ::std::boxed::Box<Expr>,
3411}
3412impl EvaluatedAssignment {
3413 pub fn new(left: Expr, operator: Token![<-], right: Expr) -> Self {
3414 {
3415 let left = ::std::boxed::Box::new(left);
3416 let right = ::std::boxed::Box::new(right);
3417 Self {
3418 left,
3419 operator,
3420 right,
3421 }
3422 }
3423 }
3424}
3425impl ::m2_syn::ToTokens for EvaluatedAssignment {
3426 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3427 let mut contents = ::m2_syn::TokenStream::new();
3428 {
3429 let mut field_output = ::m2_syn::TokenStream::new();
3430 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
3431 if !field_output.is_empty() {
3432 if !contents.is_empty()
3433 && !contents.ends_with_whitespace()
3434 && !field_output.starts_with_whitespace()
3435 {
3436 contents.push_trivia(::m2_syn::Trivia::new(
3437 ::m2_syn::TriviaKind::Whitespace,
3438 " ",
3439 ::m2_syn::Span::detached(),
3440 ));
3441 }
3442 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3443 }
3444 }
3445 {
3446 let mut field_output = ::m2_syn::TokenStream::new();
3447 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
3448 if !field_output.is_empty() {
3449 if !contents.is_empty()
3450 && !contents.ends_with_whitespace()
3451 && !field_output.starts_with_whitespace()
3452 {
3453 contents.push_trivia(::m2_syn::Trivia::new(
3454 ::m2_syn::TriviaKind::Whitespace,
3455 " ",
3456 ::m2_syn::Span::detached(),
3457 ));
3458 }
3459 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3460 }
3461 }
3462 {
3463 let mut field_output = ::m2_syn::TokenStream::new();
3464 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
3465 if !field_output.is_empty() {
3466 if !contents.is_empty()
3467 && !contents.ends_with_whitespace()
3468 && !field_output.starts_with_whitespace()
3469 {
3470 contents.push_trivia(::m2_syn::Trivia::new(
3471 ::m2_syn::TriviaKind::Whitespace,
3472 " ",
3473 ::m2_syn::Span::detached(),
3474 ));
3475 }
3476 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3477 }
3478 }
3479 ::m2_syn::ToTokens::to_tokens(&contents, output);
3480 }
3481}
3482impl ::m2_syn::PrettyTree for EvaluatedAssignment {
3483 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3484 let mut node = ::m2_syn::PrettyNode::syntax(
3485 stringify!(EvaluatedAssignment),
3486 ::m2_syn::Spanned::span(self),
3487 );
3488 node.push("left", &self.left);
3489 node.push("operator", &self.operator);
3490 node.push("right", &self.right);
3491 node
3492 }
3493}
3494impl<N> ::m2_syn::Reconstruct<N> for EvaluatedAssignment
3495where
3496 N: ::m2_syn::ExternalCstNode,
3497{
3498 fn matches(node: &N) -> bool {
3499 node.identity().matches("evaluated_assignment", true)
3500 }
3501 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3502 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3503 return Err(::m2_syn::ReconstructError::wrong_node(
3504 "evaluated_assignment",
3505 true,
3506 node.identity(),
3507 ));
3508 }
3509 let mut children = ::m2_syn::ChildCursor::new(&node);
3510 let left = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3511 children.required_field("left")?,
3512 )?);
3513 let operator = <Token![<-] as ::m2_syn::Reconstruct<N>>::reconstruct(
3514 children.required_field("operator")?,
3515 )?;
3516 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3517 children.required_field("right")?,
3518 )?);
3519 Ok(Self {
3520 left,
3521 operator,
3522 right,
3523 })
3524 }
3525}
3526#[derive(Debug, ::m2_syn::Spanned)]
3527pub struct OptionExpression {
3528 pub left: ::std::boxed::Box<Expr>,
3529 pub operator: Token![=>],
3530 pub right: ::std::boxed::Box<Expr>,
3531}
3532impl OptionExpression {
3533 pub fn new(left: Expr, operator: Token![=>], right: Expr) -> Self {
3534 {
3535 let left = ::std::boxed::Box::new(left);
3536 let right = ::std::boxed::Box::new(right);
3537 Self {
3538 left,
3539 operator,
3540 right,
3541 }
3542 }
3543 }
3544}
3545impl ::m2_syn::ToTokens for OptionExpression {
3546 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3547 let mut contents = ::m2_syn::TokenStream::new();
3548 {
3549 let mut field_output = ::m2_syn::TokenStream::new();
3550 ::m2_syn::ToTokens::to_tokens(&self.left, &mut field_output);
3551 if !field_output.is_empty() {
3552 if !contents.is_empty()
3553 && !contents.ends_with_whitespace()
3554 && !field_output.starts_with_whitespace()
3555 {
3556 contents.push_trivia(::m2_syn::Trivia::new(
3557 ::m2_syn::TriviaKind::Whitespace,
3558 " ",
3559 ::m2_syn::Span::detached(),
3560 ));
3561 }
3562 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3563 }
3564 }
3565 {
3566 let mut field_output = ::m2_syn::TokenStream::new();
3567 ::m2_syn::ToTokens::to_tokens(&self.operator, &mut field_output);
3568 if !field_output.is_empty() {
3569 if !contents.is_empty()
3570 && !contents.ends_with_whitespace()
3571 && !field_output.starts_with_whitespace()
3572 {
3573 contents.push_trivia(::m2_syn::Trivia::new(
3574 ::m2_syn::TriviaKind::Whitespace,
3575 " ",
3576 ::m2_syn::Span::detached(),
3577 ));
3578 }
3579 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3580 }
3581 }
3582 {
3583 let mut field_output = ::m2_syn::TokenStream::new();
3584 ::m2_syn::ToTokens::to_tokens(&self.right, &mut field_output);
3585 if !field_output.is_empty() {
3586 if !contents.is_empty()
3587 && !contents.ends_with_whitespace()
3588 && !field_output.starts_with_whitespace()
3589 {
3590 contents.push_trivia(::m2_syn::Trivia::new(
3591 ::m2_syn::TriviaKind::Whitespace,
3592 " ",
3593 ::m2_syn::Span::detached(),
3594 ));
3595 }
3596 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3597 }
3598 }
3599 ::m2_syn::ToTokens::to_tokens(&contents, output);
3600 }
3601}
3602impl ::m2_syn::PrettyTree for OptionExpression {
3603 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3604 let mut node = ::m2_syn::PrettyNode::syntax(
3605 stringify!(OptionExpression),
3606 ::m2_syn::Spanned::span(self),
3607 );
3608 node.push("left", &self.left);
3609 node.push("operator", &self.operator);
3610 node.push("right", &self.right);
3611 node
3612 }
3613}
3614impl<N> ::m2_syn::Reconstruct<N> for OptionExpression
3615where
3616 N: ::m2_syn::ExternalCstNode,
3617{
3618 fn matches(node: &N) -> bool {
3619 node.identity().matches("option", true)
3620 && node.children().any(|child| {
3621 child.field == Some("left")
3622 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
3623 })
3624 && node.children().any(|child| {
3625 child.field == Some("operator")
3626 && <Token![=>] as ::m2_syn::Reconstruct<N>>::matches(&child.node)
3627 })
3628 && node.children().any(|child| {
3629 child.field == Some("right")
3630 && <Expr as ::m2_syn::Reconstruct<N>>::matches(&child.node)
3631 })
3632 }
3633 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3634 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3635 return Err(::m2_syn::ReconstructError::wrong_node(
3636 "option",
3637 true,
3638 node.identity(),
3639 ));
3640 }
3641 let mut children = ::m2_syn::ChildCursor::new(&node);
3642 let left = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3643 children.required_field("left")?,
3644 )?);
3645 let operator = <Token![=>] as ::m2_syn::Reconstruct<N>>::reconstruct(
3646 children.required_field("operator")?,
3647 )?;
3648 let right = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3649 children.required_field("right")?,
3650 )?);
3651 Ok(Self {
3652 left,
3653 operator,
3654 right,
3655 })
3656 }
3657}
3658#[derive(Debug, ::m2_syn::Spanned)]
3659pub struct ThenClause {
3660 pub keyword: Token![then],
3661 pub value: ::std::boxed::Box<Expr>,
3662}
3663impl ThenClause {
3664 pub fn new(keyword: Token![then], value: Expr) -> Self {
3665 {
3666 let value = ::std::boxed::Box::new(value);
3667 Self { keyword, value }
3668 }
3669 }
3670}
3671impl ::m2_syn::ToTokens for ThenClause {
3672 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3673 let mut contents = ::m2_syn::TokenStream::new();
3674 {
3675 let mut field_output = ::m2_syn::TokenStream::new();
3676 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
3677 if !field_output.is_empty() {
3678 if !contents.is_empty()
3679 && !contents.ends_with_whitespace()
3680 && !field_output.starts_with_whitespace()
3681 {
3682 contents.push_trivia(::m2_syn::Trivia::new(
3683 ::m2_syn::TriviaKind::Whitespace,
3684 " ",
3685 ::m2_syn::Span::detached(),
3686 ));
3687 }
3688 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3689 }
3690 }
3691 {
3692 let mut field_output = ::m2_syn::TokenStream::new();
3693 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
3694 if !field_output.is_empty() {
3695 if !contents.is_empty()
3696 && !contents.ends_with_whitespace()
3697 && !field_output.starts_with_whitespace()
3698 {
3699 contents.push_trivia(::m2_syn::Trivia::new(
3700 ::m2_syn::TriviaKind::Whitespace,
3701 " ",
3702 ::m2_syn::Span::detached(),
3703 ));
3704 }
3705 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3706 }
3707 }
3708 ::m2_syn::ToTokens::to_tokens(&contents, output);
3709 }
3710}
3711impl ::m2_syn::PrettyTree for ThenClause {
3712 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3713 let mut node =
3714 ::m2_syn::PrettyNode::syntax(stringify!(ThenClause), ::m2_syn::Spanned::span(self));
3715 node.push("keyword", &self.keyword);
3716 node.push("value", &self.value);
3717 node
3718 }
3719}
3720impl<N> ::m2_syn::Reconstruct<N> for ThenClause
3721where
3722 N: ::m2_syn::ExternalCstNode,
3723{
3724 fn matches(node: &N) -> bool {
3725 node.identity().matches("then_clause", true)
3726 }
3727 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3728 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3729 return Err(::m2_syn::ReconstructError::wrong_node(
3730 "then_clause",
3731 true,
3732 node.identity(),
3733 ));
3734 }
3735 let mut children = ::m2_syn::ChildCursor::new(&node);
3736 let keyword = <Token![then] as ::m2_syn::Reconstruct<N>>::reconstruct(
3737 children.required_matching::<Token![then]>()?,
3738 )?;
3739 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3740 children.required_matching::<Expr>()?,
3741 )?);
3742 Ok(Self { keyword, value })
3743 }
3744}
3745#[derive(Debug, ::m2_syn::Spanned)]
3746pub struct ElseClause {
3747 pub keyword: Token![else],
3748 pub value: ::std::boxed::Box<Expr>,
3749}
3750impl ElseClause {
3751 pub fn new(keyword: Token![else], value: Expr) -> Self {
3752 {
3753 let value = ::std::boxed::Box::new(value);
3754 Self { keyword, value }
3755 }
3756 }
3757}
3758impl ::m2_syn::ToTokens for ElseClause {
3759 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3760 let mut contents = ::m2_syn::TokenStream::new();
3761 {
3762 let mut field_output = ::m2_syn::TokenStream::new();
3763 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
3764 if !field_output.is_empty() {
3765 if !contents.is_empty()
3766 && !contents.ends_with_whitespace()
3767 && !field_output.starts_with_whitespace()
3768 {
3769 contents.push_trivia(::m2_syn::Trivia::new(
3770 ::m2_syn::TriviaKind::Whitespace,
3771 " ",
3772 ::m2_syn::Span::detached(),
3773 ));
3774 }
3775 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3776 }
3777 }
3778 {
3779 let mut field_output = ::m2_syn::TokenStream::new();
3780 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
3781 if !field_output.is_empty() {
3782 if !contents.is_empty()
3783 && !contents.ends_with_whitespace()
3784 && !field_output.starts_with_whitespace()
3785 {
3786 contents.push_trivia(::m2_syn::Trivia::new(
3787 ::m2_syn::TriviaKind::Whitespace,
3788 " ",
3789 ::m2_syn::Span::detached(),
3790 ));
3791 }
3792 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3793 }
3794 }
3795 ::m2_syn::ToTokens::to_tokens(&contents, output);
3796 }
3797}
3798impl ::m2_syn::PrettyTree for ElseClause {
3799 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3800 let mut node =
3801 ::m2_syn::PrettyNode::syntax(stringify!(ElseClause), ::m2_syn::Spanned::span(self));
3802 node.push("keyword", &self.keyword);
3803 node.push("value", &self.value);
3804 node
3805 }
3806}
3807impl<N> ::m2_syn::Reconstruct<N> for ElseClause
3808where
3809 N: ::m2_syn::ExternalCstNode,
3810{
3811 fn matches(node: &N) -> bool {
3812 node.identity().matches("else_clause", true)
3813 }
3814 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3815 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3816 return Err(::m2_syn::ReconstructError::wrong_node(
3817 "else_clause",
3818 true,
3819 node.identity(),
3820 ));
3821 }
3822 let mut children = ::m2_syn::ChildCursor::new(&node);
3823 let keyword = <Token![else] as ::m2_syn::Reconstruct<N>>::reconstruct(
3824 children.required_matching::<Token![else]>()?,
3825 )?;
3826 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3827 children.required_matching::<Expr>()?,
3828 )?);
3829 Ok(Self { keyword, value })
3830 }
3831}
3832#[derive(Debug, ::m2_syn::Spanned)]
3833pub struct IfStatement {
3834 pub keyword: Token![if],
3835 pub condition: ::std::boxed::Box<Expr>,
3836 pub then_clause: ::std::boxed::Box<ThenClause>,
3837 pub else_clause: ::std::option::Option<::std::boxed::Box<ElseClause>>,
3838}
3839impl IfStatement {
3840 pub fn new(
3841 keyword: Token![if],
3842 condition: Expr,
3843 then_clause: ThenClause,
3844 else_clause: ::std::option::Option<ElseClause>,
3845 ) -> Self {
3846 {
3847 let condition = ::std::boxed::Box::new(condition);
3848 let then_clause = ::std::boxed::Box::new(then_clause);
3849 let else_clause = else_clause.map(::std::boxed::Box::new);
3850 Self {
3851 keyword,
3852 condition,
3853 then_clause,
3854 else_clause,
3855 }
3856 }
3857 }
3858}
3859impl ::m2_syn::ToTokens for IfStatement {
3860 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
3861 let mut contents = ::m2_syn::TokenStream::new();
3862 {
3863 let mut field_output = ::m2_syn::TokenStream::new();
3864 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
3865 if !field_output.is_empty() {
3866 if !contents.is_empty()
3867 && !contents.ends_with_whitespace()
3868 && !field_output.starts_with_whitespace()
3869 {
3870 contents.push_trivia(::m2_syn::Trivia::new(
3871 ::m2_syn::TriviaKind::Whitespace,
3872 " ",
3873 ::m2_syn::Span::detached(),
3874 ));
3875 }
3876 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3877 }
3878 }
3879 {
3880 let mut field_output = ::m2_syn::TokenStream::new();
3881 ::m2_syn::ToTokens::to_tokens(&self.condition, &mut field_output);
3882 if !field_output.is_empty() {
3883 if !contents.is_empty()
3884 && !contents.ends_with_whitespace()
3885 && !field_output.starts_with_whitespace()
3886 {
3887 contents.push_trivia(::m2_syn::Trivia::new(
3888 ::m2_syn::TriviaKind::Whitespace,
3889 " ",
3890 ::m2_syn::Span::detached(),
3891 ));
3892 }
3893 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3894 }
3895 }
3896 {
3897 let mut field_output = ::m2_syn::TokenStream::new();
3898 ::m2_syn::ToTokens::to_tokens(&self.then_clause, &mut field_output);
3899 if !field_output.is_empty() {
3900 if !contents.is_empty()
3901 && !contents.ends_with_whitespace()
3902 && !field_output.starts_with_whitespace()
3903 {
3904 contents.push_trivia(::m2_syn::Trivia::new(
3905 ::m2_syn::TriviaKind::Whitespace,
3906 " ",
3907 ::m2_syn::Span::detached(),
3908 ));
3909 }
3910 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3911 }
3912 }
3913 {
3914 let mut field_output = ::m2_syn::TokenStream::new();
3915 ::m2_syn::ToTokens::to_tokens(&self.else_clause, &mut field_output);
3916 if !field_output.is_empty() {
3917 if !contents.is_empty()
3918 && !contents.ends_with_whitespace()
3919 && !field_output.starts_with_whitespace()
3920 {
3921 contents.push_trivia(::m2_syn::Trivia::new(
3922 ::m2_syn::TriviaKind::Whitespace,
3923 " ",
3924 ::m2_syn::Span::detached(),
3925 ));
3926 }
3927 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
3928 }
3929 }
3930 ::m2_syn::ToTokens::to_tokens(&contents, output);
3931 }
3932}
3933impl ::m2_syn::PrettyTree for IfStatement {
3934 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
3935 let mut node =
3936 ::m2_syn::PrettyNode::syntax(stringify!(IfStatement), ::m2_syn::Spanned::span(self));
3937 node.push("keyword", &self.keyword);
3938 node.push("condition", &self.condition);
3939 node.push("then_clause", &self.then_clause);
3940 node.push("else_clause", &self.else_clause);
3941 node
3942 }
3943}
3944impl<N> ::m2_syn::Reconstruct<N> for IfStatement
3945where
3946 N: ::m2_syn::ExternalCstNode,
3947{
3948 fn matches(node: &N) -> bool {
3949 node.identity().matches("if_statement", true)
3950 }
3951 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
3952 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
3953 return Err(::m2_syn::ReconstructError::wrong_node(
3954 "if_statement",
3955 true,
3956 node.identity(),
3957 ));
3958 }
3959 let mut children = ::m2_syn::ChildCursor::new(&node);
3960 let keyword = <Token![if] as ::m2_syn::Reconstruct<N>>::reconstruct(
3961 children.required_matching::<Token![if]>()?,
3962 )?;
3963 let condition = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
3964 children.required_field("condition")?,
3965 )?);
3966 let then_clause =
3967 ::std::boxed::Box::new(<ThenClause as ::m2_syn::Reconstruct<N>>::reconstruct(
3968 children.required_matching::<ThenClause>()?,
3969 )?);
3970 let else_clause = children
3971 .optional_matching::<ElseClause>()
3972 .map(|node| {
3973 let value = <ElseClause as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
3974 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
3975 })
3976 .transpose()?;
3977 Ok(Self {
3978 keyword,
3979 condition,
3980 then_clause,
3981 else_clause,
3982 })
3983 }
3984}
3985#[derive(Debug, ::m2_syn::Spanned)]
3986pub struct LoopBody {
3987 pub list_keyword: ::std::option::Option<Token![list]>,
3988 pub listed_value: ::std::option::Option<::std::boxed::Box<Expr>>,
3989 pub do_keyword: ::std::option::Option<Token![do]>,
3990 pub ignored_value: ::std::option::Option<::std::boxed::Box<Expr>>,
3991}
3992impl LoopBody {
3993 pub fn new(
3994 list_keyword: ::std::option::Option<Token![list]>,
3995 listed_value: ::std::option::Option<Expr>,
3996 do_keyword: ::std::option::Option<Token![do]>,
3997 ignored_value: ::std::option::Option<Expr>,
3998 ) -> Self {
3999 {
4000 let listed_value = listed_value.map(::std::boxed::Box::new);
4001 let ignored_value = ignored_value.map(::std::boxed::Box::new);
4002 Self {
4003 list_keyword,
4004 listed_value,
4005 do_keyword,
4006 ignored_value,
4007 }
4008 }
4009 }
4010}
4011impl ::m2_syn::ToTokens for LoopBody {
4012 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4013 let mut contents = ::m2_syn::TokenStream::new();
4014 {
4015 let mut field_output = ::m2_syn::TokenStream::new();
4016 ::m2_syn::ToTokens::to_tokens(&self.list_keyword, &mut field_output);
4017 if !field_output.is_empty() {
4018 if !contents.is_empty()
4019 && !contents.ends_with_whitespace()
4020 && !field_output.starts_with_whitespace()
4021 {
4022 contents.push_trivia(::m2_syn::Trivia::new(
4023 ::m2_syn::TriviaKind::Whitespace,
4024 " ",
4025 ::m2_syn::Span::detached(),
4026 ));
4027 }
4028 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4029 }
4030 }
4031 {
4032 let mut field_output = ::m2_syn::TokenStream::new();
4033 ::m2_syn::ToTokens::to_tokens(&self.listed_value, &mut field_output);
4034 if !field_output.is_empty() {
4035 if !contents.is_empty()
4036 && !contents.ends_with_whitespace()
4037 && !field_output.starts_with_whitespace()
4038 {
4039 contents.push_trivia(::m2_syn::Trivia::new(
4040 ::m2_syn::TriviaKind::Whitespace,
4041 " ",
4042 ::m2_syn::Span::detached(),
4043 ));
4044 }
4045 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4046 }
4047 }
4048 {
4049 let mut field_output = ::m2_syn::TokenStream::new();
4050 ::m2_syn::ToTokens::to_tokens(&self.do_keyword, &mut field_output);
4051 if !field_output.is_empty() {
4052 if !contents.is_empty()
4053 && !contents.ends_with_whitespace()
4054 && !field_output.starts_with_whitespace()
4055 {
4056 contents.push_trivia(::m2_syn::Trivia::new(
4057 ::m2_syn::TriviaKind::Whitespace,
4058 " ",
4059 ::m2_syn::Span::detached(),
4060 ));
4061 }
4062 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4063 }
4064 }
4065 {
4066 let mut field_output = ::m2_syn::TokenStream::new();
4067 ::m2_syn::ToTokens::to_tokens(&self.ignored_value, &mut field_output);
4068 if !field_output.is_empty() {
4069 if !contents.is_empty()
4070 && !contents.ends_with_whitespace()
4071 && !field_output.starts_with_whitespace()
4072 {
4073 contents.push_trivia(::m2_syn::Trivia::new(
4074 ::m2_syn::TriviaKind::Whitespace,
4075 " ",
4076 ::m2_syn::Span::detached(),
4077 ));
4078 }
4079 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4080 }
4081 }
4082 ::m2_syn::ToTokens::to_tokens(&contents, output);
4083 }
4084}
4085impl ::m2_syn::PrettyTree for LoopBody {
4086 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4087 let mut node =
4088 ::m2_syn::PrettyNode::syntax(stringify!(LoopBody), ::m2_syn::Spanned::span(self));
4089 node.push("list_keyword", &self.list_keyword);
4090 node.push("listed_value", &self.listed_value);
4091 node.push("do_keyword", &self.do_keyword);
4092 node.push("ignored_value", &self.ignored_value);
4093 node
4094 }
4095}
4096impl<N> ::m2_syn::Reconstruct<N> for LoopBody
4097where
4098 N: ::m2_syn::ExternalCstNode,
4099{
4100 fn matches(node: &N) -> bool {
4101 node.identity().matches("loop_body", true)
4102 }
4103 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4104 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4105 return Err(::m2_syn::ReconstructError::wrong_node(
4106 "loop_body",
4107 true,
4108 node.identity(),
4109 ));
4110 }
4111 let mut children = ::m2_syn::ChildCursor::new(&node);
4112 let list_keyword = children
4113 .optional_matching::<Token![list]>()
4114 .map(|node| {
4115 let value = <Token![list] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4116 Ok::<_, ::m2_syn::ReconstructError>(value)
4117 })
4118 .transpose()?;
4119 let listed_value = children
4120 .optional_field("listed_value")
4121 .map(|node| {
4122 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4123 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4124 })
4125 .transpose()?;
4126 let do_keyword = children
4127 .optional_matching::<Token![do]>()
4128 .map(|node| {
4129 let value = <Token![do] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4130 Ok::<_, ::m2_syn::ReconstructError>(value)
4131 })
4132 .transpose()?;
4133 let ignored_value = children
4134 .optional_field("ignored_value")
4135 .map(|node| {
4136 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4137 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4138 })
4139 .transpose()?;
4140 Ok(Self {
4141 list_keyword,
4142 listed_value,
4143 do_keyword,
4144 ignored_value,
4145 })
4146 }
4147}
4148#[derive(Debug, ::m2_syn::Spanned)]
4149pub struct IterationRange {
4150 pub in_keyword: ::std::option::Option<Token![in]>,
4151 pub iterated_collection: ::std::option::Option<::std::boxed::Box<Expr>>,
4152 pub from_keyword: ::std::option::Option<Token![from]>,
4153 pub range_start: ::std::option::Option<::std::boxed::Box<Expr>>,
4154 pub to_keyword: ::std::option::Option<Token![to]>,
4155 pub range_end: ::std::option::Option<::std::boxed::Box<Expr>>,
4156}
4157impl IterationRange {
4158 pub fn new(
4159 in_keyword: ::std::option::Option<Token![in]>,
4160 iterated_collection: ::std::option::Option<Expr>,
4161 from_keyword: ::std::option::Option<Token![from]>,
4162 range_start: ::std::option::Option<Expr>,
4163 to_keyword: ::std::option::Option<Token![to]>,
4164 range_end: ::std::option::Option<Expr>,
4165 ) -> Self {
4166 {
4167 let iterated_collection = iterated_collection.map(::std::boxed::Box::new);
4168 let range_start = range_start.map(::std::boxed::Box::new);
4169 let range_end = range_end.map(::std::boxed::Box::new);
4170 Self {
4171 in_keyword,
4172 iterated_collection,
4173 from_keyword,
4174 range_start,
4175 to_keyword,
4176 range_end,
4177 }
4178 }
4179 }
4180}
4181impl ::m2_syn::ToTokens for IterationRange {
4182 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4183 let mut contents = ::m2_syn::TokenStream::new();
4184 {
4185 let mut field_output = ::m2_syn::TokenStream::new();
4186 ::m2_syn::ToTokens::to_tokens(&self.in_keyword, &mut field_output);
4187 if !field_output.is_empty() {
4188 if !contents.is_empty()
4189 && !contents.ends_with_whitespace()
4190 && !field_output.starts_with_whitespace()
4191 {
4192 contents.push_trivia(::m2_syn::Trivia::new(
4193 ::m2_syn::TriviaKind::Whitespace,
4194 " ",
4195 ::m2_syn::Span::detached(),
4196 ));
4197 }
4198 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4199 }
4200 }
4201 {
4202 let mut field_output = ::m2_syn::TokenStream::new();
4203 ::m2_syn::ToTokens::to_tokens(&self.iterated_collection, &mut field_output);
4204 if !field_output.is_empty() {
4205 if !contents.is_empty()
4206 && !contents.ends_with_whitespace()
4207 && !field_output.starts_with_whitespace()
4208 {
4209 contents.push_trivia(::m2_syn::Trivia::new(
4210 ::m2_syn::TriviaKind::Whitespace,
4211 " ",
4212 ::m2_syn::Span::detached(),
4213 ));
4214 }
4215 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4216 }
4217 }
4218 {
4219 let mut field_output = ::m2_syn::TokenStream::new();
4220 ::m2_syn::ToTokens::to_tokens(&self.from_keyword, &mut field_output);
4221 if !field_output.is_empty() {
4222 if !contents.is_empty()
4223 && !contents.ends_with_whitespace()
4224 && !field_output.starts_with_whitespace()
4225 {
4226 contents.push_trivia(::m2_syn::Trivia::new(
4227 ::m2_syn::TriviaKind::Whitespace,
4228 " ",
4229 ::m2_syn::Span::detached(),
4230 ));
4231 }
4232 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4233 }
4234 }
4235 {
4236 let mut field_output = ::m2_syn::TokenStream::new();
4237 ::m2_syn::ToTokens::to_tokens(&self.range_start, &mut field_output);
4238 if !field_output.is_empty() {
4239 if !contents.is_empty()
4240 && !contents.ends_with_whitespace()
4241 && !field_output.starts_with_whitespace()
4242 {
4243 contents.push_trivia(::m2_syn::Trivia::new(
4244 ::m2_syn::TriviaKind::Whitespace,
4245 " ",
4246 ::m2_syn::Span::detached(),
4247 ));
4248 }
4249 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4250 }
4251 }
4252 {
4253 let mut field_output = ::m2_syn::TokenStream::new();
4254 ::m2_syn::ToTokens::to_tokens(&self.to_keyword, &mut field_output);
4255 if !field_output.is_empty() {
4256 if !contents.is_empty()
4257 && !contents.ends_with_whitespace()
4258 && !field_output.starts_with_whitespace()
4259 {
4260 contents.push_trivia(::m2_syn::Trivia::new(
4261 ::m2_syn::TriviaKind::Whitespace,
4262 " ",
4263 ::m2_syn::Span::detached(),
4264 ));
4265 }
4266 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4267 }
4268 }
4269 {
4270 let mut field_output = ::m2_syn::TokenStream::new();
4271 ::m2_syn::ToTokens::to_tokens(&self.range_end, &mut field_output);
4272 if !field_output.is_empty() {
4273 if !contents.is_empty()
4274 && !contents.ends_with_whitespace()
4275 && !field_output.starts_with_whitespace()
4276 {
4277 contents.push_trivia(::m2_syn::Trivia::new(
4278 ::m2_syn::TriviaKind::Whitespace,
4279 " ",
4280 ::m2_syn::Span::detached(),
4281 ));
4282 }
4283 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4284 }
4285 }
4286 ::m2_syn::ToTokens::to_tokens(&contents, output);
4287 }
4288}
4289impl ::m2_syn::PrettyTree for IterationRange {
4290 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4291 let mut node =
4292 ::m2_syn::PrettyNode::syntax(stringify!(IterationRange), ::m2_syn::Spanned::span(self));
4293 node.push("in_keyword", &self.in_keyword);
4294 node.push("iterated_collection", &self.iterated_collection);
4295 node.push("from_keyword", &self.from_keyword);
4296 node.push("range_start", &self.range_start);
4297 node.push("to_keyword", &self.to_keyword);
4298 node.push("range_end", &self.range_end);
4299 node
4300 }
4301}
4302impl<N> ::m2_syn::Reconstruct<N> for IterationRange
4303where
4304 N: ::m2_syn::ExternalCstNode,
4305{
4306 fn matches(node: &N) -> bool {
4307 node.identity().matches("iteration_range", true)
4308 }
4309 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4310 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4311 return Err(::m2_syn::ReconstructError::wrong_node(
4312 "iteration_range",
4313 true,
4314 node.identity(),
4315 ));
4316 }
4317 let mut children = ::m2_syn::ChildCursor::new(&node);
4318 let in_keyword = children
4319 .optional_matching::<Token![in]>()
4320 .map(|node| {
4321 let value = <Token![in] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4322 Ok::<_, ::m2_syn::ReconstructError>(value)
4323 })
4324 .transpose()?;
4325 let iterated_collection = children
4326 .optional_field("iterated_collection")
4327 .map(|node| {
4328 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4329 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4330 })
4331 .transpose()?;
4332 let from_keyword = children
4333 .optional_matching::<Token![from]>()
4334 .map(|node| {
4335 let value = <Token![from] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4336 Ok::<_, ::m2_syn::ReconstructError>(value)
4337 })
4338 .transpose()?;
4339 let range_start = children
4340 .optional_field("range_start")
4341 .map(|node| {
4342 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4343 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4344 })
4345 .transpose()?;
4346 let to_keyword = children
4347 .optional_matching::<Token![to]>()
4348 .map(|node| {
4349 let value = <Token![to] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4350 Ok::<_, ::m2_syn::ReconstructError>(value)
4351 })
4352 .transpose()?;
4353 let range_end = children
4354 .optional_field("range_end")
4355 .map(|node| {
4356 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4357 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4358 })
4359 .transpose()?;
4360 Ok(Self {
4361 in_keyword,
4362 iterated_collection,
4363 from_keyword,
4364 range_start,
4365 to_keyword,
4366 range_end,
4367 })
4368 }
4369}
4370#[derive(Debug, ::m2_syn::Spanned)]
4371pub struct ForLoop {
4372 pub keyword: Token![for],
4373 pub variable: ::std::boxed::Box<Symbol>,
4374 pub range: ::std::option::Option<::std::boxed::Box<IterationRange>>,
4375 pub when_keyword: ::std::option::Option<Token![when]>,
4376 pub filter: ::std::option::Option<::std::boxed::Box<Expr>>,
4377 pub body: ::std::boxed::Box<LoopBody>,
4378}
4379impl ForLoop {
4380 pub fn new(
4381 keyword: Token![for],
4382 variable: Symbol,
4383 range: ::std::option::Option<IterationRange>,
4384 when_keyword: ::std::option::Option<Token![when]>,
4385 filter: ::std::option::Option<Expr>,
4386 body: LoopBody,
4387 ) -> Self {
4388 {
4389 let variable = ::std::boxed::Box::new(variable);
4390 let range = range.map(::std::boxed::Box::new);
4391 let filter = filter.map(::std::boxed::Box::new);
4392 let body = ::std::boxed::Box::new(body);
4393 Self {
4394 keyword,
4395 variable,
4396 range,
4397 when_keyword,
4398 filter,
4399 body,
4400 }
4401 }
4402 }
4403}
4404impl ::m2_syn::ToTokens for ForLoop {
4405 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4406 let mut contents = ::m2_syn::TokenStream::new();
4407 {
4408 let mut field_output = ::m2_syn::TokenStream::new();
4409 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
4410 if !field_output.is_empty() {
4411 if !contents.is_empty()
4412 && !contents.ends_with_whitespace()
4413 && !field_output.starts_with_whitespace()
4414 {
4415 contents.push_trivia(::m2_syn::Trivia::new(
4416 ::m2_syn::TriviaKind::Whitespace,
4417 " ",
4418 ::m2_syn::Span::detached(),
4419 ));
4420 }
4421 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4422 }
4423 }
4424 {
4425 let mut field_output = ::m2_syn::TokenStream::new();
4426 ::m2_syn::ToTokens::to_tokens(&self.variable, &mut field_output);
4427 if !field_output.is_empty() {
4428 if !contents.is_empty()
4429 && !contents.ends_with_whitespace()
4430 && !field_output.starts_with_whitespace()
4431 {
4432 contents.push_trivia(::m2_syn::Trivia::new(
4433 ::m2_syn::TriviaKind::Whitespace,
4434 " ",
4435 ::m2_syn::Span::detached(),
4436 ));
4437 }
4438 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4439 }
4440 }
4441 {
4442 let mut field_output = ::m2_syn::TokenStream::new();
4443 ::m2_syn::ToTokens::to_tokens(&self.range, &mut field_output);
4444 if !field_output.is_empty() {
4445 if !contents.is_empty()
4446 && !contents.ends_with_whitespace()
4447 && !field_output.starts_with_whitespace()
4448 {
4449 contents.push_trivia(::m2_syn::Trivia::new(
4450 ::m2_syn::TriviaKind::Whitespace,
4451 " ",
4452 ::m2_syn::Span::detached(),
4453 ));
4454 }
4455 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4456 }
4457 }
4458 {
4459 let mut field_output = ::m2_syn::TokenStream::new();
4460 ::m2_syn::ToTokens::to_tokens(&self.when_keyword, &mut field_output);
4461 if !field_output.is_empty() {
4462 if !contents.is_empty()
4463 && !contents.ends_with_whitespace()
4464 && !field_output.starts_with_whitespace()
4465 {
4466 contents.push_trivia(::m2_syn::Trivia::new(
4467 ::m2_syn::TriviaKind::Whitespace,
4468 " ",
4469 ::m2_syn::Span::detached(),
4470 ));
4471 }
4472 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4473 }
4474 }
4475 {
4476 let mut field_output = ::m2_syn::TokenStream::new();
4477 ::m2_syn::ToTokens::to_tokens(&self.filter, &mut field_output);
4478 if !field_output.is_empty() {
4479 if !contents.is_empty()
4480 && !contents.ends_with_whitespace()
4481 && !field_output.starts_with_whitespace()
4482 {
4483 contents.push_trivia(::m2_syn::Trivia::new(
4484 ::m2_syn::TriviaKind::Whitespace,
4485 " ",
4486 ::m2_syn::Span::detached(),
4487 ));
4488 }
4489 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4490 }
4491 }
4492 {
4493 let mut field_output = ::m2_syn::TokenStream::new();
4494 ::m2_syn::ToTokens::to_tokens(&self.body, &mut field_output);
4495 if !field_output.is_empty() {
4496 if !contents.is_empty()
4497 && !contents.ends_with_whitespace()
4498 && !field_output.starts_with_whitespace()
4499 {
4500 contents.push_trivia(::m2_syn::Trivia::new(
4501 ::m2_syn::TriviaKind::Whitespace,
4502 " ",
4503 ::m2_syn::Span::detached(),
4504 ));
4505 }
4506 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4507 }
4508 }
4509 ::m2_syn::ToTokens::to_tokens(&contents, output);
4510 }
4511}
4512impl ::m2_syn::PrettyTree for ForLoop {
4513 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4514 let mut node =
4515 ::m2_syn::PrettyNode::syntax(stringify!(ForLoop), ::m2_syn::Spanned::span(self));
4516 node.push("keyword", &self.keyword);
4517 node.push("variable", &self.variable);
4518 node.push("range", &self.range);
4519 node.push("when_keyword", &self.when_keyword);
4520 node.push("filter", &self.filter);
4521 node.push("body", &self.body);
4522 node
4523 }
4524}
4525impl<N> ::m2_syn::Reconstruct<N> for ForLoop
4526where
4527 N: ::m2_syn::ExternalCstNode,
4528{
4529 fn matches(node: &N) -> bool {
4530 node.identity().matches("for_loop", true)
4531 }
4532 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4533 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4534 return Err(::m2_syn::ReconstructError::wrong_node(
4535 "for_loop",
4536 true,
4537 node.identity(),
4538 ));
4539 }
4540 let mut children = ::m2_syn::ChildCursor::new(&node);
4541 let keyword = <Token![for] as ::m2_syn::Reconstruct<N>>::reconstruct(
4542 children.required_matching::<Token![for]>()?,
4543 )?;
4544 let variable = ::std::boxed::Box::new(<Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(
4545 children.required_field("variable")?,
4546 )?);
4547 let range = children
4548 .optional_matching::<IterationRange>()
4549 .map(|node| {
4550 let value = <IterationRange as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4551 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4552 })
4553 .transpose()?;
4554 let when_keyword = children
4555 .optional_matching::<Token![when]>()
4556 .map(|node| {
4557 let value = <Token![when] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4558 Ok::<_, ::m2_syn::ReconstructError>(value)
4559 })
4560 .transpose()?;
4561 let filter = children
4562 .optional_field("filter")
4563 .map(|node| {
4564 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4565 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4566 })
4567 .transpose()?;
4568 let body = ::std::boxed::Box::new(<LoopBody as ::m2_syn::Reconstruct<N>>::reconstruct(
4569 children.required_matching::<LoopBody>()?,
4570 )?);
4571 Ok(Self {
4572 keyword,
4573 variable,
4574 range,
4575 when_keyword,
4576 filter,
4577 body,
4578 })
4579 }
4580}
4581#[derive(Debug, ::m2_syn::Spanned)]
4582pub struct WhileLoop {
4583 pub keyword: Token![while],
4584 pub condition: ::std::boxed::Box<Expr>,
4585 pub body: ::std::boxed::Box<LoopBody>,
4586}
4587impl WhileLoop {
4588 pub fn new(keyword: Token![while], condition: Expr, body: LoopBody) -> Self {
4589 {
4590 let condition = ::std::boxed::Box::new(condition);
4591 let body = ::std::boxed::Box::new(body);
4592 Self {
4593 keyword,
4594 condition,
4595 body,
4596 }
4597 }
4598 }
4599}
4600impl ::m2_syn::ToTokens for WhileLoop {
4601 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4602 let mut contents = ::m2_syn::TokenStream::new();
4603 {
4604 let mut field_output = ::m2_syn::TokenStream::new();
4605 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
4606 if !field_output.is_empty() {
4607 if !contents.is_empty()
4608 && !contents.ends_with_whitespace()
4609 && !field_output.starts_with_whitespace()
4610 {
4611 contents.push_trivia(::m2_syn::Trivia::new(
4612 ::m2_syn::TriviaKind::Whitespace,
4613 " ",
4614 ::m2_syn::Span::detached(),
4615 ));
4616 }
4617 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4618 }
4619 }
4620 {
4621 let mut field_output = ::m2_syn::TokenStream::new();
4622 ::m2_syn::ToTokens::to_tokens(&self.condition, &mut field_output);
4623 if !field_output.is_empty() {
4624 if !contents.is_empty()
4625 && !contents.ends_with_whitespace()
4626 && !field_output.starts_with_whitespace()
4627 {
4628 contents.push_trivia(::m2_syn::Trivia::new(
4629 ::m2_syn::TriviaKind::Whitespace,
4630 " ",
4631 ::m2_syn::Span::detached(),
4632 ));
4633 }
4634 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4635 }
4636 }
4637 {
4638 let mut field_output = ::m2_syn::TokenStream::new();
4639 ::m2_syn::ToTokens::to_tokens(&self.body, &mut field_output);
4640 if !field_output.is_empty() {
4641 if !contents.is_empty()
4642 && !contents.ends_with_whitespace()
4643 && !field_output.starts_with_whitespace()
4644 {
4645 contents.push_trivia(::m2_syn::Trivia::new(
4646 ::m2_syn::TriviaKind::Whitespace,
4647 " ",
4648 ::m2_syn::Span::detached(),
4649 ));
4650 }
4651 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4652 }
4653 }
4654 ::m2_syn::ToTokens::to_tokens(&contents, output);
4655 }
4656}
4657impl ::m2_syn::PrettyTree for WhileLoop {
4658 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4659 let mut node =
4660 ::m2_syn::PrettyNode::syntax(stringify!(WhileLoop), ::m2_syn::Spanned::span(self));
4661 node.push("keyword", &self.keyword);
4662 node.push("condition", &self.condition);
4663 node.push("body", &self.body);
4664 node
4665 }
4666}
4667impl<N> ::m2_syn::Reconstruct<N> for WhileLoop
4668where
4669 N: ::m2_syn::ExternalCstNode,
4670{
4671 fn matches(node: &N) -> bool {
4672 node.identity().matches("while_loop", true)
4673 }
4674 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4675 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4676 return Err(::m2_syn::ReconstructError::wrong_node(
4677 "while_loop",
4678 true,
4679 node.identity(),
4680 ));
4681 }
4682 let mut children = ::m2_syn::ChildCursor::new(&node);
4683 let keyword = <Token![while] as ::m2_syn::Reconstruct<N>>::reconstruct(
4684 children.required_matching::<Token![while]>()?,
4685 )?;
4686 let condition = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
4687 children.required_field("condition")?,
4688 )?);
4689 let body = ::std::boxed::Box::new(<LoopBody as ::m2_syn::Reconstruct<N>>::reconstruct(
4690 children.required_matching::<LoopBody>()?,
4691 )?);
4692 Ok(Self {
4693 keyword,
4694 condition,
4695 body,
4696 })
4697 }
4698}
4699#[derive(Debug, ::m2_syn::Spanned)]
4700pub struct NewStatement {
4701 pub keyword: Token![new],
4702 pub class: ::std::boxed::Box<Expr>,
4703 pub of_keyword: ::std::option::Option<Token![of]>,
4704 pub parent: ::std::option::Option<::std::boxed::Box<Expr>>,
4705 pub from_keyword: ::std::option::Option<Token![from]>,
4706 pub instance: ::std::option::Option<::std::boxed::Box<Expr>>,
4707}
4708impl NewStatement {
4709 pub fn new(
4710 keyword: Token![new],
4711 class: Expr,
4712 of_keyword: ::std::option::Option<Token![of]>,
4713 parent: ::std::option::Option<Expr>,
4714 from_keyword: ::std::option::Option<Token![from]>,
4715 instance: ::std::option::Option<Expr>,
4716 ) -> Self {
4717 {
4718 let class = ::std::boxed::Box::new(class);
4719 let parent = parent.map(::std::boxed::Box::new);
4720 let instance = instance.map(::std::boxed::Box::new);
4721 Self {
4722 keyword,
4723 class,
4724 of_keyword,
4725 parent,
4726 from_keyword,
4727 instance,
4728 }
4729 }
4730 }
4731}
4732impl ::m2_syn::ToTokens for NewStatement {
4733 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4734 let mut contents = ::m2_syn::TokenStream::new();
4735 {
4736 let mut field_output = ::m2_syn::TokenStream::new();
4737 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
4738 if !field_output.is_empty() {
4739 if !contents.is_empty()
4740 && !contents.ends_with_whitespace()
4741 && !field_output.starts_with_whitespace()
4742 {
4743 contents.push_trivia(::m2_syn::Trivia::new(
4744 ::m2_syn::TriviaKind::Whitespace,
4745 " ",
4746 ::m2_syn::Span::detached(),
4747 ));
4748 }
4749 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4750 }
4751 }
4752 {
4753 let mut field_output = ::m2_syn::TokenStream::new();
4754 ::m2_syn::ToTokens::to_tokens(&self.class, &mut field_output);
4755 if !field_output.is_empty() {
4756 if !contents.is_empty()
4757 && !contents.ends_with_whitespace()
4758 && !field_output.starts_with_whitespace()
4759 {
4760 contents.push_trivia(::m2_syn::Trivia::new(
4761 ::m2_syn::TriviaKind::Whitespace,
4762 " ",
4763 ::m2_syn::Span::detached(),
4764 ));
4765 }
4766 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4767 }
4768 }
4769 {
4770 let mut field_output = ::m2_syn::TokenStream::new();
4771 ::m2_syn::ToTokens::to_tokens(&self.of_keyword, &mut field_output);
4772 if !field_output.is_empty() {
4773 if !contents.is_empty()
4774 && !contents.ends_with_whitespace()
4775 && !field_output.starts_with_whitespace()
4776 {
4777 contents.push_trivia(::m2_syn::Trivia::new(
4778 ::m2_syn::TriviaKind::Whitespace,
4779 " ",
4780 ::m2_syn::Span::detached(),
4781 ));
4782 }
4783 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4784 }
4785 }
4786 {
4787 let mut field_output = ::m2_syn::TokenStream::new();
4788 ::m2_syn::ToTokens::to_tokens(&self.parent, &mut field_output);
4789 if !field_output.is_empty() {
4790 if !contents.is_empty()
4791 && !contents.ends_with_whitespace()
4792 && !field_output.starts_with_whitespace()
4793 {
4794 contents.push_trivia(::m2_syn::Trivia::new(
4795 ::m2_syn::TriviaKind::Whitespace,
4796 " ",
4797 ::m2_syn::Span::detached(),
4798 ));
4799 }
4800 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4801 }
4802 }
4803 {
4804 let mut field_output = ::m2_syn::TokenStream::new();
4805 ::m2_syn::ToTokens::to_tokens(&self.from_keyword, &mut field_output);
4806 if !field_output.is_empty() {
4807 if !contents.is_empty()
4808 && !contents.ends_with_whitespace()
4809 && !field_output.starts_with_whitespace()
4810 {
4811 contents.push_trivia(::m2_syn::Trivia::new(
4812 ::m2_syn::TriviaKind::Whitespace,
4813 " ",
4814 ::m2_syn::Span::detached(),
4815 ));
4816 }
4817 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4818 }
4819 }
4820 {
4821 let mut field_output = ::m2_syn::TokenStream::new();
4822 ::m2_syn::ToTokens::to_tokens(&self.instance, &mut field_output);
4823 if !field_output.is_empty() {
4824 if !contents.is_empty()
4825 && !contents.ends_with_whitespace()
4826 && !field_output.starts_with_whitespace()
4827 {
4828 contents.push_trivia(::m2_syn::Trivia::new(
4829 ::m2_syn::TriviaKind::Whitespace,
4830 " ",
4831 ::m2_syn::Span::detached(),
4832 ));
4833 }
4834 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4835 }
4836 }
4837 ::m2_syn::ToTokens::to_tokens(&contents, output);
4838 }
4839}
4840impl ::m2_syn::PrettyTree for NewStatement {
4841 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4842 let mut node =
4843 ::m2_syn::PrettyNode::syntax(stringify!(NewStatement), ::m2_syn::Spanned::span(self));
4844 node.push("keyword", &self.keyword);
4845 node.push("class", &self.class);
4846 node.push("of_keyword", &self.of_keyword);
4847 node.push("parent", &self.parent);
4848 node.push("from_keyword", &self.from_keyword);
4849 node.push("instance", &self.instance);
4850 node
4851 }
4852}
4853impl<N> ::m2_syn::Reconstruct<N> for NewStatement
4854where
4855 N: ::m2_syn::ExternalCstNode,
4856{
4857 fn matches(node: &N) -> bool {
4858 node.identity().matches("new_statement", true)
4859 }
4860 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4861 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4862 return Err(::m2_syn::ReconstructError::wrong_node(
4863 "new_statement",
4864 true,
4865 node.identity(),
4866 ));
4867 }
4868 let mut children = ::m2_syn::ChildCursor::new(&node);
4869 let keyword = <Token![new] as ::m2_syn::Reconstruct<N>>::reconstruct(
4870 children.required_matching::<Token![new]>()?,
4871 )?;
4872 let class = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
4873 children.required_field("class")?,
4874 )?);
4875 let of_keyword = children
4876 .optional_matching::<Token![of]>()
4877 .map(|node| {
4878 let value = <Token![of] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4879 Ok::<_, ::m2_syn::ReconstructError>(value)
4880 })
4881 .transpose()?;
4882 let parent = children
4883 .optional_field("parent")
4884 .map(|node| {
4885 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4886 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4887 })
4888 .transpose()?;
4889 let from_keyword = children
4890 .optional_matching::<Token![from]>()
4891 .map(|node| {
4892 let value = <Token![from] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4893 Ok::<_, ::m2_syn::ReconstructError>(value)
4894 })
4895 .transpose()?;
4896 let instance = children
4897 .optional_field("instance")
4898 .map(|node| {
4899 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4900 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4901 })
4902 .transpose()?;
4903 Ok(Self {
4904 keyword,
4905 class,
4906 of_keyword,
4907 parent,
4908 from_keyword,
4909 instance,
4910 })
4911 }
4912}
4913#[derive(Debug, ::m2_syn::Spanned)]
4914pub struct DebugClause {
4915 pub keyword: DebugKeyword,
4916 pub value: ::std::option::Option<::std::boxed::Box<Expr>>,
4917}
4918impl DebugClause {
4919 pub fn new(keyword: DebugKeyword, value: ::std::option::Option<Expr>) -> Self {
4920 {
4921 let value = value.map(::std::boxed::Box::new);
4922 Self { keyword, value }
4923 }
4924 }
4925}
4926impl ::m2_syn::ToTokens for DebugClause {
4927 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
4928 let mut contents = ::m2_syn::TokenStream::new();
4929 {
4930 let mut field_output = ::m2_syn::TokenStream::new();
4931 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
4932 if !field_output.is_empty() {
4933 if !contents.is_empty()
4934 && !contents.ends_with_whitespace()
4935 && !field_output.starts_with_whitespace()
4936 {
4937 contents.push_trivia(::m2_syn::Trivia::new(
4938 ::m2_syn::TriviaKind::Whitespace,
4939 " ",
4940 ::m2_syn::Span::detached(),
4941 ));
4942 }
4943 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4944 }
4945 }
4946 {
4947 let mut field_output = ::m2_syn::TokenStream::new();
4948 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
4949 if !field_output.is_empty() {
4950 if !contents.is_empty()
4951 && !contents.ends_with_whitespace()
4952 && !field_output.starts_with_whitespace()
4953 {
4954 contents.push_trivia(::m2_syn::Trivia::new(
4955 ::m2_syn::TriviaKind::Whitespace,
4956 " ",
4957 ::m2_syn::Span::detached(),
4958 ));
4959 }
4960 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
4961 }
4962 }
4963 ::m2_syn::ToTokens::to_tokens(&contents, output);
4964 }
4965}
4966impl ::m2_syn::PrettyTree for DebugClause {
4967 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
4968 let mut node =
4969 ::m2_syn::PrettyNode::syntax(stringify!(DebugClause), ::m2_syn::Spanned::span(self));
4970 node.push("keyword", &self.keyword);
4971 node.push("value", &self.value);
4972 node
4973 }
4974}
4975impl<N> ::m2_syn::Reconstruct<N> for DebugClause
4976where
4977 N: ::m2_syn::ExternalCstNode,
4978{
4979 fn matches(node: &N) -> bool {
4980 node.identity().matches("debug_clause", true)
4981 }
4982 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
4983 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
4984 return Err(::m2_syn::ReconstructError::wrong_node(
4985 "debug_clause",
4986 true,
4987 node.identity(),
4988 ));
4989 }
4990 let mut children = ::m2_syn::ChildCursor::new(&node);
4991 let keyword = <DebugKeyword as ::m2_syn::Reconstruct<N>>::reconstruct(
4992 children.required_field("keyword")?,
4993 )?;
4994 let value = children
4995 .optional_matching::<Expr>()
4996 .map(|node| {
4997 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
4998 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
4999 })
5000 .transpose()?;
5001 Ok(Self { keyword, value })
5002 }
5003}
5004#[derive(Debug, ::m2_syn::Spanned)]
5005pub struct BreakStatement {
5006 pub keyword: Token![break],
5007 pub value: ::std::option::Option<::std::boxed::Box<Expr>>,
5008}
5009impl BreakStatement {
5010 pub fn new(keyword: Token![break], value: ::std::option::Option<Expr>) -> Self {
5011 {
5012 let value = value.map(::std::boxed::Box::new);
5013 Self { keyword, value }
5014 }
5015 }
5016}
5017impl ::m2_syn::ToTokens for BreakStatement {
5018 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5019 let mut contents = ::m2_syn::TokenStream::new();
5020 {
5021 let mut field_output = ::m2_syn::TokenStream::new();
5022 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5023 if !field_output.is_empty() {
5024 if !contents.is_empty()
5025 && !contents.ends_with_whitespace()
5026 && !field_output.starts_with_whitespace()
5027 {
5028 contents.push_trivia(::m2_syn::Trivia::new(
5029 ::m2_syn::TriviaKind::Whitespace,
5030 " ",
5031 ::m2_syn::Span::detached(),
5032 ));
5033 }
5034 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5035 }
5036 }
5037 {
5038 let mut field_output = ::m2_syn::TokenStream::new();
5039 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5040 if !field_output.is_empty() {
5041 if !contents.is_empty()
5042 && !contents.ends_with_whitespace()
5043 && !field_output.starts_with_whitespace()
5044 {
5045 contents.push_trivia(::m2_syn::Trivia::new(
5046 ::m2_syn::TriviaKind::Whitespace,
5047 " ",
5048 ::m2_syn::Span::detached(),
5049 ));
5050 }
5051 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5052 }
5053 }
5054 ::m2_syn::ToTokens::to_tokens(&contents, output);
5055 }
5056}
5057impl ::m2_syn::PrettyTree for BreakStatement {
5058 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5059 let mut node =
5060 ::m2_syn::PrettyNode::syntax(stringify!(BreakStatement), ::m2_syn::Spanned::span(self));
5061 node.push("keyword", &self.keyword);
5062 node.push("value", &self.value);
5063 node
5064 }
5065}
5066impl<N> ::m2_syn::Reconstruct<N> for BreakStatement
5067where
5068 N: ::m2_syn::ExternalCstNode,
5069{
5070 fn matches(node: &N) -> bool {
5071 node.identity().matches("break_statement", true)
5072 }
5073 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5074 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5075 return Err(::m2_syn::ReconstructError::wrong_node(
5076 "break_statement",
5077 true,
5078 node.identity(),
5079 ));
5080 }
5081 let mut children = ::m2_syn::ChildCursor::new(&node);
5082 let keyword = <Token![break] as ::m2_syn::Reconstruct<N>>::reconstruct(
5083 children.required_matching::<Token![break]>()?,
5084 )?;
5085 let value = children
5086 .optional_matching::<Expr>()
5087 .map(|node| {
5088 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
5089 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
5090 })
5091 .transpose()?;
5092 Ok(Self { keyword, value })
5093 }
5094}
5095#[derive(Debug, ::m2_syn::Spanned)]
5096pub struct ContinueStatement {
5097 pub keyword: Token![continue],
5098 pub value: ::std::option::Option<::std::boxed::Box<Expr>>,
5099}
5100impl ContinueStatement {
5101 pub fn new(keyword: Token![continue], value: ::std::option::Option<Expr>) -> Self {
5102 {
5103 let value = value.map(::std::boxed::Box::new);
5104 Self { keyword, value }
5105 }
5106 }
5107}
5108impl ::m2_syn::ToTokens for ContinueStatement {
5109 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5110 let mut contents = ::m2_syn::TokenStream::new();
5111 {
5112 let mut field_output = ::m2_syn::TokenStream::new();
5113 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5114 if !field_output.is_empty() {
5115 if !contents.is_empty()
5116 && !contents.ends_with_whitespace()
5117 && !field_output.starts_with_whitespace()
5118 {
5119 contents.push_trivia(::m2_syn::Trivia::new(
5120 ::m2_syn::TriviaKind::Whitespace,
5121 " ",
5122 ::m2_syn::Span::detached(),
5123 ));
5124 }
5125 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5126 }
5127 }
5128 {
5129 let mut field_output = ::m2_syn::TokenStream::new();
5130 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5131 if !field_output.is_empty() {
5132 if !contents.is_empty()
5133 && !contents.ends_with_whitespace()
5134 && !field_output.starts_with_whitespace()
5135 {
5136 contents.push_trivia(::m2_syn::Trivia::new(
5137 ::m2_syn::TriviaKind::Whitespace,
5138 " ",
5139 ::m2_syn::Span::detached(),
5140 ));
5141 }
5142 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5143 }
5144 }
5145 ::m2_syn::ToTokens::to_tokens(&contents, output);
5146 }
5147}
5148impl ::m2_syn::PrettyTree for ContinueStatement {
5149 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5150 let mut node = ::m2_syn::PrettyNode::syntax(
5151 stringify!(ContinueStatement),
5152 ::m2_syn::Spanned::span(self),
5153 );
5154 node.push("keyword", &self.keyword);
5155 node.push("value", &self.value);
5156 node
5157 }
5158}
5159impl<N> ::m2_syn::Reconstruct<N> for ContinueStatement
5160where
5161 N: ::m2_syn::ExternalCstNode,
5162{
5163 fn matches(node: &N) -> bool {
5164 node.identity().matches("continue_statement", true)
5165 }
5166 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5167 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5168 return Err(::m2_syn::ReconstructError::wrong_node(
5169 "continue_statement",
5170 true,
5171 node.identity(),
5172 ));
5173 }
5174 let mut children = ::m2_syn::ChildCursor::new(&node);
5175 let keyword = <Token![continue] as ::m2_syn::Reconstruct<N>>::reconstruct(
5176 children.required_matching::<Token![continue]>()?,
5177 )?;
5178 let value = children
5179 .optional_matching::<Expr>()
5180 .map(|node| {
5181 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
5182 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
5183 })
5184 .transpose()?;
5185 Ok(Self { keyword, value })
5186 }
5187}
5188#[derive(Debug, ::m2_syn::Spanned)]
5189pub struct ReturnStatement {
5190 pub keyword: Token![return],
5191 pub value: ::std::option::Option<::std::boxed::Box<Expr>>,
5192}
5193impl ReturnStatement {
5194 pub fn new(keyword: Token![return], value: ::std::option::Option<Expr>) -> Self {
5195 {
5196 let value = value.map(::std::boxed::Box::new);
5197 Self { keyword, value }
5198 }
5199 }
5200}
5201impl ::m2_syn::ToTokens for ReturnStatement {
5202 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5203 let mut contents = ::m2_syn::TokenStream::new();
5204 {
5205 let mut field_output = ::m2_syn::TokenStream::new();
5206 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5207 if !field_output.is_empty() {
5208 if !contents.is_empty()
5209 && !contents.ends_with_whitespace()
5210 && !field_output.starts_with_whitespace()
5211 {
5212 contents.push_trivia(::m2_syn::Trivia::new(
5213 ::m2_syn::TriviaKind::Whitespace,
5214 " ",
5215 ::m2_syn::Span::detached(),
5216 ));
5217 }
5218 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5219 }
5220 }
5221 {
5222 let mut field_output = ::m2_syn::TokenStream::new();
5223 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5224 if !field_output.is_empty() {
5225 if !contents.is_empty()
5226 && !contents.ends_with_whitespace()
5227 && !field_output.starts_with_whitespace()
5228 {
5229 contents.push_trivia(::m2_syn::Trivia::new(
5230 ::m2_syn::TriviaKind::Whitespace,
5231 " ",
5232 ::m2_syn::Span::detached(),
5233 ));
5234 }
5235 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5236 }
5237 }
5238 ::m2_syn::ToTokens::to_tokens(&contents, output);
5239 }
5240}
5241impl ::m2_syn::PrettyTree for ReturnStatement {
5242 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5243 let mut node = ::m2_syn::PrettyNode::syntax(
5244 stringify!(ReturnStatement),
5245 ::m2_syn::Spanned::span(self),
5246 );
5247 node.push("keyword", &self.keyword);
5248 node.push("value", &self.value);
5249 node
5250 }
5251}
5252impl<N> ::m2_syn::Reconstruct<N> for ReturnStatement
5253where
5254 N: ::m2_syn::ExternalCstNode,
5255{
5256 fn matches(node: &N) -> bool {
5257 node.identity().matches("return_statement", true)
5258 }
5259 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5260 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5261 return Err(::m2_syn::ReconstructError::wrong_node(
5262 "return_statement",
5263 true,
5264 node.identity(),
5265 ));
5266 }
5267 let mut children = ::m2_syn::ChildCursor::new(&node);
5268 let keyword = <Token![return] as ::m2_syn::Reconstruct<N>>::reconstruct(
5269 children.required_matching::<Token![return]>()?,
5270 )?;
5271 let value = children
5272 .optional_matching::<Expr>()
5273 .map(|node| {
5274 let value = <Expr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
5275 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
5276 })
5277 .transpose()?;
5278 Ok(Self { keyword, value })
5279 }
5280}
5281#[derive(Debug, ::m2_syn::Spanned)]
5282pub struct CatchStatement {
5283 pub keyword: Token![catch],
5284 pub value: ::std::boxed::Box<Expr>,
5285}
5286impl CatchStatement {
5287 pub fn new(keyword: Token![catch], value: Expr) -> Self {
5288 {
5289 let value = ::std::boxed::Box::new(value);
5290 Self { keyword, value }
5291 }
5292 }
5293}
5294impl ::m2_syn::ToTokens for CatchStatement {
5295 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5296 let mut contents = ::m2_syn::TokenStream::new();
5297 {
5298 let mut field_output = ::m2_syn::TokenStream::new();
5299 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5300 if !field_output.is_empty() {
5301 if !contents.is_empty()
5302 && !contents.ends_with_whitespace()
5303 && !field_output.starts_with_whitespace()
5304 {
5305 contents.push_trivia(::m2_syn::Trivia::new(
5306 ::m2_syn::TriviaKind::Whitespace,
5307 " ",
5308 ::m2_syn::Span::detached(),
5309 ));
5310 }
5311 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5312 }
5313 }
5314 {
5315 let mut field_output = ::m2_syn::TokenStream::new();
5316 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5317 if !field_output.is_empty() {
5318 if !contents.is_empty()
5319 && !contents.ends_with_whitespace()
5320 && !field_output.starts_with_whitespace()
5321 {
5322 contents.push_trivia(::m2_syn::Trivia::new(
5323 ::m2_syn::TriviaKind::Whitespace,
5324 " ",
5325 ::m2_syn::Span::detached(),
5326 ));
5327 }
5328 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5329 }
5330 }
5331 ::m2_syn::ToTokens::to_tokens(&contents, output);
5332 }
5333}
5334impl ::m2_syn::PrettyTree for CatchStatement {
5335 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5336 let mut node =
5337 ::m2_syn::PrettyNode::syntax(stringify!(CatchStatement), ::m2_syn::Spanned::span(self));
5338 node.push("keyword", &self.keyword);
5339 node.push("value", &self.value);
5340 node
5341 }
5342}
5343impl<N> ::m2_syn::Reconstruct<N> for CatchStatement
5344where
5345 N: ::m2_syn::ExternalCstNode,
5346{
5347 fn matches(node: &N) -> bool {
5348 node.identity().matches("catch_statement", true)
5349 }
5350 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5351 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5352 return Err(::m2_syn::ReconstructError::wrong_node(
5353 "catch_statement",
5354 true,
5355 node.identity(),
5356 ));
5357 }
5358 let mut children = ::m2_syn::ChildCursor::new(&node);
5359 let keyword = <Token![catch] as ::m2_syn::Reconstruct<N>>::reconstruct(
5360 children.required_matching::<Token![catch]>()?,
5361 )?;
5362 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
5363 children.required_matching::<Expr>()?,
5364 )?);
5365 Ok(Self { keyword, value })
5366 }
5367}
5368#[derive(Debug, ::m2_syn::Spanned)]
5369pub struct ThrowStatement {
5370 pub keyword: Token![throw],
5371 pub value: ::std::boxed::Box<Expr>,
5372}
5373impl ThrowStatement {
5374 pub fn new(keyword: Token![throw], value: Expr) -> Self {
5375 {
5376 let value = ::std::boxed::Box::new(value);
5377 Self { keyword, value }
5378 }
5379 }
5380}
5381impl ::m2_syn::ToTokens for ThrowStatement {
5382 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5383 let mut contents = ::m2_syn::TokenStream::new();
5384 {
5385 let mut field_output = ::m2_syn::TokenStream::new();
5386 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5387 if !field_output.is_empty() {
5388 if !contents.is_empty()
5389 && !contents.ends_with_whitespace()
5390 && !field_output.starts_with_whitespace()
5391 {
5392 contents.push_trivia(::m2_syn::Trivia::new(
5393 ::m2_syn::TriviaKind::Whitespace,
5394 " ",
5395 ::m2_syn::Span::detached(),
5396 ));
5397 }
5398 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5399 }
5400 }
5401 {
5402 let mut field_output = ::m2_syn::TokenStream::new();
5403 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5404 if !field_output.is_empty() {
5405 if !contents.is_empty()
5406 && !contents.ends_with_whitespace()
5407 && !field_output.starts_with_whitespace()
5408 {
5409 contents.push_trivia(::m2_syn::Trivia::new(
5410 ::m2_syn::TriviaKind::Whitespace,
5411 " ",
5412 ::m2_syn::Span::detached(),
5413 ));
5414 }
5415 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5416 }
5417 }
5418 ::m2_syn::ToTokens::to_tokens(&contents, output);
5419 }
5420}
5421impl ::m2_syn::PrettyTree for ThrowStatement {
5422 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5423 let mut node =
5424 ::m2_syn::PrettyNode::syntax(stringify!(ThrowStatement), ::m2_syn::Spanned::span(self));
5425 node.push("keyword", &self.keyword);
5426 node.push("value", &self.value);
5427 node
5428 }
5429}
5430impl<N> ::m2_syn::Reconstruct<N> for ThrowStatement
5431where
5432 N: ::m2_syn::ExternalCstNode,
5433{
5434 fn matches(node: &N) -> bool {
5435 node.identity().matches("throw_statement", true)
5436 }
5437 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5438 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5439 return Err(::m2_syn::ReconstructError::wrong_node(
5440 "throw_statement",
5441 true,
5442 node.identity(),
5443 ));
5444 }
5445 let mut children = ::m2_syn::ChildCursor::new(&node);
5446 let keyword = <Token![throw] as ::m2_syn::Reconstruct<N>>::reconstruct(
5447 children.required_matching::<Token![throw]>()?,
5448 )?;
5449 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
5450 children.required_matching::<Expr>()?,
5451 )?);
5452 Ok(Self { keyword, value })
5453 }
5454}
5455#[derive(Debug, ::m2_syn::Spanned)]
5456pub struct TrapStatement {
5457 pub keyword: Token![trap],
5458 pub value: ::std::boxed::Box<Expr>,
5459}
5460impl TrapStatement {
5461 pub fn new(keyword: Token![trap], value: Expr) -> Self {
5462 {
5463 let value = ::std::boxed::Box::new(value);
5464 Self { keyword, value }
5465 }
5466 }
5467}
5468impl ::m2_syn::ToTokens for TrapStatement {
5469 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5470 let mut contents = ::m2_syn::TokenStream::new();
5471 {
5472 let mut field_output = ::m2_syn::TokenStream::new();
5473 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5474 if !field_output.is_empty() {
5475 if !contents.is_empty()
5476 && !contents.ends_with_whitespace()
5477 && !field_output.starts_with_whitespace()
5478 {
5479 contents.push_trivia(::m2_syn::Trivia::new(
5480 ::m2_syn::TriviaKind::Whitespace,
5481 " ",
5482 ::m2_syn::Span::detached(),
5483 ));
5484 }
5485 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5486 }
5487 }
5488 {
5489 let mut field_output = ::m2_syn::TokenStream::new();
5490 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5491 if !field_output.is_empty() {
5492 if !contents.is_empty()
5493 && !contents.ends_with_whitespace()
5494 && !field_output.starts_with_whitespace()
5495 {
5496 contents.push_trivia(::m2_syn::Trivia::new(
5497 ::m2_syn::TriviaKind::Whitespace,
5498 " ",
5499 ::m2_syn::Span::detached(),
5500 ));
5501 }
5502 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5503 }
5504 }
5505 ::m2_syn::ToTokens::to_tokens(&contents, output);
5506 }
5507}
5508impl ::m2_syn::PrettyTree for TrapStatement {
5509 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5510 let mut node =
5511 ::m2_syn::PrettyNode::syntax(stringify!(TrapStatement), ::m2_syn::Spanned::span(self));
5512 node.push("keyword", &self.keyword);
5513 node.push("value", &self.value);
5514 node
5515 }
5516}
5517impl<N> ::m2_syn::Reconstruct<N> for TrapStatement
5518where
5519 N: ::m2_syn::ExternalCstNode,
5520{
5521 fn matches(node: &N) -> bool {
5522 node.identity().matches("trap_statement", true)
5523 }
5524 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5525 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5526 return Err(::m2_syn::ReconstructError::wrong_node(
5527 "trap_statement",
5528 true,
5529 node.identity(),
5530 ));
5531 }
5532 let mut children = ::m2_syn::ChildCursor::new(&node);
5533 let keyword = <Token![trap] as ::m2_syn::Reconstruct<N>>::reconstruct(
5534 children.required_matching::<Token![trap]>()?,
5535 )?;
5536 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
5537 children.required_matching::<Expr>()?,
5538 )?);
5539 Ok(Self { keyword, value })
5540 }
5541}
5542#[derive(Debug, ::m2_syn::Spanned)]
5543pub struct ExceptClause {
5544 pub keyword: Token![except],
5545 pub exception: ::std::boxed::Box<Symbol>,
5546 pub do_keyword: Token![do],
5547 pub value: ::std::boxed::Box<Expr>,
5548}
5549impl ExceptClause {
5550 pub fn new(
5551 keyword: Token![except],
5552 exception: Symbol,
5553 do_keyword: Token![do],
5554 value: Expr,
5555 ) -> Self {
5556 {
5557 let exception = ::std::boxed::Box::new(exception);
5558 let value = ::std::boxed::Box::new(value);
5559 Self {
5560 keyword,
5561 exception,
5562 do_keyword,
5563 value,
5564 }
5565 }
5566 }
5567}
5568impl ::m2_syn::ToTokens for ExceptClause {
5569 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5570 let mut contents = ::m2_syn::TokenStream::new();
5571 {
5572 let mut field_output = ::m2_syn::TokenStream::new();
5573 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5574 if !field_output.is_empty() {
5575 if !contents.is_empty()
5576 && !contents.ends_with_whitespace()
5577 && !field_output.starts_with_whitespace()
5578 {
5579 contents.push_trivia(::m2_syn::Trivia::new(
5580 ::m2_syn::TriviaKind::Whitespace,
5581 " ",
5582 ::m2_syn::Span::detached(),
5583 ));
5584 }
5585 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5586 }
5587 }
5588 {
5589 let mut field_output = ::m2_syn::TokenStream::new();
5590 ::m2_syn::ToTokens::to_tokens(&self.exception, &mut field_output);
5591 if !field_output.is_empty() {
5592 if !contents.is_empty()
5593 && !contents.ends_with_whitespace()
5594 && !field_output.starts_with_whitespace()
5595 {
5596 contents.push_trivia(::m2_syn::Trivia::new(
5597 ::m2_syn::TriviaKind::Whitespace,
5598 " ",
5599 ::m2_syn::Span::detached(),
5600 ));
5601 }
5602 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5603 }
5604 }
5605 {
5606 let mut field_output = ::m2_syn::TokenStream::new();
5607 ::m2_syn::ToTokens::to_tokens(&self.do_keyword, &mut field_output);
5608 if !field_output.is_empty() {
5609 if !contents.is_empty()
5610 && !contents.ends_with_whitespace()
5611 && !field_output.starts_with_whitespace()
5612 {
5613 contents.push_trivia(::m2_syn::Trivia::new(
5614 ::m2_syn::TriviaKind::Whitespace,
5615 " ",
5616 ::m2_syn::Span::detached(),
5617 ));
5618 }
5619 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5620 }
5621 }
5622 {
5623 let mut field_output = ::m2_syn::TokenStream::new();
5624 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5625 if !field_output.is_empty() {
5626 if !contents.is_empty()
5627 && !contents.ends_with_whitespace()
5628 && !field_output.starts_with_whitespace()
5629 {
5630 contents.push_trivia(::m2_syn::Trivia::new(
5631 ::m2_syn::TriviaKind::Whitespace,
5632 " ",
5633 ::m2_syn::Span::detached(),
5634 ));
5635 }
5636 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5637 }
5638 }
5639 ::m2_syn::ToTokens::to_tokens(&contents, output);
5640 }
5641}
5642impl ::m2_syn::PrettyTree for ExceptClause {
5643 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5644 let mut node =
5645 ::m2_syn::PrettyNode::syntax(stringify!(ExceptClause), ::m2_syn::Spanned::span(self));
5646 node.push("keyword", &self.keyword);
5647 node.push("exception", &self.exception);
5648 node.push("do_keyword", &self.do_keyword);
5649 node.push("value", &self.value);
5650 node
5651 }
5652}
5653impl<N> ::m2_syn::Reconstruct<N> for ExceptClause
5654where
5655 N: ::m2_syn::ExternalCstNode,
5656{
5657 fn matches(node: &N) -> bool {
5658 node.identity().matches("except_clause", true)
5659 }
5660 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5661 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5662 return Err(::m2_syn::ReconstructError::wrong_node(
5663 "except_clause",
5664 true,
5665 node.identity(),
5666 ));
5667 }
5668 let mut children = ::m2_syn::ChildCursor::new(&node);
5669 let keyword = <Token![except] as ::m2_syn::Reconstruct<N>>::reconstruct(
5670 children.required_matching::<Token![except]>()?,
5671 )?;
5672 let exception = ::std::boxed::Box::new(<Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(
5673 children.required_field("exception")?,
5674 )?);
5675 let do_keyword = <Token![do] as ::m2_syn::Reconstruct<N>>::reconstruct(
5676 children.required_matching::<Token![do]>()?,
5677 )?;
5678 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
5679 children.required_matching::<Expr>()?,
5680 )?);
5681 Ok(Self {
5682 keyword,
5683 exception,
5684 do_keyword,
5685 value,
5686 })
5687 }
5688}
5689#[derive(Debug, ::m2_syn::Spanned)]
5690pub struct TryStatement {
5691 pub keyword: Token![try],
5692 pub value: ::std::boxed::Box<Expr>,
5693 pub then_clause: ::std::option::Option<::std::boxed::Box<ThenClause>>,
5694 pub fallback: ::std::option::Option<::std::boxed::Box<TryFallback>>,
5695}
5696impl TryStatement {
5697 pub fn new(
5698 keyword: Token![try],
5699 value: Expr,
5700 then_clause: ::std::option::Option<ThenClause>,
5701 fallback: ::std::option::Option<TryFallback>,
5702 ) -> Self {
5703 {
5704 let value = ::std::boxed::Box::new(value);
5705 let then_clause = then_clause.map(::std::boxed::Box::new);
5706 let fallback = fallback.map(::std::boxed::Box::new);
5707 Self {
5708 keyword,
5709 value,
5710 then_clause,
5711 fallback,
5712 }
5713 }
5714 }
5715}
5716impl ::m2_syn::ToTokens for TryStatement {
5717 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5718 let mut contents = ::m2_syn::TokenStream::new();
5719 {
5720 let mut field_output = ::m2_syn::TokenStream::new();
5721 ::m2_syn::ToTokens::to_tokens(&self.keyword, &mut field_output);
5722 if !field_output.is_empty() {
5723 if !contents.is_empty()
5724 && !contents.ends_with_whitespace()
5725 && !field_output.starts_with_whitespace()
5726 {
5727 contents.push_trivia(::m2_syn::Trivia::new(
5728 ::m2_syn::TriviaKind::Whitespace,
5729 " ",
5730 ::m2_syn::Span::detached(),
5731 ));
5732 }
5733 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5734 }
5735 }
5736 {
5737 let mut field_output = ::m2_syn::TokenStream::new();
5738 ::m2_syn::ToTokens::to_tokens(&self.value, &mut field_output);
5739 if !field_output.is_empty() {
5740 if !contents.is_empty()
5741 && !contents.ends_with_whitespace()
5742 && !field_output.starts_with_whitespace()
5743 {
5744 contents.push_trivia(::m2_syn::Trivia::new(
5745 ::m2_syn::TriviaKind::Whitespace,
5746 " ",
5747 ::m2_syn::Span::detached(),
5748 ));
5749 }
5750 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5751 }
5752 }
5753 {
5754 let mut field_output = ::m2_syn::TokenStream::new();
5755 ::m2_syn::ToTokens::to_tokens(&self.then_clause, &mut field_output);
5756 if !field_output.is_empty() {
5757 if !contents.is_empty()
5758 && !contents.ends_with_whitespace()
5759 && !field_output.starts_with_whitespace()
5760 {
5761 contents.push_trivia(::m2_syn::Trivia::new(
5762 ::m2_syn::TriviaKind::Whitespace,
5763 " ",
5764 ::m2_syn::Span::detached(),
5765 ));
5766 }
5767 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5768 }
5769 }
5770 {
5771 let mut field_output = ::m2_syn::TokenStream::new();
5772 ::m2_syn::ToTokens::to_tokens(&self.fallback, &mut field_output);
5773 if !field_output.is_empty() {
5774 if !contents.is_empty()
5775 && !contents.ends_with_whitespace()
5776 && !field_output.starts_with_whitespace()
5777 {
5778 contents.push_trivia(::m2_syn::Trivia::new(
5779 ::m2_syn::TriviaKind::Whitespace,
5780 " ",
5781 ::m2_syn::Span::detached(),
5782 ));
5783 }
5784 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5785 }
5786 }
5787 ::m2_syn::ToTokens::to_tokens(&contents, output);
5788 }
5789}
5790impl ::m2_syn::PrettyTree for TryStatement {
5791 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5792 let mut node =
5793 ::m2_syn::PrettyNode::syntax(stringify!(TryStatement), ::m2_syn::Spanned::span(self));
5794 node.push("keyword", &self.keyword);
5795 node.push("value", &self.value);
5796 node.push("then_clause", &self.then_clause);
5797 node.push("fallback", &self.fallback);
5798 node
5799 }
5800}
5801impl<N> ::m2_syn::Reconstruct<N> for TryStatement
5802where
5803 N: ::m2_syn::ExternalCstNode,
5804{
5805 fn matches(node: &N) -> bool {
5806 node.identity().matches("try_statement", true)
5807 }
5808 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5809 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5810 return Err(::m2_syn::ReconstructError::wrong_node(
5811 "try_statement",
5812 true,
5813 node.identity(),
5814 ));
5815 }
5816 let mut children = ::m2_syn::ChildCursor::new(&node);
5817 let keyword = <Token![try] as ::m2_syn::Reconstruct<N>>::reconstruct(
5818 children.required_matching::<Token![try]>()?,
5819 )?;
5820 let value = ::std::boxed::Box::new(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
5821 children.required_matching::<Expr>()?,
5822 )?);
5823 let then_clause = children
5824 .optional_matching::<ThenClause>()
5825 .map(|node| {
5826 let value = <ThenClause as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
5827 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
5828 })
5829 .transpose()?;
5830 let fallback = children
5831 .optional_field("fallback")
5832 .map(|node| {
5833 let value = <TryFallback as ::m2_syn::Reconstruct<N>>::reconstruct(node)?;
5834 Ok::<_, ::m2_syn::ReconstructError>(::std::boxed::Box::new(value))
5835 })
5836 .transpose()?;
5837 Ok(Self {
5838 keyword,
5839 value,
5840 then_clause,
5841 fallback,
5842 })
5843 }
5844}
5845#[derive(Debug, ::m2_syn::Spanned)]
5846pub struct QuoteExpression {
5847 pub specifier: QuoteSpecifier,
5848 pub token: ::std::boxed::Box<Symbol>,
5849}
5850impl QuoteExpression {
5851 pub fn new(specifier: QuoteSpecifier, token: Symbol) -> Self {
5852 {
5853 let token = ::std::boxed::Box::new(token);
5854 Self { specifier, token }
5855 }
5856 }
5857}
5858impl ::m2_syn::ToTokens for QuoteExpression {
5859 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5860 let mut contents = ::m2_syn::TokenStream::new();
5861 {
5862 let mut field_output = ::m2_syn::TokenStream::new();
5863 ::m2_syn::ToTokens::to_tokens(&self.specifier, &mut field_output);
5864 if !field_output.is_empty() {
5865 if !contents.is_empty()
5866 && !contents.ends_with_whitespace()
5867 && !field_output.starts_with_whitespace()
5868 {
5869 contents.push_trivia(::m2_syn::Trivia::new(
5870 ::m2_syn::TriviaKind::Whitespace,
5871 " ",
5872 ::m2_syn::Span::detached(),
5873 ));
5874 }
5875 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5876 }
5877 }
5878 {
5879 let mut field_output = ::m2_syn::TokenStream::new();
5880 ::m2_syn::ToTokens::to_tokens(&self.token, &mut field_output);
5881 if !field_output.is_empty() {
5882 if !contents.is_empty()
5883 && !contents.ends_with_whitespace()
5884 && !field_output.starts_with_whitespace()
5885 {
5886 contents.push_trivia(::m2_syn::Trivia::new(
5887 ::m2_syn::TriviaKind::Whitespace,
5888 " ",
5889 ::m2_syn::Span::detached(),
5890 ));
5891 }
5892 ::m2_syn::ToTokens::to_tokens(&field_output, &mut contents);
5893 }
5894 }
5895 ::m2_syn::ToTokens::to_tokens(&contents, output);
5896 }
5897}
5898impl ::m2_syn::PrettyTree for QuoteExpression {
5899 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5900 let mut node = ::m2_syn::PrettyNode::syntax(
5901 stringify!(QuoteExpression),
5902 ::m2_syn::Spanned::span(self),
5903 );
5904 node.push("specifier", &self.specifier);
5905 node.push("token", &self.token);
5906 node
5907 }
5908}
5909impl<N> ::m2_syn::Reconstruct<N> for QuoteExpression
5910where
5911 N: ::m2_syn::ExternalCstNode,
5912{
5913 fn matches(node: &N) -> bool {
5914 node.identity().matches("quote_expression", true)
5915 }
5916 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
5917 if !<Self as ::m2_syn::Reconstruct<N>>::matches(&node) {
5918 return Err(::m2_syn::ReconstructError::wrong_node(
5919 "quote_expression",
5920 true,
5921 node.identity(),
5922 ));
5923 }
5924 let mut children = ::m2_syn::ChildCursor::new(&node);
5925 let specifier = <QuoteSpecifier as ::m2_syn::Reconstruct<N>>::reconstruct(
5926 children.required_matching::<QuoteSpecifier>()?,
5927 )?;
5928 let token = ::std::boxed::Box::new(<Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(
5929 children.required_field("token")?,
5930 )?);
5931 Ok(Self { specifier, token })
5932 }
5933}
5934#[derive(Debug, ::m2_syn::Spanned)]
5935pub enum PrefixOperator {
5936 Hsh(Token![#]),
5937 Mul(Token![*]),
5938 Add(Token![+]),
5939 Sub(Token![-]),
5940 Lst(Token![<]),
5941 LstLst(Token![<<]),
5942 LstEql(Token![<=]),
5943 LstEqlEql(Token![<==]),
5944 LstEqlEqlEql(Token![<===]),
5945 Gst(Token![>]),
5946 GstEql(Token![>=]),
5947 Qsm(Token![?]),
5948 QsmQsm(Token![??]),
5949 PipSub(Token![|-]),
5950 Tld(Token![~]),
5951 Not(Token![not]),
5952}
5953impl ::m2_syn::ToTokens for PrefixOperator {
5954 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
5955 match self {
5956 Self::Hsh(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5957 Self::Mul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5958 Self::Add(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5959 Self::Sub(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5960 Self::Lst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5961 Self::LstLst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5962 Self::LstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5963 Self::LstEqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5964 Self::LstEqlEqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5965 Self::Gst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5966 Self::GstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5967 Self::Qsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5968 Self::QsmQsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5969 Self::PipSub(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5970 Self::Tld(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5971 Self::Not(node) => ::m2_syn::ToTokens::to_tokens(node, output),
5972 }
5973 }
5974}
5975impl ::m2_syn::PrettyTree for PrefixOperator {
5976 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
5977 match self {
5978 Self::Hsh(value) => ::m2_syn::PrettyNode::variant(
5979 stringify!(PrefixOperator),
5980 stringify!(Hsh),
5981 ::m2_syn::Spanned::span(self),
5982 ::m2_syn::PrettyTree::pretty_tree(value),
5983 ),
5984 Self::Mul(value) => ::m2_syn::PrettyNode::variant(
5985 stringify!(PrefixOperator),
5986 stringify!(Mul),
5987 ::m2_syn::Spanned::span(self),
5988 ::m2_syn::PrettyTree::pretty_tree(value),
5989 ),
5990 Self::Add(value) => ::m2_syn::PrettyNode::variant(
5991 stringify!(PrefixOperator),
5992 stringify!(Add),
5993 ::m2_syn::Spanned::span(self),
5994 ::m2_syn::PrettyTree::pretty_tree(value),
5995 ),
5996 Self::Sub(value) => ::m2_syn::PrettyNode::variant(
5997 stringify!(PrefixOperator),
5998 stringify!(Sub),
5999 ::m2_syn::Spanned::span(self),
6000 ::m2_syn::PrettyTree::pretty_tree(value),
6001 ),
6002 Self::Lst(value) => ::m2_syn::PrettyNode::variant(
6003 stringify!(PrefixOperator),
6004 stringify!(Lst),
6005 ::m2_syn::Spanned::span(self),
6006 ::m2_syn::PrettyTree::pretty_tree(value),
6007 ),
6008 Self::LstLst(value) => ::m2_syn::PrettyNode::variant(
6009 stringify!(PrefixOperator),
6010 stringify!(LstLst),
6011 ::m2_syn::Spanned::span(self),
6012 ::m2_syn::PrettyTree::pretty_tree(value),
6013 ),
6014 Self::LstEql(value) => ::m2_syn::PrettyNode::variant(
6015 stringify!(PrefixOperator),
6016 stringify!(LstEql),
6017 ::m2_syn::Spanned::span(self),
6018 ::m2_syn::PrettyTree::pretty_tree(value),
6019 ),
6020 Self::LstEqlEql(value) => ::m2_syn::PrettyNode::variant(
6021 stringify!(PrefixOperator),
6022 stringify!(LstEqlEql),
6023 ::m2_syn::Spanned::span(self),
6024 ::m2_syn::PrettyTree::pretty_tree(value),
6025 ),
6026 Self::LstEqlEqlEql(value) => ::m2_syn::PrettyNode::variant(
6027 stringify!(PrefixOperator),
6028 stringify!(LstEqlEqlEql),
6029 ::m2_syn::Spanned::span(self),
6030 ::m2_syn::PrettyTree::pretty_tree(value),
6031 ),
6032 Self::Gst(value) => ::m2_syn::PrettyNode::variant(
6033 stringify!(PrefixOperator),
6034 stringify!(Gst),
6035 ::m2_syn::Spanned::span(self),
6036 ::m2_syn::PrettyTree::pretty_tree(value),
6037 ),
6038 Self::GstEql(value) => ::m2_syn::PrettyNode::variant(
6039 stringify!(PrefixOperator),
6040 stringify!(GstEql),
6041 ::m2_syn::Spanned::span(self),
6042 ::m2_syn::PrettyTree::pretty_tree(value),
6043 ),
6044 Self::Qsm(value) => ::m2_syn::PrettyNode::variant(
6045 stringify!(PrefixOperator),
6046 stringify!(Qsm),
6047 ::m2_syn::Spanned::span(self),
6048 ::m2_syn::PrettyTree::pretty_tree(value),
6049 ),
6050 Self::QsmQsm(value) => ::m2_syn::PrettyNode::variant(
6051 stringify!(PrefixOperator),
6052 stringify!(QsmQsm),
6053 ::m2_syn::Spanned::span(self),
6054 ::m2_syn::PrettyTree::pretty_tree(value),
6055 ),
6056 Self::PipSub(value) => ::m2_syn::PrettyNode::variant(
6057 stringify!(PrefixOperator),
6058 stringify!(PipSub),
6059 ::m2_syn::Spanned::span(self),
6060 ::m2_syn::PrettyTree::pretty_tree(value),
6061 ),
6062 Self::Tld(value) => ::m2_syn::PrettyNode::variant(
6063 stringify!(PrefixOperator),
6064 stringify!(Tld),
6065 ::m2_syn::Spanned::span(self),
6066 ::m2_syn::PrettyTree::pretty_tree(value),
6067 ),
6068 Self::Not(value) => ::m2_syn::PrettyNode::variant(
6069 stringify!(PrefixOperator),
6070 stringify!(Not),
6071 ::m2_syn::Spanned::span(self),
6072 ::m2_syn::PrettyTree::pretty_tree(value),
6073 ),
6074 }
6075 }
6076}
6077impl<N> ::m2_syn::Reconstruct<N> for PrefixOperator
6078where
6079 N: ::m2_syn::ExternalCstNode,
6080{
6081 fn matches(node: &N) -> bool {
6082 <Token![#] as ::m2_syn::Reconstruct<N>>::matches(node)
6083 || <Token![*] as ::m2_syn::Reconstruct<N>>::matches(node)
6084 || <Token![+] as ::m2_syn::Reconstruct<N>>::matches(node)
6085 || <Token![-] as ::m2_syn::Reconstruct<N>>::matches(node)
6086 || <Token![<] as ::m2_syn::Reconstruct<N>>::matches(node)
6087 || <Token![<<] as ::m2_syn::Reconstruct<N>>::matches(node)
6088 || <Token![<=] as ::m2_syn::Reconstruct<N>>::matches(node)
6089 || <Token![<==] as ::m2_syn::Reconstruct<N>>::matches(node)
6090 || <Token![<===] as ::m2_syn::Reconstruct<N>>::matches(node)
6091 || <Token![>] as ::m2_syn::Reconstruct<N>>::matches(node)
6092 || <Token![>=] as ::m2_syn::Reconstruct<N>>::matches(node)
6093 || <Token![?] as ::m2_syn::Reconstruct<N>>::matches(node)
6094 || <Token![??] as ::m2_syn::Reconstruct<N>>::matches(node)
6095 || <Token![|-] as ::m2_syn::Reconstruct<N>>::matches(node)
6096 || <Token![~] as ::m2_syn::Reconstruct<N>>::matches(node)
6097 || <Token![not] as ::m2_syn::Reconstruct<N>>::matches(node)
6098 }
6099 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
6100 if <Token![#] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6101 return Ok(Self::Hsh(
6102 <Token![#] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6103 ));
6104 }
6105 if <Token![*] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6106 return Ok(Self::Mul(
6107 <Token![*] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6108 ));
6109 }
6110 if <Token![+] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6111 return Ok(Self::Add(
6112 <Token![+] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6113 ));
6114 }
6115 if <Token![-] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6116 return Ok(Self::Sub(
6117 <Token![-] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6118 ));
6119 }
6120 if <Token![<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6121 return Ok(Self::Lst(
6122 <Token![<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6123 ));
6124 }
6125 if <Token![<<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6126 return Ok(Self::LstLst(
6127 <Token![<<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6128 ));
6129 }
6130 if <Token![<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6131 return Ok(Self::LstEql(
6132 <Token![<=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6133 ));
6134 }
6135 if <Token![<==] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6136 return Ok(Self::LstEqlEql(<Token![<==] as ::m2_syn::Reconstruct<
6137 N,
6138 >>::reconstruct(node)?));
6139 }
6140 if <Token![<===] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6141 return Ok(Self::LstEqlEqlEql(
6142 <Token![<===] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6143 ));
6144 }
6145 if <Token![>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6146 return Ok(Self::Gst(
6147 <Token![>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6148 ));
6149 }
6150 if <Token![>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6151 return Ok(Self::GstEql(
6152 <Token![>=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6153 ));
6154 }
6155 if <Token![?] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6156 return Ok(Self::Qsm(
6157 <Token![?] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6158 ));
6159 }
6160 if <Token![??] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6161 return Ok(Self::QsmQsm(
6162 <Token![??] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6163 ));
6164 }
6165 if <Token![|-] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6166 return Ok(Self::PipSub(
6167 <Token![|-] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6168 ));
6169 }
6170 if <Token![~] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6171 return Ok(Self::Tld(
6172 <Token![~] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6173 ));
6174 }
6175 if <Token![not] as ::m2_syn::Reconstruct<N>>::matches(&node) {
6176 return Ok(Self::Not(
6177 <Token![not] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
6178 ));
6179 }
6180 Err(::m2_syn::ReconstructError::wrong_category(
6181 stringify!(PrefixOperator),
6182 node.identity(),
6183 ))
6184 }
6185}
6186impl PrefixOperator {
6187 pub fn from_spelling(spelling: &str, span: ::m2_syn::Span) -> ::std::option::Option<Self> {
6188 match spelling {
6189 "#" => Some(Self::Hsh(Token)),
6190 "*" => Some(Self::Mul(Token)),
6191 "+" => Some(Self::Add(Token)),
6192 "-" => Some(Self::Sub(Token)),
6193 "<" => Some(Self::Lst(Token)),
6194 "<<" => Some(Self::LstLst(Token)),
6195 "<=" => Some(Self::LstEql(Token)),
6196 "<==" => Some(Self::LstEqlEql(Token)),
6197 "<===" => Some(Self::LstEqlEqlEql(Token)),
6198 ">" => Some(Self::Gst(Token)),
6199 ">=" => Some(Self::GstEql(Token)),
6200 "?" => Some(Self::Qsm(Token)),
6201 "??" => Some(Self::QsmQsm(Token)),
6202 "|-" => Some(Self::PipSub(Token)),
6203 "~" => Some(Self::Tld(Token)),
6204 "not" => Some(Self::Not(Token)),
6205 _ => None,
6206 }
6207 }
6208 pub fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
6209 if <Token![#] as ::m2_syn::Token>::matches_token_tree(&token) {
6210 return Some(Self::Hsh(<Token![#] as ::m2_syn::Token>::from_token_tree(
6211 token,
6212 )?));
6213 }
6214 if <Token![*] as ::m2_syn::Token>::matches_token_tree(&token) {
6215 return Some(Self::Mul(<Token![*] as ::m2_syn::Token>::from_token_tree(
6216 token,
6217 )?));
6218 }
6219 if <Token![+] as ::m2_syn::Token>::matches_token_tree(&token) {
6220 return Some(Self::Add(<Token![+] as ::m2_syn::Token>::from_token_tree(
6221 token,
6222 )?));
6223 }
6224 if <Token![-] as ::m2_syn::Token>::matches_token_tree(&token) {
6225 return Some(Self::Sub(<Token![-] as ::m2_syn::Token>::from_token_tree(
6226 token,
6227 )?));
6228 }
6229 if <Token![<] as ::m2_syn::Token>::matches_token_tree(&token) {
6230 return Some(Self::Lst(<Token![<] as ::m2_syn::Token>::from_token_tree(
6231 token,
6232 )?));
6233 }
6234 if <Token![<<] as ::m2_syn::Token>::matches_token_tree(&token) {
6235 return Some(Self::LstLst(
6236 <Token![<<] as ::m2_syn::Token>::from_token_tree(token)?,
6237 ));
6238 }
6239 if <Token![<=] as ::m2_syn::Token>::matches_token_tree(&token) {
6240 return Some(Self::LstEql(
6241 <Token![<=] as ::m2_syn::Token>::from_token_tree(token)?,
6242 ));
6243 }
6244 if <Token![<==] as ::m2_syn::Token>::matches_token_tree(&token) {
6245 return Some(Self::LstEqlEql(
6246 <Token![<==] as ::m2_syn::Token>::from_token_tree(token)?,
6247 ));
6248 }
6249 if <Token![<===] as ::m2_syn::Token>::matches_token_tree(&token) {
6250 return Some(Self::LstEqlEqlEql(
6251 <Token![<===] as ::m2_syn::Token>::from_token_tree(token)?,
6252 ));
6253 }
6254 if <Token![>] as ::m2_syn::Token>::matches_token_tree(&token) {
6255 return Some(Self::Gst(<Token![>] as ::m2_syn::Token>::from_token_tree(
6256 token,
6257 )?));
6258 }
6259 if <Token![>=] as ::m2_syn::Token>::matches_token_tree(&token) {
6260 return Some(Self::GstEql(
6261 <Token![>=] as ::m2_syn::Token>::from_token_tree(token)?,
6262 ));
6263 }
6264 if <Token![?] as ::m2_syn::Token>::matches_token_tree(&token) {
6265 return Some(Self::Qsm(<Token![?] as ::m2_syn::Token>::from_token_tree(
6266 token,
6267 )?));
6268 }
6269 if <Token![??] as ::m2_syn::Token>::matches_token_tree(&token) {
6270 return Some(Self::QsmQsm(
6271 <Token![??] as ::m2_syn::Token>::from_token_tree(token)?,
6272 ));
6273 }
6274 if <Token![|-] as ::m2_syn::Token>::matches_token_tree(&token) {
6275 return Some(Self::PipSub(
6276 <Token![|-] as ::m2_syn::Token>::from_token_tree(token)?,
6277 ));
6278 }
6279 if <Token![~] as ::m2_syn::Token>::matches_token_tree(&token) {
6280 return Some(Self::Tld(<Token![~] as ::m2_syn::Token>::from_token_tree(
6281 token,
6282 )?));
6283 }
6284 if <Token![not] as ::m2_syn::Token>::matches_token_tree(&token) {
6285 return Some(Self::Not(
6286 <Token![not] as ::m2_syn::Token>::from_token_tree(token)?,
6287 ));
6288 }
6289 None
6290 }
6291 pub fn spelling(&self) -> &'static str {
6292 match self {
6293 Self::Hsh(_) => "#",
6294 Self::Mul(_) => "*",
6295 Self::Add(_) => "+",
6296 Self::Sub(_) => "-",
6297 Self::Lst(_) => "<",
6298 Self::LstLst(_) => "<<",
6299 Self::LstEql(_) => "<=",
6300 Self::LstEqlEql(_) => "<==",
6301 Self::LstEqlEqlEql(_) => "<===",
6302 Self::Gst(_) => ">",
6303 Self::GstEql(_) => ">=",
6304 Self::Qsm(_) => "?",
6305 Self::QsmQsm(_) => "??",
6306 Self::PipSub(_) => "|-",
6307 Self::Tld(_) => "~",
6308 Self::Not(_) => "not",
6309 }
6310 }
6311}
6312#[derive(Debug, ::m2_syn::Spanned)]
6313pub enum BinaryOperator {
6314 BngEql(Token![!=]),
6315 Hsh(Token![#]),
6316 HshQsm(Token![#?]),
6317 Mod(Token![%]),
6318 ModEql(Token![%=]),
6319 Amp(Token![&]),
6320 AmpEql(Token![&=]),
6321 Mul(Token![*]),
6322 MulEql(Token![*=]),
6323 MulMul(Token![**]),
6324 MulMulEql(Token![**=]),
6325 Add(Token![+]),
6326 AddEql(Token![+=]),
6327 AddAdd(Token![++]),
6328 AddAddEql(Token![++=]),
6329 Sub(Token![-]),
6330 SubEql(Token![-=]),
6331 Dot(Token![.]),
6332 DotDot(Token![..]),
6333 DotDotEql(Token![..=]),
6334 DotDotLst(Token![..<]),
6335 DotDotLstEql(Token![..<=]),
6336 DotQsm(Token![.?]),
6337 Slh(Token![/]),
6338 SlhEql(Token![/=]),
6339 SlhSlh(Token![/ /]),
6340 SlhSlhEql(Token![/ /=]),
6341 Col(Token![:]),
6342 ColEql(Token![:=]),
6343 Lst(Token![<]),
6344 LstLst(Token![<<]),
6345 LstLstEql(Token![<<=]),
6346 LstEql(Token![<=]),
6347 LstEqlEql(Token![<==]),
6348 LstEqlEqlEql(Token![<===]),
6349 LstEqlEqlGst(Token![<==>]),
6350 LstEqlEqlGstEql(Token![<==>=]),
6351 EqlBngEql(Token![=!=]),
6352 EqlEql(Token![==]),
6353 EqlEqlEql(Token![===]),
6354 EqlEqlEqlGst(Token![===>]),
6355 EqlEqlEqlGstEql(Token![===>=]),
6356 EqlEqlGst(Token![==>]),
6357 EqlEqlGstEql(Token![==>=]),
6358 Gst(Token![>]),
6359 GstEql(Token![>=]),
6360 GstGst(Token![>>]),
6361 GstGstEql(Token![>>=]),
6362 Qsm(Token![?]),
6363 QsmQsm(Token![??]),
6364 QsmQsmEql(Token![??=]),
6365 Att(Token![@]),
6366 AttEql(Token![@=]),
6367 AttAtt(Token![@@]),
6368 AttAttEql(Token![@@=]),
6369 AttAttQsm(Token![@@?]),
6370 AttAttQsmEql(Token![@@?=]),
6371 Bsl(Token!["\\"]),
6372 BslEql(Token!["\\="]),
6373 BslBsl(Token!["\\\\"]),
6374 BslBslEql(Token!["\\\\="]),
6375 Crt(Token![^]),
6376 CrtEql(Token![^=]),
6377 CrtMulMul(Token![^**]),
6378 CrtMulMulEql(Token![^**=]),
6379 CrtLst(Token![^<]),
6380 CrtLstEql(Token![^<=]),
6381 CrtGst(Token![^>]),
6382 CrtGstEql(Token![^>=]),
6383 CrtCrt(Token![^^]),
6384 CrtCrtEql(Token![^^=]),
6385 Ubs(Token![_]),
6386 UbsEql(Token![_=]),
6387 UbsLst(Token![_<]),
6388 UbsLstEql(Token![_<=]),
6389 UbsGst(Token![_>]),
6390 UbsGstEql(Token![_>=]),
6391 Pip(Token![|]),
6392 PipEql(Token![|=]),
6393 PipSub(Token![|-]),
6394 PipSubEql(Token![|-=]),
6395 PipUbs(Token![|_]),
6396 PipUbsEql(Token![|_=]),
6397 PipPip(Token![||]),
6398 PipPipEql(Token![||=]),
6399 Tld(Token![~]),
6400 TldEql(Token![~=]),
6401 Cdt(Token!["·"]),
6402 CdtEql(Token!["·="]),
6403 Box(Token!["⊠"]),
6404 BoxEql(Token!["⊠="]),
6405 Sfp(Token!["⧢"]),
6406 SfpEql(Token!["⧢="]),
6407 And(Token![and]),
6408 Or(Token![or]),
6409 Space(Token![SPACE]),
6410 Xor(Token![xor]),
6411}
6412impl ::m2_syn::ToTokens for BinaryOperator {
6413 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
6414 match self {
6415 Self::BngEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6416 Self::Hsh(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6417 Self::HshQsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6418 Self::Mod(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6419 Self::ModEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6420 Self::Amp(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6421 Self::AmpEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6422 Self::Mul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6423 Self::MulEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6424 Self::MulMul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6425 Self::MulMulEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6426 Self::Add(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6427 Self::AddEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6428 Self::AddAdd(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6429 Self::AddAddEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6430 Self::Sub(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6431 Self::SubEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6432 Self::Dot(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6433 Self::DotDot(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6434 Self::DotDotEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6435 Self::DotDotLst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6436 Self::DotDotLstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6437 Self::DotQsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6438 Self::Slh(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6439 Self::SlhEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6440 Self::SlhSlh(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6441 Self::SlhSlhEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6442 Self::Col(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6443 Self::ColEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6444 Self::Lst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6445 Self::LstLst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6446 Self::LstLstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6447 Self::LstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6448 Self::LstEqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6449 Self::LstEqlEqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6450 Self::LstEqlEqlGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6451 Self::LstEqlEqlGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6452 Self::EqlBngEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6453 Self::EqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6454 Self::EqlEqlEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6455 Self::EqlEqlEqlGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6456 Self::EqlEqlEqlGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6457 Self::EqlEqlGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6458 Self::EqlEqlGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6459 Self::Gst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6460 Self::GstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6461 Self::GstGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6462 Self::GstGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6463 Self::Qsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6464 Self::QsmQsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6465 Self::QsmQsmEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6466 Self::Att(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6467 Self::AttEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6468 Self::AttAtt(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6469 Self::AttAttEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6470 Self::AttAttQsm(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6471 Self::AttAttQsmEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6472 Self::Bsl(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6473 Self::BslEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6474 Self::BslBsl(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6475 Self::BslBslEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6476 Self::Crt(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6477 Self::CrtEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6478 Self::CrtMulMul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6479 Self::CrtMulMulEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6480 Self::CrtLst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6481 Self::CrtLstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6482 Self::CrtGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6483 Self::CrtGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6484 Self::CrtCrt(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6485 Self::CrtCrtEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6486 Self::Ubs(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6487 Self::UbsEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6488 Self::UbsLst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6489 Self::UbsLstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6490 Self::UbsGst(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6491 Self::UbsGstEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6492 Self::Pip(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6493 Self::PipEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6494 Self::PipSub(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6495 Self::PipSubEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6496 Self::PipUbs(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6497 Self::PipUbsEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6498 Self::PipPip(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6499 Self::PipPipEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6500 Self::Tld(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6501 Self::TldEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6502 Self::Cdt(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6503 Self::CdtEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6504 Self::Box(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6505 Self::BoxEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6506 Self::Sfp(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6507 Self::SfpEql(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6508 Self::And(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6509 Self::Or(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6510 Self::Space(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6511 Self::Xor(node) => ::m2_syn::ToTokens::to_tokens(node, output),
6512 }
6513 }
6514}
6515impl ::m2_syn::PrettyTree for BinaryOperator {
6516 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
6517 match self {
6518 Self::BngEql(value) => ::m2_syn::PrettyNode::variant(
6519 stringify!(BinaryOperator),
6520 stringify!(BngEql),
6521 ::m2_syn::Spanned::span(self),
6522 ::m2_syn::PrettyTree::pretty_tree(value),
6523 ),
6524 Self::Hsh(value) => ::m2_syn::PrettyNode::variant(
6525 stringify!(BinaryOperator),
6526 stringify!(Hsh),
6527 ::m2_syn::Spanned::span(self),
6528 ::m2_syn::PrettyTree::pretty_tree(value),
6529 ),
6530 Self::HshQsm(value) => ::m2_syn::PrettyNode::variant(
6531 stringify!(BinaryOperator),
6532 stringify!(HshQsm),
6533 ::m2_syn::Spanned::span(self),
6534 ::m2_syn::PrettyTree::pretty_tree(value),
6535 ),
6536 Self::Mod(value) => ::m2_syn::PrettyNode::variant(
6537 stringify!(BinaryOperator),
6538 stringify!(Mod),
6539 ::m2_syn::Spanned::span(self),
6540 ::m2_syn::PrettyTree::pretty_tree(value),
6541 ),
6542 Self::ModEql(value) => ::m2_syn::PrettyNode::variant(
6543 stringify!(BinaryOperator),
6544 stringify!(ModEql),
6545 ::m2_syn::Spanned::span(self),
6546 ::m2_syn::PrettyTree::pretty_tree(value),
6547 ),
6548 Self::Amp(value) => ::m2_syn::PrettyNode::variant(
6549 stringify!(BinaryOperator),
6550 stringify!(Amp),
6551 ::m2_syn::Spanned::span(self),
6552 ::m2_syn::PrettyTree::pretty_tree(value),
6553 ),
6554 Self::AmpEql(value) => ::m2_syn::PrettyNode::variant(
6555 stringify!(BinaryOperator),
6556 stringify!(AmpEql),
6557 ::m2_syn::Spanned::span(self),
6558 ::m2_syn::PrettyTree::pretty_tree(value),
6559 ),
6560 Self::Mul(value) => ::m2_syn::PrettyNode::variant(
6561 stringify!(BinaryOperator),
6562 stringify!(Mul),
6563 ::m2_syn::Spanned::span(self),
6564 ::m2_syn::PrettyTree::pretty_tree(value),
6565 ),
6566 Self::MulEql(value) => ::m2_syn::PrettyNode::variant(
6567 stringify!(BinaryOperator),
6568 stringify!(MulEql),
6569 ::m2_syn::Spanned::span(self),
6570 ::m2_syn::PrettyTree::pretty_tree(value),
6571 ),
6572 Self::MulMul(value) => ::m2_syn::PrettyNode::variant(
6573 stringify!(BinaryOperator),
6574 stringify!(MulMul),
6575 ::m2_syn::Spanned::span(self),
6576 ::m2_syn::PrettyTree::pretty_tree(value),
6577 ),
6578 Self::MulMulEql(value) => ::m2_syn::PrettyNode::variant(
6579 stringify!(BinaryOperator),
6580 stringify!(MulMulEql),
6581 ::m2_syn::Spanned::span(self),
6582 ::m2_syn::PrettyTree::pretty_tree(value),
6583 ),
6584 Self::Add(value) => ::m2_syn::PrettyNode::variant(
6585 stringify!(BinaryOperator),
6586 stringify!(Add),
6587 ::m2_syn::Spanned::span(self),
6588 ::m2_syn::PrettyTree::pretty_tree(value),
6589 ),
6590 Self::AddEql(value) => ::m2_syn::PrettyNode::variant(
6591 stringify!(BinaryOperator),
6592 stringify!(AddEql),
6593 ::m2_syn::Spanned::span(self),
6594 ::m2_syn::PrettyTree::pretty_tree(value),
6595 ),
6596 Self::AddAdd(value) => ::m2_syn::PrettyNode::variant(
6597 stringify!(BinaryOperator),
6598 stringify!(AddAdd),
6599 ::m2_syn::Spanned::span(self),
6600 ::m2_syn::PrettyTree::pretty_tree(value),
6601 ),
6602 Self::AddAddEql(value) => ::m2_syn::PrettyNode::variant(
6603 stringify!(BinaryOperator),
6604 stringify!(AddAddEql),
6605 ::m2_syn::Spanned::span(self),
6606 ::m2_syn::PrettyTree::pretty_tree(value),
6607 ),
6608 Self::Sub(value) => ::m2_syn::PrettyNode::variant(
6609 stringify!(BinaryOperator),
6610 stringify!(Sub),
6611 ::m2_syn::Spanned::span(self),
6612 ::m2_syn::PrettyTree::pretty_tree(value),
6613 ),
6614 Self::SubEql(value) => ::m2_syn::PrettyNode::variant(
6615 stringify!(BinaryOperator),
6616 stringify!(SubEql),
6617 ::m2_syn::Spanned::span(self),
6618 ::m2_syn::PrettyTree::pretty_tree(value),
6619 ),
6620 Self::Dot(value) => ::m2_syn::PrettyNode::variant(
6621 stringify!(BinaryOperator),
6622 stringify!(Dot),
6623 ::m2_syn::Spanned::span(self),
6624 ::m2_syn::PrettyTree::pretty_tree(value),
6625 ),
6626 Self::DotDot(value) => ::m2_syn::PrettyNode::variant(
6627 stringify!(BinaryOperator),
6628 stringify!(DotDot),
6629 ::m2_syn::Spanned::span(self),
6630 ::m2_syn::PrettyTree::pretty_tree(value),
6631 ),
6632 Self::DotDotEql(value) => ::m2_syn::PrettyNode::variant(
6633 stringify!(BinaryOperator),
6634 stringify!(DotDotEql),
6635 ::m2_syn::Spanned::span(self),
6636 ::m2_syn::PrettyTree::pretty_tree(value),
6637 ),
6638 Self::DotDotLst(value) => ::m2_syn::PrettyNode::variant(
6639 stringify!(BinaryOperator),
6640 stringify!(DotDotLst),
6641 ::m2_syn::Spanned::span(self),
6642 ::m2_syn::PrettyTree::pretty_tree(value),
6643 ),
6644 Self::DotDotLstEql(value) => ::m2_syn::PrettyNode::variant(
6645 stringify!(BinaryOperator),
6646 stringify!(DotDotLstEql),
6647 ::m2_syn::Spanned::span(self),
6648 ::m2_syn::PrettyTree::pretty_tree(value),
6649 ),
6650 Self::DotQsm(value) => ::m2_syn::PrettyNode::variant(
6651 stringify!(BinaryOperator),
6652 stringify!(DotQsm),
6653 ::m2_syn::Spanned::span(self),
6654 ::m2_syn::PrettyTree::pretty_tree(value),
6655 ),
6656 Self::Slh(value) => ::m2_syn::PrettyNode::variant(
6657 stringify!(BinaryOperator),
6658 stringify!(Slh),
6659 ::m2_syn::Spanned::span(self),
6660 ::m2_syn::PrettyTree::pretty_tree(value),
6661 ),
6662 Self::SlhEql(value) => ::m2_syn::PrettyNode::variant(
6663 stringify!(BinaryOperator),
6664 stringify!(SlhEql),
6665 ::m2_syn::Spanned::span(self),
6666 ::m2_syn::PrettyTree::pretty_tree(value),
6667 ),
6668 Self::SlhSlh(value) => ::m2_syn::PrettyNode::variant(
6669 stringify!(BinaryOperator),
6670 stringify!(SlhSlh),
6671 ::m2_syn::Spanned::span(self),
6672 ::m2_syn::PrettyTree::pretty_tree(value),
6673 ),
6674 Self::SlhSlhEql(value) => ::m2_syn::PrettyNode::variant(
6675 stringify!(BinaryOperator),
6676 stringify!(SlhSlhEql),
6677 ::m2_syn::Spanned::span(self),
6678 ::m2_syn::PrettyTree::pretty_tree(value),
6679 ),
6680 Self::Col(value) => ::m2_syn::PrettyNode::variant(
6681 stringify!(BinaryOperator),
6682 stringify!(Col),
6683 ::m2_syn::Spanned::span(self),
6684 ::m2_syn::PrettyTree::pretty_tree(value),
6685 ),
6686 Self::ColEql(value) => ::m2_syn::PrettyNode::variant(
6687 stringify!(BinaryOperator),
6688 stringify!(ColEql),
6689 ::m2_syn::Spanned::span(self),
6690 ::m2_syn::PrettyTree::pretty_tree(value),
6691 ),
6692 Self::Lst(value) => ::m2_syn::PrettyNode::variant(
6693 stringify!(BinaryOperator),
6694 stringify!(Lst),
6695 ::m2_syn::Spanned::span(self),
6696 ::m2_syn::PrettyTree::pretty_tree(value),
6697 ),
6698 Self::LstLst(value) => ::m2_syn::PrettyNode::variant(
6699 stringify!(BinaryOperator),
6700 stringify!(LstLst),
6701 ::m2_syn::Spanned::span(self),
6702 ::m2_syn::PrettyTree::pretty_tree(value),
6703 ),
6704 Self::LstLstEql(value) => ::m2_syn::PrettyNode::variant(
6705 stringify!(BinaryOperator),
6706 stringify!(LstLstEql),
6707 ::m2_syn::Spanned::span(self),
6708 ::m2_syn::PrettyTree::pretty_tree(value),
6709 ),
6710 Self::LstEql(value) => ::m2_syn::PrettyNode::variant(
6711 stringify!(BinaryOperator),
6712 stringify!(LstEql),
6713 ::m2_syn::Spanned::span(self),
6714 ::m2_syn::PrettyTree::pretty_tree(value),
6715 ),
6716 Self::LstEqlEql(value) => ::m2_syn::PrettyNode::variant(
6717 stringify!(BinaryOperator),
6718 stringify!(LstEqlEql),
6719 ::m2_syn::Spanned::span(self),
6720 ::m2_syn::PrettyTree::pretty_tree(value),
6721 ),
6722 Self::LstEqlEqlEql(value) => ::m2_syn::PrettyNode::variant(
6723 stringify!(BinaryOperator),
6724 stringify!(LstEqlEqlEql),
6725 ::m2_syn::Spanned::span(self),
6726 ::m2_syn::PrettyTree::pretty_tree(value),
6727 ),
6728 Self::LstEqlEqlGst(value) => ::m2_syn::PrettyNode::variant(
6729 stringify!(BinaryOperator),
6730 stringify!(LstEqlEqlGst),
6731 ::m2_syn::Spanned::span(self),
6732 ::m2_syn::PrettyTree::pretty_tree(value),
6733 ),
6734 Self::LstEqlEqlGstEql(value) => ::m2_syn::PrettyNode::variant(
6735 stringify!(BinaryOperator),
6736 stringify!(LstEqlEqlGstEql),
6737 ::m2_syn::Spanned::span(self),
6738 ::m2_syn::PrettyTree::pretty_tree(value),
6739 ),
6740 Self::EqlBngEql(value) => ::m2_syn::PrettyNode::variant(
6741 stringify!(BinaryOperator),
6742 stringify!(EqlBngEql),
6743 ::m2_syn::Spanned::span(self),
6744 ::m2_syn::PrettyTree::pretty_tree(value),
6745 ),
6746 Self::EqlEql(value) => ::m2_syn::PrettyNode::variant(
6747 stringify!(BinaryOperator),
6748 stringify!(EqlEql),
6749 ::m2_syn::Spanned::span(self),
6750 ::m2_syn::PrettyTree::pretty_tree(value),
6751 ),
6752 Self::EqlEqlEql(value) => ::m2_syn::PrettyNode::variant(
6753 stringify!(BinaryOperator),
6754 stringify!(EqlEqlEql),
6755 ::m2_syn::Spanned::span(self),
6756 ::m2_syn::PrettyTree::pretty_tree(value),
6757 ),
6758 Self::EqlEqlEqlGst(value) => ::m2_syn::PrettyNode::variant(
6759 stringify!(BinaryOperator),
6760 stringify!(EqlEqlEqlGst),
6761 ::m2_syn::Spanned::span(self),
6762 ::m2_syn::PrettyTree::pretty_tree(value),
6763 ),
6764 Self::EqlEqlEqlGstEql(value) => ::m2_syn::PrettyNode::variant(
6765 stringify!(BinaryOperator),
6766 stringify!(EqlEqlEqlGstEql),
6767 ::m2_syn::Spanned::span(self),
6768 ::m2_syn::PrettyTree::pretty_tree(value),
6769 ),
6770 Self::EqlEqlGst(value) => ::m2_syn::PrettyNode::variant(
6771 stringify!(BinaryOperator),
6772 stringify!(EqlEqlGst),
6773 ::m2_syn::Spanned::span(self),
6774 ::m2_syn::PrettyTree::pretty_tree(value),
6775 ),
6776 Self::EqlEqlGstEql(value) => ::m2_syn::PrettyNode::variant(
6777 stringify!(BinaryOperator),
6778 stringify!(EqlEqlGstEql),
6779 ::m2_syn::Spanned::span(self),
6780 ::m2_syn::PrettyTree::pretty_tree(value),
6781 ),
6782 Self::Gst(value) => ::m2_syn::PrettyNode::variant(
6783 stringify!(BinaryOperator),
6784 stringify!(Gst),
6785 ::m2_syn::Spanned::span(self),
6786 ::m2_syn::PrettyTree::pretty_tree(value),
6787 ),
6788 Self::GstEql(value) => ::m2_syn::PrettyNode::variant(
6789 stringify!(BinaryOperator),
6790 stringify!(GstEql),
6791 ::m2_syn::Spanned::span(self),
6792 ::m2_syn::PrettyTree::pretty_tree(value),
6793 ),
6794 Self::GstGst(value) => ::m2_syn::PrettyNode::variant(
6795 stringify!(BinaryOperator),
6796 stringify!(GstGst),
6797 ::m2_syn::Spanned::span(self),
6798 ::m2_syn::PrettyTree::pretty_tree(value),
6799 ),
6800 Self::GstGstEql(value) => ::m2_syn::PrettyNode::variant(
6801 stringify!(BinaryOperator),
6802 stringify!(GstGstEql),
6803 ::m2_syn::Spanned::span(self),
6804 ::m2_syn::PrettyTree::pretty_tree(value),
6805 ),
6806 Self::Qsm(value) => ::m2_syn::PrettyNode::variant(
6807 stringify!(BinaryOperator),
6808 stringify!(Qsm),
6809 ::m2_syn::Spanned::span(self),
6810 ::m2_syn::PrettyTree::pretty_tree(value),
6811 ),
6812 Self::QsmQsm(value) => ::m2_syn::PrettyNode::variant(
6813 stringify!(BinaryOperator),
6814 stringify!(QsmQsm),
6815 ::m2_syn::Spanned::span(self),
6816 ::m2_syn::PrettyTree::pretty_tree(value),
6817 ),
6818 Self::QsmQsmEql(value) => ::m2_syn::PrettyNode::variant(
6819 stringify!(BinaryOperator),
6820 stringify!(QsmQsmEql),
6821 ::m2_syn::Spanned::span(self),
6822 ::m2_syn::PrettyTree::pretty_tree(value),
6823 ),
6824 Self::Att(value) => ::m2_syn::PrettyNode::variant(
6825 stringify!(BinaryOperator),
6826 stringify!(Att),
6827 ::m2_syn::Spanned::span(self),
6828 ::m2_syn::PrettyTree::pretty_tree(value),
6829 ),
6830 Self::AttEql(value) => ::m2_syn::PrettyNode::variant(
6831 stringify!(BinaryOperator),
6832 stringify!(AttEql),
6833 ::m2_syn::Spanned::span(self),
6834 ::m2_syn::PrettyTree::pretty_tree(value),
6835 ),
6836 Self::AttAtt(value) => ::m2_syn::PrettyNode::variant(
6837 stringify!(BinaryOperator),
6838 stringify!(AttAtt),
6839 ::m2_syn::Spanned::span(self),
6840 ::m2_syn::PrettyTree::pretty_tree(value),
6841 ),
6842 Self::AttAttEql(value) => ::m2_syn::PrettyNode::variant(
6843 stringify!(BinaryOperator),
6844 stringify!(AttAttEql),
6845 ::m2_syn::Spanned::span(self),
6846 ::m2_syn::PrettyTree::pretty_tree(value),
6847 ),
6848 Self::AttAttQsm(value) => ::m2_syn::PrettyNode::variant(
6849 stringify!(BinaryOperator),
6850 stringify!(AttAttQsm),
6851 ::m2_syn::Spanned::span(self),
6852 ::m2_syn::PrettyTree::pretty_tree(value),
6853 ),
6854 Self::AttAttQsmEql(value) => ::m2_syn::PrettyNode::variant(
6855 stringify!(BinaryOperator),
6856 stringify!(AttAttQsmEql),
6857 ::m2_syn::Spanned::span(self),
6858 ::m2_syn::PrettyTree::pretty_tree(value),
6859 ),
6860 Self::Bsl(value) => ::m2_syn::PrettyNode::variant(
6861 stringify!(BinaryOperator),
6862 stringify!(Bsl),
6863 ::m2_syn::Spanned::span(self),
6864 ::m2_syn::PrettyTree::pretty_tree(value),
6865 ),
6866 Self::BslEql(value) => ::m2_syn::PrettyNode::variant(
6867 stringify!(BinaryOperator),
6868 stringify!(BslEql),
6869 ::m2_syn::Spanned::span(self),
6870 ::m2_syn::PrettyTree::pretty_tree(value),
6871 ),
6872 Self::BslBsl(value) => ::m2_syn::PrettyNode::variant(
6873 stringify!(BinaryOperator),
6874 stringify!(BslBsl),
6875 ::m2_syn::Spanned::span(self),
6876 ::m2_syn::PrettyTree::pretty_tree(value),
6877 ),
6878 Self::BslBslEql(value) => ::m2_syn::PrettyNode::variant(
6879 stringify!(BinaryOperator),
6880 stringify!(BslBslEql),
6881 ::m2_syn::Spanned::span(self),
6882 ::m2_syn::PrettyTree::pretty_tree(value),
6883 ),
6884 Self::Crt(value) => ::m2_syn::PrettyNode::variant(
6885 stringify!(BinaryOperator),
6886 stringify!(Crt),
6887 ::m2_syn::Spanned::span(self),
6888 ::m2_syn::PrettyTree::pretty_tree(value),
6889 ),
6890 Self::CrtEql(value) => ::m2_syn::PrettyNode::variant(
6891 stringify!(BinaryOperator),
6892 stringify!(CrtEql),
6893 ::m2_syn::Spanned::span(self),
6894 ::m2_syn::PrettyTree::pretty_tree(value),
6895 ),
6896 Self::CrtMulMul(value) => ::m2_syn::PrettyNode::variant(
6897 stringify!(BinaryOperator),
6898 stringify!(CrtMulMul),
6899 ::m2_syn::Spanned::span(self),
6900 ::m2_syn::PrettyTree::pretty_tree(value),
6901 ),
6902 Self::CrtMulMulEql(value) => ::m2_syn::PrettyNode::variant(
6903 stringify!(BinaryOperator),
6904 stringify!(CrtMulMulEql),
6905 ::m2_syn::Spanned::span(self),
6906 ::m2_syn::PrettyTree::pretty_tree(value),
6907 ),
6908 Self::CrtLst(value) => ::m2_syn::PrettyNode::variant(
6909 stringify!(BinaryOperator),
6910 stringify!(CrtLst),
6911 ::m2_syn::Spanned::span(self),
6912 ::m2_syn::PrettyTree::pretty_tree(value),
6913 ),
6914 Self::CrtLstEql(value) => ::m2_syn::PrettyNode::variant(
6915 stringify!(BinaryOperator),
6916 stringify!(CrtLstEql),
6917 ::m2_syn::Spanned::span(self),
6918 ::m2_syn::PrettyTree::pretty_tree(value),
6919 ),
6920 Self::CrtGst(value) => ::m2_syn::PrettyNode::variant(
6921 stringify!(BinaryOperator),
6922 stringify!(CrtGst),
6923 ::m2_syn::Spanned::span(self),
6924 ::m2_syn::PrettyTree::pretty_tree(value),
6925 ),
6926 Self::CrtGstEql(value) => ::m2_syn::PrettyNode::variant(
6927 stringify!(BinaryOperator),
6928 stringify!(CrtGstEql),
6929 ::m2_syn::Spanned::span(self),
6930 ::m2_syn::PrettyTree::pretty_tree(value),
6931 ),
6932 Self::CrtCrt(value) => ::m2_syn::PrettyNode::variant(
6933 stringify!(BinaryOperator),
6934 stringify!(CrtCrt),
6935 ::m2_syn::Spanned::span(self),
6936 ::m2_syn::PrettyTree::pretty_tree(value),
6937 ),
6938 Self::CrtCrtEql(value) => ::m2_syn::PrettyNode::variant(
6939 stringify!(BinaryOperator),
6940 stringify!(CrtCrtEql),
6941 ::m2_syn::Spanned::span(self),
6942 ::m2_syn::PrettyTree::pretty_tree(value),
6943 ),
6944 Self::Ubs(value) => ::m2_syn::PrettyNode::variant(
6945 stringify!(BinaryOperator),
6946 stringify!(Ubs),
6947 ::m2_syn::Spanned::span(self),
6948 ::m2_syn::PrettyTree::pretty_tree(value),
6949 ),
6950 Self::UbsEql(value) => ::m2_syn::PrettyNode::variant(
6951 stringify!(BinaryOperator),
6952 stringify!(UbsEql),
6953 ::m2_syn::Spanned::span(self),
6954 ::m2_syn::PrettyTree::pretty_tree(value),
6955 ),
6956 Self::UbsLst(value) => ::m2_syn::PrettyNode::variant(
6957 stringify!(BinaryOperator),
6958 stringify!(UbsLst),
6959 ::m2_syn::Spanned::span(self),
6960 ::m2_syn::PrettyTree::pretty_tree(value),
6961 ),
6962 Self::UbsLstEql(value) => ::m2_syn::PrettyNode::variant(
6963 stringify!(BinaryOperator),
6964 stringify!(UbsLstEql),
6965 ::m2_syn::Spanned::span(self),
6966 ::m2_syn::PrettyTree::pretty_tree(value),
6967 ),
6968 Self::UbsGst(value) => ::m2_syn::PrettyNode::variant(
6969 stringify!(BinaryOperator),
6970 stringify!(UbsGst),
6971 ::m2_syn::Spanned::span(self),
6972 ::m2_syn::PrettyTree::pretty_tree(value),
6973 ),
6974 Self::UbsGstEql(value) => ::m2_syn::PrettyNode::variant(
6975 stringify!(BinaryOperator),
6976 stringify!(UbsGstEql),
6977 ::m2_syn::Spanned::span(self),
6978 ::m2_syn::PrettyTree::pretty_tree(value),
6979 ),
6980 Self::Pip(value) => ::m2_syn::PrettyNode::variant(
6981 stringify!(BinaryOperator),
6982 stringify!(Pip),
6983 ::m2_syn::Spanned::span(self),
6984 ::m2_syn::PrettyTree::pretty_tree(value),
6985 ),
6986 Self::PipEql(value) => ::m2_syn::PrettyNode::variant(
6987 stringify!(BinaryOperator),
6988 stringify!(PipEql),
6989 ::m2_syn::Spanned::span(self),
6990 ::m2_syn::PrettyTree::pretty_tree(value),
6991 ),
6992 Self::PipSub(value) => ::m2_syn::PrettyNode::variant(
6993 stringify!(BinaryOperator),
6994 stringify!(PipSub),
6995 ::m2_syn::Spanned::span(self),
6996 ::m2_syn::PrettyTree::pretty_tree(value),
6997 ),
6998 Self::PipSubEql(value) => ::m2_syn::PrettyNode::variant(
6999 stringify!(BinaryOperator),
7000 stringify!(PipSubEql),
7001 ::m2_syn::Spanned::span(self),
7002 ::m2_syn::PrettyTree::pretty_tree(value),
7003 ),
7004 Self::PipUbs(value) => ::m2_syn::PrettyNode::variant(
7005 stringify!(BinaryOperator),
7006 stringify!(PipUbs),
7007 ::m2_syn::Spanned::span(self),
7008 ::m2_syn::PrettyTree::pretty_tree(value),
7009 ),
7010 Self::PipUbsEql(value) => ::m2_syn::PrettyNode::variant(
7011 stringify!(BinaryOperator),
7012 stringify!(PipUbsEql),
7013 ::m2_syn::Spanned::span(self),
7014 ::m2_syn::PrettyTree::pretty_tree(value),
7015 ),
7016 Self::PipPip(value) => ::m2_syn::PrettyNode::variant(
7017 stringify!(BinaryOperator),
7018 stringify!(PipPip),
7019 ::m2_syn::Spanned::span(self),
7020 ::m2_syn::PrettyTree::pretty_tree(value),
7021 ),
7022 Self::PipPipEql(value) => ::m2_syn::PrettyNode::variant(
7023 stringify!(BinaryOperator),
7024 stringify!(PipPipEql),
7025 ::m2_syn::Spanned::span(self),
7026 ::m2_syn::PrettyTree::pretty_tree(value),
7027 ),
7028 Self::Tld(value) => ::m2_syn::PrettyNode::variant(
7029 stringify!(BinaryOperator),
7030 stringify!(Tld),
7031 ::m2_syn::Spanned::span(self),
7032 ::m2_syn::PrettyTree::pretty_tree(value),
7033 ),
7034 Self::TldEql(value) => ::m2_syn::PrettyNode::variant(
7035 stringify!(BinaryOperator),
7036 stringify!(TldEql),
7037 ::m2_syn::Spanned::span(self),
7038 ::m2_syn::PrettyTree::pretty_tree(value),
7039 ),
7040 Self::Cdt(value) => ::m2_syn::PrettyNode::variant(
7041 stringify!(BinaryOperator),
7042 stringify!(Cdt),
7043 ::m2_syn::Spanned::span(self),
7044 ::m2_syn::PrettyTree::pretty_tree(value),
7045 ),
7046 Self::CdtEql(value) => ::m2_syn::PrettyNode::variant(
7047 stringify!(BinaryOperator),
7048 stringify!(CdtEql),
7049 ::m2_syn::Spanned::span(self),
7050 ::m2_syn::PrettyTree::pretty_tree(value),
7051 ),
7052 Self::Box(value) => ::m2_syn::PrettyNode::variant(
7053 stringify!(BinaryOperator),
7054 stringify!(Box),
7055 ::m2_syn::Spanned::span(self),
7056 ::m2_syn::PrettyTree::pretty_tree(value),
7057 ),
7058 Self::BoxEql(value) => ::m2_syn::PrettyNode::variant(
7059 stringify!(BinaryOperator),
7060 stringify!(BoxEql),
7061 ::m2_syn::Spanned::span(self),
7062 ::m2_syn::PrettyTree::pretty_tree(value),
7063 ),
7064 Self::Sfp(value) => ::m2_syn::PrettyNode::variant(
7065 stringify!(BinaryOperator),
7066 stringify!(Sfp),
7067 ::m2_syn::Spanned::span(self),
7068 ::m2_syn::PrettyTree::pretty_tree(value),
7069 ),
7070 Self::SfpEql(value) => ::m2_syn::PrettyNode::variant(
7071 stringify!(BinaryOperator),
7072 stringify!(SfpEql),
7073 ::m2_syn::Spanned::span(self),
7074 ::m2_syn::PrettyTree::pretty_tree(value),
7075 ),
7076 Self::And(value) => ::m2_syn::PrettyNode::variant(
7077 stringify!(BinaryOperator),
7078 stringify!(And),
7079 ::m2_syn::Spanned::span(self),
7080 ::m2_syn::PrettyTree::pretty_tree(value),
7081 ),
7082 Self::Or(value) => ::m2_syn::PrettyNode::variant(
7083 stringify!(BinaryOperator),
7084 stringify!(Or),
7085 ::m2_syn::Spanned::span(self),
7086 ::m2_syn::PrettyTree::pretty_tree(value),
7087 ),
7088 Self::Space(value) => ::m2_syn::PrettyNode::variant(
7089 stringify!(BinaryOperator),
7090 stringify!(Space),
7091 ::m2_syn::Spanned::span(self),
7092 ::m2_syn::PrettyTree::pretty_tree(value),
7093 ),
7094 Self::Xor(value) => ::m2_syn::PrettyNode::variant(
7095 stringify!(BinaryOperator),
7096 stringify!(Xor),
7097 ::m2_syn::Spanned::span(self),
7098 ::m2_syn::PrettyTree::pretty_tree(value),
7099 ),
7100 }
7101 }
7102}
7103impl<N> ::m2_syn::Reconstruct<N> for BinaryOperator
7104where
7105 N: ::m2_syn::ExternalCstNode,
7106{
7107 fn matches(node: &N) -> bool {
7108 <Token![!=] as ::m2_syn::Reconstruct<N>>::matches(node)
7109 || <Token![#] as ::m2_syn::Reconstruct<N>>::matches(node)
7110 || <Token![#?] as ::m2_syn::Reconstruct<N>>::matches(node)
7111 || <Token![%] as ::m2_syn::Reconstruct<N>>::matches(node)
7112 || <Token![%=] as ::m2_syn::Reconstruct<N>>::matches(node)
7113 || <Token![&] as ::m2_syn::Reconstruct<N>>::matches(node)
7114 || <Token![&=] as ::m2_syn::Reconstruct<N>>::matches(node)
7115 || <Token![*] as ::m2_syn::Reconstruct<N>>::matches(node)
7116 || <Token![*=] as ::m2_syn::Reconstruct<N>>::matches(node)
7117 || <Token![**] as ::m2_syn::Reconstruct<N>>::matches(node)
7118 || <Token![**=] as ::m2_syn::Reconstruct<N>>::matches(node)
7119 || <Token![+] as ::m2_syn::Reconstruct<N>>::matches(node)
7120 || <Token![+=] as ::m2_syn::Reconstruct<N>>::matches(node)
7121 || <Token![++] as ::m2_syn::Reconstruct<N>>::matches(node)
7122 || <Token![++=] as ::m2_syn::Reconstruct<N>>::matches(node)
7123 || <Token![-] as ::m2_syn::Reconstruct<N>>::matches(node)
7124 || <Token![-=] as ::m2_syn::Reconstruct<N>>::matches(node)
7125 || <Token![.] as ::m2_syn::Reconstruct<N>>::matches(node)
7126 || <Token![..] as ::m2_syn::Reconstruct<N>>::matches(node)
7127 || <Token![..=] as ::m2_syn::Reconstruct<N>>::matches(node)
7128 || <Token![..<] as ::m2_syn::Reconstruct<N>>::matches(node)
7129 || <Token![..<=] as ::m2_syn::Reconstruct<N>>::matches(node)
7130 || <Token![.?] as ::m2_syn::Reconstruct<N>>::matches(node)
7131 || <Token![/] as ::m2_syn::Reconstruct<N>>::matches(node)
7132 || <Token![/=] as ::m2_syn::Reconstruct<N>>::matches(node)
7133 || <Token![/ /] as ::m2_syn::Reconstruct<N>>::matches(node)
7134 || <Token![/ /=] as ::m2_syn::Reconstruct<N>>::matches(node)
7135 || <Token![:] as ::m2_syn::Reconstruct<N>>::matches(node)
7136 || <Token![:=] as ::m2_syn::Reconstruct<N>>::matches(node)
7137 || <Token![<] as ::m2_syn::Reconstruct<N>>::matches(node)
7138 || <Token![<<] as ::m2_syn::Reconstruct<N>>::matches(node)
7139 || <Token![<<=] as ::m2_syn::Reconstruct<N>>::matches(node)
7140 || <Token![<=] as ::m2_syn::Reconstruct<N>>::matches(node)
7141 || <Token![<==] as ::m2_syn::Reconstruct<N>>::matches(node)
7142 || <Token![<===] as ::m2_syn::Reconstruct<N>>::matches(node)
7143 || <Token![<==>] as ::m2_syn::Reconstruct<N>>::matches(node)
7144 || <Token![<==>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7145 || <Token![=!=] as ::m2_syn::Reconstruct<N>>::matches(node)
7146 || <Token![==] as ::m2_syn::Reconstruct<N>>::matches(node)
7147 || <Token![===] as ::m2_syn::Reconstruct<N>>::matches(node)
7148 || <Token![===>] as ::m2_syn::Reconstruct<N>>::matches(node)
7149 || <Token![===>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7150 || <Token![==>] as ::m2_syn::Reconstruct<N>>::matches(node)
7151 || <Token![==>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7152 || <Token![>] as ::m2_syn::Reconstruct<N>>::matches(node)
7153 || <Token![>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7154 || <Token![>>] as ::m2_syn::Reconstruct<N>>::matches(node)
7155 || <Token![>>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7156 || <Token![?] as ::m2_syn::Reconstruct<N>>::matches(node)
7157 || <Token![??] as ::m2_syn::Reconstruct<N>>::matches(node)
7158 || <Token![??=] as ::m2_syn::Reconstruct<N>>::matches(node)
7159 || <Token![@] as ::m2_syn::Reconstruct<N>>::matches(node)
7160 || <Token![@=] as ::m2_syn::Reconstruct<N>>::matches(node)
7161 || <Token![@@] as ::m2_syn::Reconstruct<N>>::matches(node)
7162 || <Token![@@=] as ::m2_syn::Reconstruct<N>>::matches(node)
7163 || <Token![@@?] as ::m2_syn::Reconstruct<N>>::matches(node)
7164 || <Token![@@?=] as ::m2_syn::Reconstruct<N>>::matches(node)
7165 || <Token!["\\"] as ::m2_syn::Reconstruct<N>>::matches(node)
7166 || <Token!["\\="] as ::m2_syn::Reconstruct<N>>::matches(node)
7167 || <Token!["\\\\"] as ::m2_syn::Reconstruct<N>>::matches(node)
7168 || <Token!["\\\\="] as ::m2_syn::Reconstruct<N>>::matches(node)
7169 || <Token![^] as ::m2_syn::Reconstruct<N>>::matches(node)
7170 || <Token![^=] as ::m2_syn::Reconstruct<N>>::matches(node)
7171 || <Token![^**] as ::m2_syn::Reconstruct<N>>::matches(node)
7172 || <Token![^**=] as ::m2_syn::Reconstruct<N>>::matches(node)
7173 || <Token![^<] as ::m2_syn::Reconstruct<N>>::matches(node)
7174 || <Token![^<=] as ::m2_syn::Reconstruct<N>>::matches(node)
7175 || <Token![^>] as ::m2_syn::Reconstruct<N>>::matches(node)
7176 || <Token![^>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7177 || <Token![^^] as ::m2_syn::Reconstruct<N>>::matches(node)
7178 || <Token![^^=] as ::m2_syn::Reconstruct<N>>::matches(node)
7179 || <Token![_] as ::m2_syn::Reconstruct<N>>::matches(node)
7180 || <Token![_=] as ::m2_syn::Reconstruct<N>>::matches(node)
7181 || <Token![_<] as ::m2_syn::Reconstruct<N>>::matches(node)
7182 || <Token![_<=] as ::m2_syn::Reconstruct<N>>::matches(node)
7183 || <Token![_>] as ::m2_syn::Reconstruct<N>>::matches(node)
7184 || <Token![_>=] as ::m2_syn::Reconstruct<N>>::matches(node)
7185 || <Token![|] as ::m2_syn::Reconstruct<N>>::matches(node)
7186 || <Token![|=] as ::m2_syn::Reconstruct<N>>::matches(node)
7187 || <Token![|-] as ::m2_syn::Reconstruct<N>>::matches(node)
7188 || <Token![|-=] as ::m2_syn::Reconstruct<N>>::matches(node)
7189 || <Token![|_] as ::m2_syn::Reconstruct<N>>::matches(node)
7190 || <Token![|_=] as ::m2_syn::Reconstruct<N>>::matches(node)
7191 || <Token![||] as ::m2_syn::Reconstruct<N>>::matches(node)
7192 || <Token![||=] as ::m2_syn::Reconstruct<N>>::matches(node)
7193 || <Token![~] as ::m2_syn::Reconstruct<N>>::matches(node)
7194 || <Token![~=] as ::m2_syn::Reconstruct<N>>::matches(node)
7195 || <Token!["·"] as ::m2_syn::Reconstruct<N>>::matches(node)
7196 || <Token!["·="] as ::m2_syn::Reconstruct<N>>::matches(node)
7197 || <Token!["⊠"] as ::m2_syn::Reconstruct<N>>::matches(node)
7198 || <Token!["⊠="] as ::m2_syn::Reconstruct<N>>::matches(node)
7199 || <Token!["⧢"] as ::m2_syn::Reconstruct<N>>::matches(node)
7200 || <Token!["⧢="] as ::m2_syn::Reconstruct<N>>::matches(node)
7201 || <Token![and] as ::m2_syn::Reconstruct<N>>::matches(node)
7202 || <Token![or] as ::m2_syn::Reconstruct<N>>::matches(node)
7203 || <Token![SPACE] as ::m2_syn::Reconstruct<N>>::matches(node)
7204 || <Token![xor] as ::m2_syn::Reconstruct<N>>::matches(node)
7205 }
7206 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
7207 if <Token![!=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7208 return Ok(Self::BngEql(
7209 <Token![!=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7210 ));
7211 }
7212 if <Token![#] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7213 return Ok(Self::Hsh(
7214 <Token![#] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7215 ));
7216 }
7217 if <Token![#?] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7218 return Ok(Self::HshQsm(
7219 <Token![#?] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7220 ));
7221 }
7222 if <Token![%] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7223 return Ok(Self::Mod(
7224 <Token![%] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7225 ));
7226 }
7227 if <Token![%=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7228 return Ok(Self::ModEql(
7229 <Token![%=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7230 ));
7231 }
7232 if <Token![&] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7233 return Ok(Self::Amp(
7234 <Token![&] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7235 ));
7236 }
7237 if <Token![&=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7238 return Ok(Self::AmpEql(
7239 <Token![&=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7240 ));
7241 }
7242 if <Token![*] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7243 return Ok(Self::Mul(
7244 <Token![*] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7245 ));
7246 }
7247 if <Token![*=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7248 return Ok(Self::MulEql(
7249 <Token![*=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7250 ));
7251 }
7252 if <Token![**] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7253 return Ok(Self::MulMul(
7254 <Token![**] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7255 ));
7256 }
7257 if <Token![**=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7258 return Ok(Self::MulMulEql(<Token![**=] as ::m2_syn::Reconstruct<
7259 N,
7260 >>::reconstruct(node)?));
7261 }
7262 if <Token![+] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7263 return Ok(Self::Add(
7264 <Token![+] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7265 ));
7266 }
7267 if <Token![+=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7268 return Ok(Self::AddEql(
7269 <Token![+=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7270 ));
7271 }
7272 if <Token![++] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7273 return Ok(Self::AddAdd(
7274 <Token![++] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7275 ));
7276 }
7277 if <Token![++=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7278 return Ok(Self::AddAddEql(<Token![++=] as ::m2_syn::Reconstruct<
7279 N,
7280 >>::reconstruct(node)?));
7281 }
7282 if <Token![-] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7283 return Ok(Self::Sub(
7284 <Token![-] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7285 ));
7286 }
7287 if <Token![-=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7288 return Ok(Self::SubEql(
7289 <Token![-=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7290 ));
7291 }
7292 if <Token![.] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7293 return Ok(Self::Dot(
7294 <Token![.] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7295 ));
7296 }
7297 if <Token![..] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7298 return Ok(Self::DotDot(
7299 <Token![..] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7300 ));
7301 }
7302 if <Token![..=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7303 return Ok(Self::DotDotEql(<Token![..=] as ::m2_syn::Reconstruct<
7304 N,
7305 >>::reconstruct(node)?));
7306 }
7307 if <Token![..<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7308 return Ok(Self::DotDotLst(<Token![..<] as ::m2_syn::Reconstruct<
7309 N,
7310 >>::reconstruct(node)?));
7311 }
7312 if <Token![..<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7313 return Ok(Self::DotDotLstEql(
7314 <Token![..<=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7315 ));
7316 }
7317 if <Token![.?] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7318 return Ok(Self::DotQsm(
7319 <Token![.?] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7320 ));
7321 }
7322 if <Token![/] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7323 return Ok(Self::Slh(
7324 <Token![/] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7325 ));
7326 }
7327 if <Token![/=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7328 return Ok(Self::SlhEql(
7329 <Token![/=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7330 ));
7331 }
7332 if <Token![/ /] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7333 return Ok(Self::SlhSlh(
7334 <Token![/ /] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7335 ));
7336 }
7337 if <Token![/ /=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7338 return Ok(Self::SlhSlhEql(<Token![/ /=] as ::m2_syn::Reconstruct<
7339 N,
7340 >>::reconstruct(node)?));
7341 }
7342 if <Token![:] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7343 return Ok(Self::Col(
7344 <Token![:] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7345 ));
7346 }
7347 if <Token![:=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7348 return Ok(Self::ColEql(
7349 <Token![:=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7350 ));
7351 }
7352 if <Token![<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7353 return Ok(Self::Lst(
7354 <Token![<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7355 ));
7356 }
7357 if <Token![<<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7358 return Ok(Self::LstLst(
7359 <Token![<<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7360 ));
7361 }
7362 if <Token![<<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7363 return Ok(Self::LstLstEql(<Token![<<=] as ::m2_syn::Reconstruct<
7364 N,
7365 >>::reconstruct(node)?));
7366 }
7367 if <Token![<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7368 return Ok(Self::LstEql(
7369 <Token![<=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7370 ));
7371 }
7372 if <Token![<==] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7373 return Ok(Self::LstEqlEql(<Token![<==] as ::m2_syn::Reconstruct<
7374 N,
7375 >>::reconstruct(node)?));
7376 }
7377 if <Token![<===] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7378 return Ok(Self::LstEqlEqlEql(
7379 <Token![<===] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7380 ));
7381 }
7382 if <Token![<==>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7383 return Ok(Self::LstEqlEqlGst(
7384 <Token![<==>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7385 ));
7386 }
7387 if <Token![<==>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7388 return Ok(Self::LstEqlEqlGstEql(
7389 <Token![<==>=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7390 ));
7391 }
7392 if <Token![=!=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7393 return Ok(Self::EqlBngEql(<Token![=!=] as ::m2_syn::Reconstruct<
7394 N,
7395 >>::reconstruct(node)?));
7396 }
7397 if <Token![==] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7398 return Ok(Self::EqlEql(
7399 <Token![==] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7400 ));
7401 }
7402 if <Token![===] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7403 return Ok(Self::EqlEqlEql(<Token![===] as ::m2_syn::Reconstruct<
7404 N,
7405 >>::reconstruct(node)?));
7406 }
7407 if <Token![===>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7408 return Ok(Self::EqlEqlEqlGst(
7409 <Token![===>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7410 ));
7411 }
7412 if <Token![===>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7413 return Ok(Self::EqlEqlEqlGstEql(
7414 <Token![===>=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7415 ));
7416 }
7417 if <Token![==>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7418 return Ok(Self::EqlEqlGst(<Token![==>] as ::m2_syn::Reconstruct<
7419 N,
7420 >>::reconstruct(node)?));
7421 }
7422 if <Token![==>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7423 return Ok(Self::EqlEqlGstEql(
7424 <Token![==>=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7425 ));
7426 }
7427 if <Token![>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7428 return Ok(Self::Gst(
7429 <Token![>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7430 ));
7431 }
7432 if <Token![>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7433 return Ok(Self::GstEql(
7434 <Token![>=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7435 ));
7436 }
7437 if <Token![>>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7438 return Ok(Self::GstGst(
7439 <Token![>>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7440 ));
7441 }
7442 if <Token![>>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7443 return Ok(Self::GstGstEql(<Token![>>=] as ::m2_syn::Reconstruct<
7444 N,
7445 >>::reconstruct(node)?));
7446 }
7447 if <Token![?] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7448 return Ok(Self::Qsm(
7449 <Token![?] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7450 ));
7451 }
7452 if <Token![??] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7453 return Ok(Self::QsmQsm(
7454 <Token![??] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7455 ));
7456 }
7457 if <Token![??=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7458 return Ok(Self::QsmQsmEql(<Token![??=] as ::m2_syn::Reconstruct<
7459 N,
7460 >>::reconstruct(node)?));
7461 }
7462 if <Token![@] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7463 return Ok(Self::Att(
7464 <Token![@] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7465 ));
7466 }
7467 if <Token![@=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7468 return Ok(Self::AttEql(
7469 <Token![@=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7470 ));
7471 }
7472 if <Token![@@] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7473 return Ok(Self::AttAtt(
7474 <Token![@@] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7475 ));
7476 }
7477 if <Token![@@=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7478 return Ok(Self::AttAttEql(<Token![@@=] as ::m2_syn::Reconstruct<
7479 N,
7480 >>::reconstruct(node)?));
7481 }
7482 if <Token![@@?] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7483 return Ok(Self::AttAttQsm(<Token![@@?] as ::m2_syn::Reconstruct<
7484 N,
7485 >>::reconstruct(node)?));
7486 }
7487 if <Token![@@?=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7488 return Ok(Self::AttAttQsmEql(
7489 <Token![@@?=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7490 ));
7491 }
7492 if <Token!["\\"] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7493 return Ok(Self::Bsl(
7494 <Token!["\\"] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7495 ));
7496 }
7497 if <Token!["\\="] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7498 return Ok(Self::BslEql(
7499 <Token!["\\="] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7500 ));
7501 }
7502 if <Token!["\\\\"] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7503 return Ok(Self::BslBsl(<Token!["\\\\"] as ::m2_syn::Reconstruct<
7504 N,
7505 >>::reconstruct(node)?));
7506 }
7507 if <Token!["\\\\="] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7508 return Ok(Self::BslBslEql(
7509 <Token!["\\\\="] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7510 ));
7511 }
7512 if <Token![^] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7513 return Ok(Self::Crt(
7514 <Token![^] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7515 ));
7516 }
7517 if <Token![^=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7518 return Ok(Self::CrtEql(
7519 <Token![^=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7520 ));
7521 }
7522 if <Token![^**] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7523 return Ok(Self::CrtMulMul(<Token![^**] as ::m2_syn::Reconstruct<
7524 N,
7525 >>::reconstruct(node)?));
7526 }
7527 if <Token![^**=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7528 return Ok(Self::CrtMulMulEql(
7529 <Token![^**=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7530 ));
7531 }
7532 if <Token![^<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7533 return Ok(Self::CrtLst(
7534 <Token![^<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7535 ));
7536 }
7537 if <Token![^<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7538 return Ok(Self::CrtLstEql(<Token![^<=] as ::m2_syn::Reconstruct<
7539 N,
7540 >>::reconstruct(node)?));
7541 }
7542 if <Token![^>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7543 return Ok(Self::CrtGst(
7544 <Token![^>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7545 ));
7546 }
7547 if <Token![^>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7548 return Ok(Self::CrtGstEql(<Token![^>=] as ::m2_syn::Reconstruct<
7549 N,
7550 >>::reconstruct(node)?));
7551 }
7552 if <Token![^^] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7553 return Ok(Self::CrtCrt(
7554 <Token![^^] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7555 ));
7556 }
7557 if <Token![^^=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7558 return Ok(Self::CrtCrtEql(<Token![^^=] as ::m2_syn::Reconstruct<
7559 N,
7560 >>::reconstruct(node)?));
7561 }
7562 if <Token![_] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7563 return Ok(Self::Ubs(
7564 <Token![_] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7565 ));
7566 }
7567 if <Token![_=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7568 return Ok(Self::UbsEql(
7569 <Token![_=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7570 ));
7571 }
7572 if <Token![_<] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7573 return Ok(Self::UbsLst(
7574 <Token![_<] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7575 ));
7576 }
7577 if <Token![_<=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7578 return Ok(Self::UbsLstEql(<Token![_<=] as ::m2_syn::Reconstruct<
7579 N,
7580 >>::reconstruct(node)?));
7581 }
7582 if <Token![_>] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7583 return Ok(Self::UbsGst(
7584 <Token![_>] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7585 ));
7586 }
7587 if <Token![_>=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7588 return Ok(Self::UbsGstEql(<Token![_>=] as ::m2_syn::Reconstruct<
7589 N,
7590 >>::reconstruct(node)?));
7591 }
7592 if <Token![|] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7593 return Ok(Self::Pip(
7594 <Token![|] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7595 ));
7596 }
7597 if <Token![|=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7598 return Ok(Self::PipEql(
7599 <Token![|=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7600 ));
7601 }
7602 if <Token![|-] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7603 return Ok(Self::PipSub(
7604 <Token![|-] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7605 ));
7606 }
7607 if <Token![|-=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7608 return Ok(Self::PipSubEql(<Token![|-=] as ::m2_syn::Reconstruct<
7609 N,
7610 >>::reconstruct(node)?));
7611 }
7612 if <Token![|_] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7613 return Ok(Self::PipUbs(
7614 <Token![|_] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7615 ));
7616 }
7617 if <Token![|_=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7618 return Ok(Self::PipUbsEql(<Token![|_=] as ::m2_syn::Reconstruct<
7619 N,
7620 >>::reconstruct(node)?));
7621 }
7622 if <Token![||] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7623 return Ok(Self::PipPip(
7624 <Token![||] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7625 ));
7626 }
7627 if <Token![||=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7628 return Ok(Self::PipPipEql(<Token![||=] as ::m2_syn::Reconstruct<
7629 N,
7630 >>::reconstruct(node)?));
7631 }
7632 if <Token![~] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7633 return Ok(Self::Tld(
7634 <Token![~] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7635 ));
7636 }
7637 if <Token![~=] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7638 return Ok(Self::TldEql(
7639 <Token![~=] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7640 ));
7641 }
7642 if <Token!["·"] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7643 return Ok(Self::Cdt(
7644 <Token!["·"] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7645 ));
7646 }
7647 if <Token!["·="] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7648 return Ok(Self::CdtEql(
7649 <Token!["·="] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7650 ));
7651 }
7652 if <Token!["⊠"] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7653 return Ok(Self::Box(
7654 <Token!["⊠"] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7655 ));
7656 }
7657 if <Token!["⊠="] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7658 return Ok(Self::BoxEql(<Token!["⊠="] as ::m2_syn::Reconstruct<
7659 N,
7660 >>::reconstruct(node)?));
7661 }
7662 if <Token!["⧢"] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7663 return Ok(Self::Sfp(
7664 <Token!["⧢"] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7665 ));
7666 }
7667 if <Token!["⧢="] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7668 return Ok(Self::SfpEql(<Token!["⧢="] as ::m2_syn::Reconstruct<
7669 N,
7670 >>::reconstruct(node)?));
7671 }
7672 if <Token![and] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7673 return Ok(Self::And(
7674 <Token![and] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7675 ));
7676 }
7677 if <Token![or] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7678 return Ok(Self::Or(
7679 <Token![or] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7680 ));
7681 }
7682 if <Token![SPACE] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7683 return Ok(Self::Space(
7684 <Token![SPACE] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7685 ));
7686 }
7687 if <Token![xor] as ::m2_syn::Reconstruct<N>>::matches(&node) {
7688 return Ok(Self::Xor(
7689 <Token![xor] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
7690 ));
7691 }
7692 Err(::m2_syn::ReconstructError::wrong_category(
7693 stringify!(BinaryOperator),
7694 node.identity(),
7695 ))
7696 }
7697}
7698impl BinaryOperator {
7699 pub fn from_spelling(spelling: &str, span: ::m2_syn::Span) -> ::std::option::Option<Self> {
7700 match spelling {
7701 "!=" => Some(Self::BngEql(Token)),
7702 "#" => Some(Self::Hsh(Token)),
7703 "#?" => Some(Self::HshQsm(Token)),
7704 "%" => Some(Self::Mod(Token)),
7705 "%=" => Some(Self::ModEql(Token)),
7706 "&" => Some(Self::Amp(Token)),
7707 "&=" => Some(Self::AmpEql(Token)),
7708 "*" => Some(Self::Mul(Token)),
7709 "*=" => Some(Self::MulEql(Token)),
7710 "**" => Some(Self::MulMul(Token)),
7711 "**=" => Some(Self::MulMulEql(Token)),
7712 "+" => Some(Self::Add(Token)),
7713 "+=" => Some(Self::AddEql(Token)),
7714 "++" => Some(Self::AddAdd(Token)),
7715 "++=" => Some(Self::AddAddEql(Token)),
7716 "-" => Some(Self::Sub(Token)),
7717 "-=" => Some(Self::SubEql(Token)),
7718 "." => Some(Self::Dot(Token)),
7719 ".." => Some(Self::DotDot(Token)),
7720 "..=" => Some(Self::DotDotEql(Token)),
7721 "..<" => Some(Self::DotDotLst(Token)),
7722 "..<=" => Some(Self::DotDotLstEql(Token)),
7723 ".?" => Some(Self::DotQsm(Token)),
7724 "/" => Some(Self::Slh(Token)),
7725 "/=" => Some(Self::SlhEql(Token)),
7726 "//" => Some(Self::SlhSlh(Token)),
7727 "//=" => Some(Self::SlhSlhEql(Token)),
7728 ":" => Some(Self::Col(Token)),
7729 ":=" => Some(Self::ColEql(Token)),
7730 "<" => Some(Self::Lst(Token)),
7731 "<<" => Some(Self::LstLst(Token)),
7732 "<<=" => Some(Self::LstLstEql(Token)),
7733 "<=" => Some(Self::LstEql(Token)),
7734 "<==" => Some(Self::LstEqlEql(Token)),
7735 "<===" => Some(Self::LstEqlEqlEql(Token)),
7736 "<==>" => Some(Self::LstEqlEqlGst(Token)),
7737 "<==>=" => Some(Self::LstEqlEqlGstEql(Token)),
7738 "=!=" => Some(Self::EqlBngEql(Token)),
7739 "==" => Some(Self::EqlEql(Token)),
7740 "===" => Some(Self::EqlEqlEql(Token)),
7741 "===>" => Some(Self::EqlEqlEqlGst(Token)),
7742 "===>=" => Some(Self::EqlEqlEqlGstEql(Token)),
7743 "==>" => Some(Self::EqlEqlGst(Token)),
7744 "==>=" => Some(Self::EqlEqlGstEql(Token)),
7745 ">" => Some(Self::Gst(Token)),
7746 ">=" => Some(Self::GstEql(Token)),
7747 ">>" => Some(Self::GstGst(Token)),
7748 ">>=" => Some(Self::GstGstEql(Token)),
7749 "?" => Some(Self::Qsm(Token)),
7750 "??" => Some(Self::QsmQsm(Token)),
7751 "??=" => Some(Self::QsmQsmEql(Token)),
7752 "@" => Some(Self::Att(Token)),
7753 "@=" => Some(Self::AttEql(Token)),
7754 "@@" => Some(Self::AttAtt(Token)),
7755 "@@=" => Some(Self::AttAttEql(Token)),
7756 "@@?" => Some(Self::AttAttQsm(Token)),
7757 "@@?=" => Some(Self::AttAttQsmEql(Token)),
7758 "\\" => Some(Self::Bsl(Token)),
7759 "\\=" => Some(Self::BslEql(Token)),
7760 "\\\\" => Some(Self::BslBsl(Token)),
7761 "\\\\=" => Some(Self::BslBslEql(Token)),
7762 "^" => Some(Self::Crt(Token)),
7763 "^=" => Some(Self::CrtEql(Token)),
7764 "^**" => Some(Self::CrtMulMul(Token)),
7765 "^**=" => Some(Self::CrtMulMulEql(Token)),
7766 "^<" => Some(Self::CrtLst(Token)),
7767 "^<=" => Some(Self::CrtLstEql(Token)),
7768 "^>" => Some(Self::CrtGst(Token)),
7769 "^>=" => Some(Self::CrtGstEql(Token)),
7770 "^^" => Some(Self::CrtCrt(Token)),
7771 "^^=" => Some(Self::CrtCrtEql(Token)),
7772 "_" => Some(Self::Ubs(Token)),
7773 "_=" => Some(Self::UbsEql(Token)),
7774 "_<" => Some(Self::UbsLst(Token)),
7775 "_<=" => Some(Self::UbsLstEql(Token)),
7776 "_>" => Some(Self::UbsGst(Token)),
7777 "_>=" => Some(Self::UbsGstEql(Token)),
7778 "|" => Some(Self::Pip(Token)),
7779 "|=" => Some(Self::PipEql(Token)),
7780 "|-" => Some(Self::PipSub(Token)),
7781 "|-=" => Some(Self::PipSubEql(Token)),
7782 "|_" => Some(Self::PipUbs(Token)),
7783 "|_=" => Some(Self::PipUbsEql(Token)),
7784 "||" => Some(Self::PipPip(Token)),
7785 "||=" => Some(Self::PipPipEql(Token)),
7786 "~" => Some(Self::Tld(Token)),
7787 "~=" => Some(Self::TldEql(Token)),
7788 "·" => Some(Self::Cdt(Token)),
7789 "·=" => Some(Self::CdtEql(Token)),
7790 "⊠" => Some(Self::Box(Token)),
7791 "⊠=" => Some(Self::BoxEql(Token)),
7792 "⧢" => Some(Self::Sfp(Token)),
7793 "⧢=" => Some(Self::SfpEql(Token)),
7794 "and" => Some(Self::And(Token)),
7795 "or" => Some(Self::Or(Token)),
7796 "SPACE" => Some(Self::Space(Token)),
7797 "xor" => Some(Self::Xor(Token)),
7798 _ => None,
7799 }
7800 }
7801 pub fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
7802 if <Token![!=] as ::m2_syn::Token>::matches_token_tree(&token) {
7803 return Some(Self::BngEql(
7804 <Token![!=] as ::m2_syn::Token>::from_token_tree(token)?,
7805 ));
7806 }
7807 if <Token![#] as ::m2_syn::Token>::matches_token_tree(&token) {
7808 return Some(Self::Hsh(<Token![#] as ::m2_syn::Token>::from_token_tree(
7809 token,
7810 )?));
7811 }
7812 if <Token![#?] as ::m2_syn::Token>::matches_token_tree(&token) {
7813 return Some(Self::HshQsm(
7814 <Token![#?] as ::m2_syn::Token>::from_token_tree(token)?,
7815 ));
7816 }
7817 if <Token![%] as ::m2_syn::Token>::matches_token_tree(&token) {
7818 return Some(Self::Mod(<Token![%] as ::m2_syn::Token>::from_token_tree(
7819 token,
7820 )?));
7821 }
7822 if <Token![%=] as ::m2_syn::Token>::matches_token_tree(&token) {
7823 return Some(Self::ModEql(
7824 <Token![%=] as ::m2_syn::Token>::from_token_tree(token)?,
7825 ));
7826 }
7827 if <Token![&] as ::m2_syn::Token>::matches_token_tree(&token) {
7828 return Some(Self::Amp(<Token![&] as ::m2_syn::Token>::from_token_tree(
7829 token,
7830 )?));
7831 }
7832 if <Token![&=] as ::m2_syn::Token>::matches_token_tree(&token) {
7833 return Some(Self::AmpEql(
7834 <Token![&=] as ::m2_syn::Token>::from_token_tree(token)?,
7835 ));
7836 }
7837 if <Token![*] as ::m2_syn::Token>::matches_token_tree(&token) {
7838 return Some(Self::Mul(<Token![*] as ::m2_syn::Token>::from_token_tree(
7839 token,
7840 )?));
7841 }
7842 if <Token![*=] as ::m2_syn::Token>::matches_token_tree(&token) {
7843 return Some(Self::MulEql(
7844 <Token![*=] as ::m2_syn::Token>::from_token_tree(token)?,
7845 ));
7846 }
7847 if <Token![**] as ::m2_syn::Token>::matches_token_tree(&token) {
7848 return Some(Self::MulMul(
7849 <Token![**] as ::m2_syn::Token>::from_token_tree(token)?,
7850 ));
7851 }
7852 if <Token![**=] as ::m2_syn::Token>::matches_token_tree(&token) {
7853 return Some(Self::MulMulEql(
7854 <Token![**=] as ::m2_syn::Token>::from_token_tree(token)?,
7855 ));
7856 }
7857 if <Token![+] as ::m2_syn::Token>::matches_token_tree(&token) {
7858 return Some(Self::Add(<Token![+] as ::m2_syn::Token>::from_token_tree(
7859 token,
7860 )?));
7861 }
7862 if <Token![+=] as ::m2_syn::Token>::matches_token_tree(&token) {
7863 return Some(Self::AddEql(
7864 <Token![+=] as ::m2_syn::Token>::from_token_tree(token)?,
7865 ));
7866 }
7867 if <Token![++] as ::m2_syn::Token>::matches_token_tree(&token) {
7868 return Some(Self::AddAdd(
7869 <Token![++] as ::m2_syn::Token>::from_token_tree(token)?,
7870 ));
7871 }
7872 if <Token![++=] as ::m2_syn::Token>::matches_token_tree(&token) {
7873 return Some(Self::AddAddEql(
7874 <Token![++=] as ::m2_syn::Token>::from_token_tree(token)?,
7875 ));
7876 }
7877 if <Token![-] as ::m2_syn::Token>::matches_token_tree(&token) {
7878 return Some(Self::Sub(<Token![-] as ::m2_syn::Token>::from_token_tree(
7879 token,
7880 )?));
7881 }
7882 if <Token![-=] as ::m2_syn::Token>::matches_token_tree(&token) {
7883 return Some(Self::SubEql(
7884 <Token![-=] as ::m2_syn::Token>::from_token_tree(token)?,
7885 ));
7886 }
7887 if <Token![.] as ::m2_syn::Token>::matches_token_tree(&token) {
7888 return Some(Self::Dot(<Token![.] as ::m2_syn::Token>::from_token_tree(
7889 token,
7890 )?));
7891 }
7892 if <Token![..] as ::m2_syn::Token>::matches_token_tree(&token) {
7893 return Some(Self::DotDot(
7894 <Token![..] as ::m2_syn::Token>::from_token_tree(token)?,
7895 ));
7896 }
7897 if <Token![..=] as ::m2_syn::Token>::matches_token_tree(&token) {
7898 return Some(Self::DotDotEql(
7899 <Token![..=] as ::m2_syn::Token>::from_token_tree(token)?,
7900 ));
7901 }
7902 if <Token![..<] as ::m2_syn::Token>::matches_token_tree(&token) {
7903 return Some(Self::DotDotLst(
7904 <Token![..<] as ::m2_syn::Token>::from_token_tree(token)?,
7905 ));
7906 }
7907 if <Token![..<=] as ::m2_syn::Token>::matches_token_tree(&token) {
7908 return Some(Self::DotDotLstEql(
7909 <Token![..<=] as ::m2_syn::Token>::from_token_tree(token)?,
7910 ));
7911 }
7912 if <Token![.?] as ::m2_syn::Token>::matches_token_tree(&token) {
7913 return Some(Self::DotQsm(
7914 <Token![.?] as ::m2_syn::Token>::from_token_tree(token)?,
7915 ));
7916 }
7917 if <Token![/] as ::m2_syn::Token>::matches_token_tree(&token) {
7918 return Some(Self::Slh(<Token![/] as ::m2_syn::Token>::from_token_tree(
7919 token,
7920 )?));
7921 }
7922 if <Token![/=] as ::m2_syn::Token>::matches_token_tree(&token) {
7923 return Some(Self::SlhEql(
7924 <Token![/=] as ::m2_syn::Token>::from_token_tree(token)?,
7925 ));
7926 }
7927 if <Token![/ /] as ::m2_syn::Token>::matches_token_tree(&token) {
7928 return Some(Self::SlhSlh(
7929 <Token![/ /] as ::m2_syn::Token>::from_token_tree(token)?,
7930 ));
7931 }
7932 if <Token![/ /=] as ::m2_syn::Token>::matches_token_tree(&token) {
7933 return Some(Self::SlhSlhEql(
7934 <Token![/ /=] as ::m2_syn::Token>::from_token_tree(token)?,
7935 ));
7936 }
7937 if <Token![:] as ::m2_syn::Token>::matches_token_tree(&token) {
7938 return Some(Self::Col(<Token![:] as ::m2_syn::Token>::from_token_tree(
7939 token,
7940 )?));
7941 }
7942 if <Token![:=] as ::m2_syn::Token>::matches_token_tree(&token) {
7943 return Some(Self::ColEql(
7944 <Token![:=] as ::m2_syn::Token>::from_token_tree(token)?,
7945 ));
7946 }
7947 if <Token![<] as ::m2_syn::Token>::matches_token_tree(&token) {
7948 return Some(Self::Lst(<Token![<] as ::m2_syn::Token>::from_token_tree(
7949 token,
7950 )?));
7951 }
7952 if <Token![<<] as ::m2_syn::Token>::matches_token_tree(&token) {
7953 return Some(Self::LstLst(
7954 <Token![<<] as ::m2_syn::Token>::from_token_tree(token)?,
7955 ));
7956 }
7957 if <Token![<<=] as ::m2_syn::Token>::matches_token_tree(&token) {
7958 return Some(Self::LstLstEql(
7959 <Token![<<=] as ::m2_syn::Token>::from_token_tree(token)?,
7960 ));
7961 }
7962 if <Token![<=] as ::m2_syn::Token>::matches_token_tree(&token) {
7963 return Some(Self::LstEql(
7964 <Token![<=] as ::m2_syn::Token>::from_token_tree(token)?,
7965 ));
7966 }
7967 if <Token![<==] as ::m2_syn::Token>::matches_token_tree(&token) {
7968 return Some(Self::LstEqlEql(
7969 <Token![<==] as ::m2_syn::Token>::from_token_tree(token)?,
7970 ));
7971 }
7972 if <Token![<===] as ::m2_syn::Token>::matches_token_tree(&token) {
7973 return Some(Self::LstEqlEqlEql(
7974 <Token![<===] as ::m2_syn::Token>::from_token_tree(token)?,
7975 ));
7976 }
7977 if <Token![<==>] as ::m2_syn::Token>::matches_token_tree(&token) {
7978 return Some(Self::LstEqlEqlGst(
7979 <Token![<==>] as ::m2_syn::Token>::from_token_tree(token)?,
7980 ));
7981 }
7982 if <Token![<==>=] as ::m2_syn::Token>::matches_token_tree(&token) {
7983 return Some(Self::LstEqlEqlGstEql(
7984 <Token![<==>=] as ::m2_syn::Token>::from_token_tree(token)?,
7985 ));
7986 }
7987 if <Token![=!=] as ::m2_syn::Token>::matches_token_tree(&token) {
7988 return Some(Self::EqlBngEql(
7989 <Token![=!=] as ::m2_syn::Token>::from_token_tree(token)?,
7990 ));
7991 }
7992 if <Token![==] as ::m2_syn::Token>::matches_token_tree(&token) {
7993 return Some(Self::EqlEql(
7994 <Token![==] as ::m2_syn::Token>::from_token_tree(token)?,
7995 ));
7996 }
7997 if <Token![===] as ::m2_syn::Token>::matches_token_tree(&token) {
7998 return Some(Self::EqlEqlEql(
7999 <Token![===] as ::m2_syn::Token>::from_token_tree(token)?,
8000 ));
8001 }
8002 if <Token![===>] as ::m2_syn::Token>::matches_token_tree(&token) {
8003 return Some(Self::EqlEqlEqlGst(
8004 <Token![===>] as ::m2_syn::Token>::from_token_tree(token)?,
8005 ));
8006 }
8007 if <Token![===>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8008 return Some(Self::EqlEqlEqlGstEql(
8009 <Token![===>=] as ::m2_syn::Token>::from_token_tree(token)?,
8010 ));
8011 }
8012 if <Token![==>] as ::m2_syn::Token>::matches_token_tree(&token) {
8013 return Some(Self::EqlEqlGst(
8014 <Token![==>] as ::m2_syn::Token>::from_token_tree(token)?,
8015 ));
8016 }
8017 if <Token![==>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8018 return Some(Self::EqlEqlGstEql(
8019 <Token![==>=] as ::m2_syn::Token>::from_token_tree(token)?,
8020 ));
8021 }
8022 if <Token![>] as ::m2_syn::Token>::matches_token_tree(&token) {
8023 return Some(Self::Gst(<Token![>] as ::m2_syn::Token>::from_token_tree(
8024 token,
8025 )?));
8026 }
8027 if <Token![>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8028 return Some(Self::GstEql(
8029 <Token![>=] as ::m2_syn::Token>::from_token_tree(token)?,
8030 ));
8031 }
8032 if <Token![>>] as ::m2_syn::Token>::matches_token_tree(&token) {
8033 return Some(Self::GstGst(
8034 <Token![>>] as ::m2_syn::Token>::from_token_tree(token)?,
8035 ));
8036 }
8037 if <Token![>>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8038 return Some(Self::GstGstEql(
8039 <Token![>>=] as ::m2_syn::Token>::from_token_tree(token)?,
8040 ));
8041 }
8042 if <Token![?] as ::m2_syn::Token>::matches_token_tree(&token) {
8043 return Some(Self::Qsm(<Token![?] as ::m2_syn::Token>::from_token_tree(
8044 token,
8045 )?));
8046 }
8047 if <Token![??] as ::m2_syn::Token>::matches_token_tree(&token) {
8048 return Some(Self::QsmQsm(
8049 <Token![??] as ::m2_syn::Token>::from_token_tree(token)?,
8050 ));
8051 }
8052 if <Token![??=] as ::m2_syn::Token>::matches_token_tree(&token) {
8053 return Some(Self::QsmQsmEql(
8054 <Token![??=] as ::m2_syn::Token>::from_token_tree(token)?,
8055 ));
8056 }
8057 if <Token![@] as ::m2_syn::Token>::matches_token_tree(&token) {
8058 return Some(Self::Att(<Token![@] as ::m2_syn::Token>::from_token_tree(
8059 token,
8060 )?));
8061 }
8062 if <Token![@=] as ::m2_syn::Token>::matches_token_tree(&token) {
8063 return Some(Self::AttEql(
8064 <Token![@=] as ::m2_syn::Token>::from_token_tree(token)?,
8065 ));
8066 }
8067 if <Token![@@] as ::m2_syn::Token>::matches_token_tree(&token) {
8068 return Some(Self::AttAtt(
8069 <Token![@@] as ::m2_syn::Token>::from_token_tree(token)?,
8070 ));
8071 }
8072 if <Token![@@=] as ::m2_syn::Token>::matches_token_tree(&token) {
8073 return Some(Self::AttAttEql(
8074 <Token![@@=] as ::m2_syn::Token>::from_token_tree(token)?,
8075 ));
8076 }
8077 if <Token![@@?] as ::m2_syn::Token>::matches_token_tree(&token) {
8078 return Some(Self::AttAttQsm(
8079 <Token![@@?] as ::m2_syn::Token>::from_token_tree(token)?,
8080 ));
8081 }
8082 if <Token![@@?=] as ::m2_syn::Token>::matches_token_tree(&token) {
8083 return Some(Self::AttAttQsmEql(
8084 <Token![@@?=] as ::m2_syn::Token>::from_token_tree(token)?,
8085 ));
8086 }
8087 if <Token!["\\"] as ::m2_syn::Token>::matches_token_tree(&token) {
8088 return Some(Self::Bsl(
8089 <Token!["\\"] as ::m2_syn::Token>::from_token_tree(token)?,
8090 ));
8091 }
8092 if <Token!["\\="] as ::m2_syn::Token>::matches_token_tree(&token) {
8093 return Some(Self::BslEql(
8094 <Token!["\\="] as ::m2_syn::Token>::from_token_tree(token)?,
8095 ));
8096 }
8097 if <Token!["\\\\"] as ::m2_syn::Token>::matches_token_tree(&token) {
8098 return Some(Self::BslBsl(
8099 <Token!["\\\\"] as ::m2_syn::Token>::from_token_tree(token)?,
8100 ));
8101 }
8102 if <Token!["\\\\="] as ::m2_syn::Token>::matches_token_tree(&token) {
8103 return Some(Self::BslBslEql(
8104 <Token!["\\\\="] as ::m2_syn::Token>::from_token_tree(token)?,
8105 ));
8106 }
8107 if <Token![^] as ::m2_syn::Token>::matches_token_tree(&token) {
8108 return Some(Self::Crt(<Token![^] as ::m2_syn::Token>::from_token_tree(
8109 token,
8110 )?));
8111 }
8112 if <Token![^=] as ::m2_syn::Token>::matches_token_tree(&token) {
8113 return Some(Self::CrtEql(
8114 <Token![^=] as ::m2_syn::Token>::from_token_tree(token)?,
8115 ));
8116 }
8117 if <Token![^**] as ::m2_syn::Token>::matches_token_tree(&token) {
8118 return Some(Self::CrtMulMul(
8119 <Token![^**] as ::m2_syn::Token>::from_token_tree(token)?,
8120 ));
8121 }
8122 if <Token![^**=] as ::m2_syn::Token>::matches_token_tree(&token) {
8123 return Some(Self::CrtMulMulEql(
8124 <Token![^**=] as ::m2_syn::Token>::from_token_tree(token)?,
8125 ));
8126 }
8127 if <Token![^<] as ::m2_syn::Token>::matches_token_tree(&token) {
8128 return Some(Self::CrtLst(
8129 <Token![^<] as ::m2_syn::Token>::from_token_tree(token)?,
8130 ));
8131 }
8132 if <Token![^<=] as ::m2_syn::Token>::matches_token_tree(&token) {
8133 return Some(Self::CrtLstEql(
8134 <Token![^<=] as ::m2_syn::Token>::from_token_tree(token)?,
8135 ));
8136 }
8137 if <Token![^>] as ::m2_syn::Token>::matches_token_tree(&token) {
8138 return Some(Self::CrtGst(
8139 <Token![^>] as ::m2_syn::Token>::from_token_tree(token)?,
8140 ));
8141 }
8142 if <Token![^>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8143 return Some(Self::CrtGstEql(
8144 <Token![^>=] as ::m2_syn::Token>::from_token_tree(token)?,
8145 ));
8146 }
8147 if <Token![^^] as ::m2_syn::Token>::matches_token_tree(&token) {
8148 return Some(Self::CrtCrt(
8149 <Token![^^] as ::m2_syn::Token>::from_token_tree(token)?,
8150 ));
8151 }
8152 if <Token![^^=] as ::m2_syn::Token>::matches_token_tree(&token) {
8153 return Some(Self::CrtCrtEql(
8154 <Token![^^=] as ::m2_syn::Token>::from_token_tree(token)?,
8155 ));
8156 }
8157 if <Token![_] as ::m2_syn::Token>::matches_token_tree(&token) {
8158 return Some(Self::Ubs(<Token![_] as ::m2_syn::Token>::from_token_tree(
8159 token,
8160 )?));
8161 }
8162 if <Token![_=] as ::m2_syn::Token>::matches_token_tree(&token) {
8163 return Some(Self::UbsEql(
8164 <Token![_=] as ::m2_syn::Token>::from_token_tree(token)?,
8165 ));
8166 }
8167 if <Token![_<] as ::m2_syn::Token>::matches_token_tree(&token) {
8168 return Some(Self::UbsLst(
8169 <Token![_<] as ::m2_syn::Token>::from_token_tree(token)?,
8170 ));
8171 }
8172 if <Token![_<=] as ::m2_syn::Token>::matches_token_tree(&token) {
8173 return Some(Self::UbsLstEql(
8174 <Token![_<=] as ::m2_syn::Token>::from_token_tree(token)?,
8175 ));
8176 }
8177 if <Token![_>] as ::m2_syn::Token>::matches_token_tree(&token) {
8178 return Some(Self::UbsGst(
8179 <Token![_>] as ::m2_syn::Token>::from_token_tree(token)?,
8180 ));
8181 }
8182 if <Token![_>=] as ::m2_syn::Token>::matches_token_tree(&token) {
8183 return Some(Self::UbsGstEql(
8184 <Token![_>=] as ::m2_syn::Token>::from_token_tree(token)?,
8185 ));
8186 }
8187 if <Token![|] as ::m2_syn::Token>::matches_token_tree(&token) {
8188 return Some(Self::Pip(<Token![|] as ::m2_syn::Token>::from_token_tree(
8189 token,
8190 )?));
8191 }
8192 if <Token![|=] as ::m2_syn::Token>::matches_token_tree(&token) {
8193 return Some(Self::PipEql(
8194 <Token![|=] as ::m2_syn::Token>::from_token_tree(token)?,
8195 ));
8196 }
8197 if <Token![|-] as ::m2_syn::Token>::matches_token_tree(&token) {
8198 return Some(Self::PipSub(
8199 <Token![|-] as ::m2_syn::Token>::from_token_tree(token)?,
8200 ));
8201 }
8202 if <Token![|-=] as ::m2_syn::Token>::matches_token_tree(&token) {
8203 return Some(Self::PipSubEql(
8204 <Token![|-=] as ::m2_syn::Token>::from_token_tree(token)?,
8205 ));
8206 }
8207 if <Token![|_] as ::m2_syn::Token>::matches_token_tree(&token) {
8208 return Some(Self::PipUbs(
8209 <Token![|_] as ::m2_syn::Token>::from_token_tree(token)?,
8210 ));
8211 }
8212 if <Token![|_=] as ::m2_syn::Token>::matches_token_tree(&token) {
8213 return Some(Self::PipUbsEql(
8214 <Token![|_=] as ::m2_syn::Token>::from_token_tree(token)?,
8215 ));
8216 }
8217 if <Token![||] as ::m2_syn::Token>::matches_token_tree(&token) {
8218 return Some(Self::PipPip(
8219 <Token![||] as ::m2_syn::Token>::from_token_tree(token)?,
8220 ));
8221 }
8222 if <Token![||=] as ::m2_syn::Token>::matches_token_tree(&token) {
8223 return Some(Self::PipPipEql(
8224 <Token![||=] as ::m2_syn::Token>::from_token_tree(token)?,
8225 ));
8226 }
8227 if <Token![~] as ::m2_syn::Token>::matches_token_tree(&token) {
8228 return Some(Self::Tld(<Token![~] as ::m2_syn::Token>::from_token_tree(
8229 token,
8230 )?));
8231 }
8232 if <Token![~=] as ::m2_syn::Token>::matches_token_tree(&token) {
8233 return Some(Self::TldEql(
8234 <Token![~=] as ::m2_syn::Token>::from_token_tree(token)?,
8235 ));
8236 }
8237 if <Token!["·"] as ::m2_syn::Token>::matches_token_tree(&token) {
8238 return Some(Self::Cdt(
8239 <Token!["·"] as ::m2_syn::Token>::from_token_tree(token)?,
8240 ));
8241 }
8242 if <Token!["·="] as ::m2_syn::Token>::matches_token_tree(&token) {
8243 return Some(Self::CdtEql(
8244 <Token!["·="] as ::m2_syn::Token>::from_token_tree(token)?,
8245 ));
8246 }
8247 if <Token!["⊠"] as ::m2_syn::Token>::matches_token_tree(&token) {
8248 return Some(Self::Box(
8249 <Token!["⊠"] as ::m2_syn::Token>::from_token_tree(token)?,
8250 ));
8251 }
8252 if <Token!["⊠="] as ::m2_syn::Token>::matches_token_tree(&token) {
8253 return Some(Self::BoxEql(
8254 <Token!["⊠="] as ::m2_syn::Token>::from_token_tree(token)?,
8255 ));
8256 }
8257 if <Token!["⧢"] as ::m2_syn::Token>::matches_token_tree(&token) {
8258 return Some(Self::Sfp(
8259 <Token!["⧢"] as ::m2_syn::Token>::from_token_tree(token)?,
8260 ));
8261 }
8262 if <Token!["⧢="] as ::m2_syn::Token>::matches_token_tree(&token) {
8263 return Some(Self::SfpEql(
8264 <Token!["⧢="] as ::m2_syn::Token>::from_token_tree(token)?,
8265 ));
8266 }
8267 if <Token![and] as ::m2_syn::Token>::matches_token_tree(&token) {
8268 return Some(Self::And(
8269 <Token![and] as ::m2_syn::Token>::from_token_tree(token)?,
8270 ));
8271 }
8272 if <Token![or] as ::m2_syn::Token>::matches_token_tree(&token) {
8273 return Some(Self::Or(<Token![or] as ::m2_syn::Token>::from_token_tree(
8274 token,
8275 )?));
8276 }
8277 if <Token![SPACE] as ::m2_syn::Token>::matches_token_tree(&token) {
8278 return Some(Self::Space(
8279 <Token![SPACE] as ::m2_syn::Token>::from_token_tree(token)?,
8280 ));
8281 }
8282 if <Token![xor] as ::m2_syn::Token>::matches_token_tree(&token) {
8283 return Some(Self::Xor(
8284 <Token![xor] as ::m2_syn::Token>::from_token_tree(token)?,
8285 ));
8286 }
8287 None
8288 }
8289 pub fn spelling(&self) -> &'static str {
8290 match self {
8291 Self::BngEql(_) => "!=",
8292 Self::Hsh(_) => "#",
8293 Self::HshQsm(_) => "#?",
8294 Self::Mod(_) => "%",
8295 Self::ModEql(_) => "%=",
8296 Self::Amp(_) => "&",
8297 Self::AmpEql(_) => "&=",
8298 Self::Mul(_) => "*",
8299 Self::MulEql(_) => "*=",
8300 Self::MulMul(_) => "**",
8301 Self::MulMulEql(_) => "**=",
8302 Self::Add(_) => "+",
8303 Self::AddEql(_) => "+=",
8304 Self::AddAdd(_) => "++",
8305 Self::AddAddEql(_) => "++=",
8306 Self::Sub(_) => "-",
8307 Self::SubEql(_) => "-=",
8308 Self::Dot(_) => ".",
8309 Self::DotDot(_) => "..",
8310 Self::DotDotEql(_) => "..=",
8311 Self::DotDotLst(_) => "..<",
8312 Self::DotDotLstEql(_) => "..<=",
8313 Self::DotQsm(_) => ".?",
8314 Self::Slh(_) => "/",
8315 Self::SlhEql(_) => "/=",
8316 Self::SlhSlh(_) => "//",
8317 Self::SlhSlhEql(_) => "//=",
8318 Self::Col(_) => ":",
8319 Self::ColEql(_) => ":=",
8320 Self::Lst(_) => "<",
8321 Self::LstLst(_) => "<<",
8322 Self::LstLstEql(_) => "<<=",
8323 Self::LstEql(_) => "<=",
8324 Self::LstEqlEql(_) => "<==",
8325 Self::LstEqlEqlEql(_) => "<===",
8326 Self::LstEqlEqlGst(_) => "<==>",
8327 Self::LstEqlEqlGstEql(_) => "<==>=",
8328 Self::EqlBngEql(_) => "=!=",
8329 Self::EqlEql(_) => "==",
8330 Self::EqlEqlEql(_) => "===",
8331 Self::EqlEqlEqlGst(_) => "===>",
8332 Self::EqlEqlEqlGstEql(_) => "===>=",
8333 Self::EqlEqlGst(_) => "==>",
8334 Self::EqlEqlGstEql(_) => "==>=",
8335 Self::Gst(_) => ">",
8336 Self::GstEql(_) => ">=",
8337 Self::GstGst(_) => ">>",
8338 Self::GstGstEql(_) => ">>=",
8339 Self::Qsm(_) => "?",
8340 Self::QsmQsm(_) => "??",
8341 Self::QsmQsmEql(_) => "??=",
8342 Self::Att(_) => "@",
8343 Self::AttEql(_) => "@=",
8344 Self::AttAtt(_) => "@@",
8345 Self::AttAttEql(_) => "@@=",
8346 Self::AttAttQsm(_) => "@@?",
8347 Self::AttAttQsmEql(_) => "@@?=",
8348 Self::Bsl(_) => "\\",
8349 Self::BslEql(_) => "\\=",
8350 Self::BslBsl(_) => "\\\\",
8351 Self::BslBslEql(_) => "\\\\=",
8352 Self::Crt(_) => "^",
8353 Self::CrtEql(_) => "^=",
8354 Self::CrtMulMul(_) => "^**",
8355 Self::CrtMulMulEql(_) => "^**=",
8356 Self::CrtLst(_) => "^<",
8357 Self::CrtLstEql(_) => "^<=",
8358 Self::CrtGst(_) => "^>",
8359 Self::CrtGstEql(_) => "^>=",
8360 Self::CrtCrt(_) => "^^",
8361 Self::CrtCrtEql(_) => "^^=",
8362 Self::Ubs(_) => "_",
8363 Self::UbsEql(_) => "_=",
8364 Self::UbsLst(_) => "_<",
8365 Self::UbsLstEql(_) => "_<=",
8366 Self::UbsGst(_) => "_>",
8367 Self::UbsGstEql(_) => "_>=",
8368 Self::Pip(_) => "|",
8369 Self::PipEql(_) => "|=",
8370 Self::PipSub(_) => "|-",
8371 Self::PipSubEql(_) => "|-=",
8372 Self::PipUbs(_) => "|_",
8373 Self::PipUbsEql(_) => "|_=",
8374 Self::PipPip(_) => "||",
8375 Self::PipPipEql(_) => "||=",
8376 Self::Tld(_) => "~",
8377 Self::TldEql(_) => "~=",
8378 Self::Cdt(_) => "·",
8379 Self::CdtEql(_) => "·=",
8380 Self::Box(_) => "⊠",
8381 Self::BoxEql(_) => "⊠=",
8382 Self::Sfp(_) => "⧢",
8383 Self::SfpEql(_) => "⧢=",
8384 Self::And(_) => "and",
8385 Self::Or(_) => "or",
8386 Self::Space(_) => "SPACE",
8387 Self::Xor(_) => "xor",
8388 }
8389 }
8390}
8391#[derive(Debug, ::m2_syn::Spanned)]
8392pub enum PostfixOperator {
8393 Bng(Token![!]),
8394 Graded(Token![(*)]),
8395 CrtBng(Token![^!]),
8396 CrtMul(Token![^*]),
8397 CrtTld(Token![^~]),
8398 UbsBng(Token![_!]),
8399 UbsMul(Token![_*]),
8400 UbsTld(Token![_~]),
8401}
8402impl ::m2_syn::ToTokens for PostfixOperator {
8403 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8404 match self {
8405 Self::Bng(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8406 Self::Graded(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8407 Self::CrtBng(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8408 Self::CrtMul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8409 Self::CrtTld(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8410 Self::UbsBng(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8411 Self::UbsMul(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8412 Self::UbsTld(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8413 }
8414 }
8415}
8416impl ::m2_syn::PrettyTree for PostfixOperator {
8417 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8418 match self {
8419 Self::Bng(value) => ::m2_syn::PrettyNode::variant(
8420 stringify!(PostfixOperator),
8421 stringify!(Bng),
8422 ::m2_syn::Spanned::span(self),
8423 ::m2_syn::PrettyTree::pretty_tree(value),
8424 ),
8425 Self::Graded(value) => ::m2_syn::PrettyNode::variant(
8426 stringify!(PostfixOperator),
8427 stringify!(Graded),
8428 ::m2_syn::Spanned::span(self),
8429 ::m2_syn::PrettyTree::pretty_tree(value),
8430 ),
8431 Self::CrtBng(value) => ::m2_syn::PrettyNode::variant(
8432 stringify!(PostfixOperator),
8433 stringify!(CrtBng),
8434 ::m2_syn::Spanned::span(self),
8435 ::m2_syn::PrettyTree::pretty_tree(value),
8436 ),
8437 Self::CrtMul(value) => ::m2_syn::PrettyNode::variant(
8438 stringify!(PostfixOperator),
8439 stringify!(CrtMul),
8440 ::m2_syn::Spanned::span(self),
8441 ::m2_syn::PrettyTree::pretty_tree(value),
8442 ),
8443 Self::CrtTld(value) => ::m2_syn::PrettyNode::variant(
8444 stringify!(PostfixOperator),
8445 stringify!(CrtTld),
8446 ::m2_syn::Spanned::span(self),
8447 ::m2_syn::PrettyTree::pretty_tree(value),
8448 ),
8449 Self::UbsBng(value) => ::m2_syn::PrettyNode::variant(
8450 stringify!(PostfixOperator),
8451 stringify!(UbsBng),
8452 ::m2_syn::Spanned::span(self),
8453 ::m2_syn::PrettyTree::pretty_tree(value),
8454 ),
8455 Self::UbsMul(value) => ::m2_syn::PrettyNode::variant(
8456 stringify!(PostfixOperator),
8457 stringify!(UbsMul),
8458 ::m2_syn::Spanned::span(self),
8459 ::m2_syn::PrettyTree::pretty_tree(value),
8460 ),
8461 Self::UbsTld(value) => ::m2_syn::PrettyNode::variant(
8462 stringify!(PostfixOperator),
8463 stringify!(UbsTld),
8464 ::m2_syn::Spanned::span(self),
8465 ::m2_syn::PrettyTree::pretty_tree(value),
8466 ),
8467 }
8468 }
8469}
8470impl<N> ::m2_syn::Reconstruct<N> for PostfixOperator
8471where
8472 N: ::m2_syn::ExternalCstNode,
8473{
8474 fn matches(node: &N) -> bool {
8475 <Token![!] as ::m2_syn::Reconstruct<N>>::matches(node)
8476 || <Token![(*)] as ::m2_syn::Reconstruct<N>>::matches(node)
8477 || <Token![^!] as ::m2_syn::Reconstruct<N>>::matches(node)
8478 || <Token![^*] as ::m2_syn::Reconstruct<N>>::matches(node)
8479 || <Token![^~] as ::m2_syn::Reconstruct<N>>::matches(node)
8480 || <Token![_!] as ::m2_syn::Reconstruct<N>>::matches(node)
8481 || <Token![_*] as ::m2_syn::Reconstruct<N>>::matches(node)
8482 || <Token![_~] as ::m2_syn::Reconstruct<N>>::matches(node)
8483 }
8484 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8485 if <Token![!] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8486 return Ok(Self::Bng(
8487 <Token![!] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8488 ));
8489 }
8490 if <Token![(*)] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8491 return Ok(Self::Graded(
8492 <Token![(*)] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8493 ));
8494 }
8495 if <Token![^!] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8496 return Ok(Self::CrtBng(
8497 <Token![^!] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8498 ));
8499 }
8500 if <Token![^*] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8501 return Ok(Self::CrtMul(
8502 <Token![^*] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8503 ));
8504 }
8505 if <Token![^~] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8506 return Ok(Self::CrtTld(
8507 <Token![^~] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8508 ));
8509 }
8510 if <Token![_!] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8511 return Ok(Self::UbsBng(
8512 <Token![_!] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8513 ));
8514 }
8515 if <Token![_*] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8516 return Ok(Self::UbsMul(
8517 <Token![_*] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8518 ));
8519 }
8520 if <Token![_~] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8521 return Ok(Self::UbsTld(
8522 <Token![_~] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8523 ));
8524 }
8525 Err(::m2_syn::ReconstructError::wrong_category(
8526 stringify!(PostfixOperator),
8527 node.identity(),
8528 ))
8529 }
8530}
8531impl PostfixOperator {
8532 pub fn from_spelling(spelling: &str, span: ::m2_syn::Span) -> ::std::option::Option<Self> {
8533 match spelling {
8534 "!" => Some(Self::Bng(Token)),
8535 "(*)" => Some(Self::Graded(Token)),
8536 "^!" => Some(Self::CrtBng(Token)),
8537 "^*" => Some(Self::CrtMul(Token)),
8538 "^~" => Some(Self::CrtTld(Token)),
8539 "_!" => Some(Self::UbsBng(Token)),
8540 "_*" => Some(Self::UbsMul(Token)),
8541 "_~" => Some(Self::UbsTld(Token)),
8542 _ => None,
8543 }
8544 }
8545 pub fn from_token_tree(token: ::m2_syn::TokenTree) -> ::std::option::Option<Self> {
8546 if <Token![!] as ::m2_syn::Token>::matches_token_tree(&token) {
8547 return Some(Self::Bng(<Token![!] as ::m2_syn::Token>::from_token_tree(
8548 token,
8549 )?));
8550 }
8551 if <Token![(*)] as ::m2_syn::Token>::matches_token_tree(&token) {
8552 return Some(Self::Graded(
8553 <Token![(*)] as ::m2_syn::Token>::from_token_tree(token)?,
8554 ));
8555 }
8556 if <Token![^!] as ::m2_syn::Token>::matches_token_tree(&token) {
8557 return Some(Self::CrtBng(
8558 <Token![^!] as ::m2_syn::Token>::from_token_tree(token)?,
8559 ));
8560 }
8561 if <Token![^*] as ::m2_syn::Token>::matches_token_tree(&token) {
8562 return Some(Self::CrtMul(
8563 <Token![^*] as ::m2_syn::Token>::from_token_tree(token)?,
8564 ));
8565 }
8566 if <Token![^~] as ::m2_syn::Token>::matches_token_tree(&token) {
8567 return Some(Self::CrtTld(
8568 <Token![^~] as ::m2_syn::Token>::from_token_tree(token)?,
8569 ));
8570 }
8571 if <Token![_!] as ::m2_syn::Token>::matches_token_tree(&token) {
8572 return Some(Self::UbsBng(
8573 <Token![_!] as ::m2_syn::Token>::from_token_tree(token)?,
8574 ));
8575 }
8576 if <Token![_*] as ::m2_syn::Token>::matches_token_tree(&token) {
8577 return Some(Self::UbsMul(
8578 <Token![_*] as ::m2_syn::Token>::from_token_tree(token)?,
8579 ));
8580 }
8581 if <Token![_~] as ::m2_syn::Token>::matches_token_tree(&token) {
8582 return Some(Self::UbsTld(
8583 <Token![_~] as ::m2_syn::Token>::from_token_tree(token)?,
8584 ));
8585 }
8586 None
8587 }
8588 pub fn spelling(&self) -> &'static str {
8589 match self {
8590 Self::Bng(_) => "!",
8591 Self::Graded(_) => "(*)",
8592 Self::CrtBng(_) => "^!",
8593 Self::CrtMul(_) => "^*",
8594 Self::CrtTld(_) => "^~",
8595 Self::UbsBng(_) => "_!",
8596 Self::UbsMul(_) => "_*",
8597 Self::UbsTld(_) => "_~",
8598 }
8599 }
8600}
8601#[derive(Debug, ::m2_syn::Spanned)]
8602pub enum DebugKeyword {
8603 Step(Token![step]),
8604 Finish(Token![finish]),
8605 Shield(Token![shield]),
8606 Test(Token![TEST]),
8607 Time(Token![time]),
8608 Timing(Token![timing]),
8609 Breakpoint(Token![breakpoint]),
8610 ElapsedTime(Token![elapsedTime]),
8611 ElapsedTiming(Token![elapsedTiming]),
8612 Profile(Token![profile]),
8613}
8614impl ::m2_syn::ToTokens for DebugKeyword {
8615 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8616 match self {
8617 Self::Step(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8618 Self::Finish(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8619 Self::Shield(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8620 Self::Test(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8621 Self::Time(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8622 Self::Timing(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8623 Self::Breakpoint(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8624 Self::ElapsedTime(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8625 Self::ElapsedTiming(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8626 Self::Profile(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8627 }
8628 }
8629}
8630impl ::m2_syn::PrettyTree for DebugKeyword {
8631 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8632 match self {
8633 Self::Step(value) => ::m2_syn::PrettyNode::variant(
8634 stringify!(DebugKeyword),
8635 stringify!(Step),
8636 ::m2_syn::Spanned::span(self),
8637 ::m2_syn::PrettyTree::pretty_tree(value),
8638 ),
8639 Self::Finish(value) => ::m2_syn::PrettyNode::variant(
8640 stringify!(DebugKeyword),
8641 stringify!(Finish),
8642 ::m2_syn::Spanned::span(self),
8643 ::m2_syn::PrettyTree::pretty_tree(value),
8644 ),
8645 Self::Shield(value) => ::m2_syn::PrettyNode::variant(
8646 stringify!(DebugKeyword),
8647 stringify!(Shield),
8648 ::m2_syn::Spanned::span(self),
8649 ::m2_syn::PrettyTree::pretty_tree(value),
8650 ),
8651 Self::Test(value) => ::m2_syn::PrettyNode::variant(
8652 stringify!(DebugKeyword),
8653 stringify!(Test),
8654 ::m2_syn::Spanned::span(self),
8655 ::m2_syn::PrettyTree::pretty_tree(value),
8656 ),
8657 Self::Time(value) => ::m2_syn::PrettyNode::variant(
8658 stringify!(DebugKeyword),
8659 stringify!(Time),
8660 ::m2_syn::Spanned::span(self),
8661 ::m2_syn::PrettyTree::pretty_tree(value),
8662 ),
8663 Self::Timing(value) => ::m2_syn::PrettyNode::variant(
8664 stringify!(DebugKeyword),
8665 stringify!(Timing),
8666 ::m2_syn::Spanned::span(self),
8667 ::m2_syn::PrettyTree::pretty_tree(value),
8668 ),
8669 Self::Breakpoint(value) => ::m2_syn::PrettyNode::variant(
8670 stringify!(DebugKeyword),
8671 stringify!(Breakpoint),
8672 ::m2_syn::Spanned::span(self),
8673 ::m2_syn::PrettyTree::pretty_tree(value),
8674 ),
8675 Self::ElapsedTime(value) => ::m2_syn::PrettyNode::variant(
8676 stringify!(DebugKeyword),
8677 stringify!(ElapsedTime),
8678 ::m2_syn::Spanned::span(self),
8679 ::m2_syn::PrettyTree::pretty_tree(value),
8680 ),
8681 Self::ElapsedTiming(value) => ::m2_syn::PrettyNode::variant(
8682 stringify!(DebugKeyword),
8683 stringify!(ElapsedTiming),
8684 ::m2_syn::Spanned::span(self),
8685 ::m2_syn::PrettyTree::pretty_tree(value),
8686 ),
8687 Self::Profile(value) => ::m2_syn::PrettyNode::variant(
8688 stringify!(DebugKeyword),
8689 stringify!(Profile),
8690 ::m2_syn::Spanned::span(self),
8691 ::m2_syn::PrettyTree::pretty_tree(value),
8692 ),
8693 }
8694 }
8695}
8696impl<N> ::m2_syn::Reconstruct<N> for DebugKeyword
8697where
8698 N: ::m2_syn::ExternalCstNode,
8699{
8700 fn matches(node: &N) -> bool {
8701 <Token![step] as ::m2_syn::Reconstruct<N>>::matches(node)
8702 || <Token![finish] as ::m2_syn::Reconstruct<N>>::matches(node)
8703 || <Token![shield] as ::m2_syn::Reconstruct<N>>::matches(node)
8704 || <Token![TEST] as ::m2_syn::Reconstruct<N>>::matches(node)
8705 || <Token![time] as ::m2_syn::Reconstruct<N>>::matches(node)
8706 || <Token![timing] as ::m2_syn::Reconstruct<N>>::matches(node)
8707 || <Token![breakpoint] as ::m2_syn::Reconstruct<N>>::matches(node)
8708 || <Token![elapsedTime] as ::m2_syn::Reconstruct<N>>::matches(node)
8709 || <Token![elapsedTiming] as ::m2_syn::Reconstruct<N>>::matches(node)
8710 || <Token![profile] as ::m2_syn::Reconstruct<N>>::matches(node)
8711 }
8712 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8713 if <Token![step] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8714 return Ok(Self::Step(
8715 <Token![step] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8716 ));
8717 }
8718 if <Token![finish] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8719 return Ok(Self::Finish(<Token![finish] as ::m2_syn::Reconstruct<
8720 N,
8721 >>::reconstruct(node)?));
8722 }
8723 if <Token![shield] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8724 return Ok(Self::Shield(<Token![shield] as ::m2_syn::Reconstruct<
8725 N,
8726 >>::reconstruct(node)?));
8727 }
8728 if <Token![TEST] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8729 return Ok(Self::Test(
8730 <Token![TEST] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8731 ));
8732 }
8733 if <Token![time] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8734 return Ok(Self::Time(
8735 <Token![time] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8736 ));
8737 }
8738 if <Token![timing] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8739 return Ok(Self::Timing(<Token![timing] as ::m2_syn::Reconstruct<
8740 N,
8741 >>::reconstruct(node)?));
8742 }
8743 if <Token![breakpoint] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8744 return Ok(Self::Breakpoint(
8745 <Token![breakpoint] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8746 ));
8747 }
8748 if <Token![elapsedTime] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8749 return Ok(Self::ElapsedTime(
8750 <Token![elapsedTime] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8751 ));
8752 }
8753 if <Token![elapsedTiming] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8754 return Ok(Self::ElapsedTiming(
8755 <Token![elapsedTiming] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8756 ));
8757 }
8758 if <Token![profile] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8759 return Ok(Self::Profile(<Token![profile] as ::m2_syn::Reconstruct<
8760 N,
8761 >>::reconstruct(node)?));
8762 }
8763 Err(::m2_syn::ReconstructError::wrong_category(
8764 stringify!(DebugKeyword),
8765 node.identity(),
8766 ))
8767 }
8768}
8769#[derive(Debug, ::m2_syn::Spanned)]
8770pub enum TryFallback {
8771 ExceptClause(ExceptClause),
8772 ElseClause(ElseClause),
8773}
8774impl ::m2_syn::ToTokens for TryFallback {
8775 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8776 match self {
8777 Self::ExceptClause(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8778 Self::ElseClause(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8779 }
8780 }
8781}
8782impl ::m2_syn::PrettyTree for TryFallback {
8783 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8784 match self {
8785 Self::ExceptClause(value) => ::m2_syn::PrettyNode::variant(
8786 stringify!(TryFallback),
8787 stringify!(ExceptClause),
8788 ::m2_syn::Spanned::span(self),
8789 ::m2_syn::PrettyTree::pretty_tree(value),
8790 ),
8791 Self::ElseClause(value) => ::m2_syn::PrettyNode::variant(
8792 stringify!(TryFallback),
8793 stringify!(ElseClause),
8794 ::m2_syn::Spanned::span(self),
8795 ::m2_syn::PrettyTree::pretty_tree(value),
8796 ),
8797 }
8798 }
8799}
8800impl<N> ::m2_syn::Reconstruct<N> for TryFallback
8801where
8802 N: ::m2_syn::ExternalCstNode,
8803{
8804 fn matches(node: &N) -> bool {
8805 <ExceptClause as ::m2_syn::Reconstruct<N>>::matches(node)
8806 || <ElseClause as ::m2_syn::Reconstruct<N>>::matches(node)
8807 }
8808 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8809 if <ExceptClause as ::m2_syn::Reconstruct<N>>::matches(&node) {
8810 return Ok(Self::ExceptClause(
8811 <ExceptClause as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8812 ));
8813 }
8814 if <ElseClause as ::m2_syn::Reconstruct<N>>::matches(&node) {
8815 return Ok(Self::ElseClause(<ElseClause as ::m2_syn::Reconstruct<
8816 N,
8817 >>::reconstruct(node)?));
8818 }
8819 Err(::m2_syn::ReconstructError::wrong_category(
8820 stringify!(TryFallback),
8821 node.identity(),
8822 ))
8823 }
8824}
8825#[derive(Debug, ::m2_syn::Spanned)]
8826pub enum QuoteSpecifier {
8827 Symbol(Token![symbol]),
8828 Local(Token![local]),
8829 Global(Token![global]),
8830 ThreadVariable(Token![threadVariable]),
8831 ThreadLocal(Token![threadLocal]),
8832}
8833impl ::m2_syn::ToTokens for QuoteSpecifier {
8834 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8835 match self {
8836 Self::Symbol(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8837 Self::Local(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8838 Self::Global(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8839 Self::ThreadVariable(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8840 Self::ThreadLocal(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8841 }
8842 }
8843}
8844impl ::m2_syn::PrettyTree for QuoteSpecifier {
8845 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8846 match self {
8847 Self::Symbol(value) => ::m2_syn::PrettyNode::variant(
8848 stringify!(QuoteSpecifier),
8849 stringify!(Symbol),
8850 ::m2_syn::Spanned::span(self),
8851 ::m2_syn::PrettyTree::pretty_tree(value),
8852 ),
8853 Self::Local(value) => ::m2_syn::PrettyNode::variant(
8854 stringify!(QuoteSpecifier),
8855 stringify!(Local),
8856 ::m2_syn::Spanned::span(self),
8857 ::m2_syn::PrettyTree::pretty_tree(value),
8858 ),
8859 Self::Global(value) => ::m2_syn::PrettyNode::variant(
8860 stringify!(QuoteSpecifier),
8861 stringify!(Global),
8862 ::m2_syn::Spanned::span(self),
8863 ::m2_syn::PrettyTree::pretty_tree(value),
8864 ),
8865 Self::ThreadVariable(value) => ::m2_syn::PrettyNode::variant(
8866 stringify!(QuoteSpecifier),
8867 stringify!(ThreadVariable),
8868 ::m2_syn::Spanned::span(self),
8869 ::m2_syn::PrettyTree::pretty_tree(value),
8870 ),
8871 Self::ThreadLocal(value) => ::m2_syn::PrettyNode::variant(
8872 stringify!(QuoteSpecifier),
8873 stringify!(ThreadLocal),
8874 ::m2_syn::Spanned::span(self),
8875 ::m2_syn::PrettyTree::pretty_tree(value),
8876 ),
8877 }
8878 }
8879}
8880impl<N> ::m2_syn::Reconstruct<N> for QuoteSpecifier
8881where
8882 N: ::m2_syn::ExternalCstNode,
8883{
8884 fn matches(node: &N) -> bool {
8885 <Token![symbol] as ::m2_syn::Reconstruct<N>>::matches(node)
8886 || <Token![local] as ::m2_syn::Reconstruct<N>>::matches(node)
8887 || <Token![global] as ::m2_syn::Reconstruct<N>>::matches(node)
8888 || <Token![threadVariable] as ::m2_syn::Reconstruct<N>>::matches(node)
8889 || <Token![threadLocal] as ::m2_syn::Reconstruct<N>>::matches(node)
8890 }
8891 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8892 if <Token![symbol] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8893 return Ok(Self::Symbol(<Token![symbol] as ::m2_syn::Reconstruct<
8894 N,
8895 >>::reconstruct(node)?));
8896 }
8897 if <Token![local] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8898 return Ok(Self::Local(
8899 <Token![local] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8900 ));
8901 }
8902 if <Token![global] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8903 return Ok(Self::Global(<Token![global] as ::m2_syn::Reconstruct<
8904 N,
8905 >>::reconstruct(node)?));
8906 }
8907 if <Token![threadVariable] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8908 return Ok(Self::ThreadVariable(
8909 <Token![threadVariable] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8910 ));
8911 }
8912 if <Token![threadLocal] as ::m2_syn::Reconstruct<N>>::matches(&node) {
8913 return Ok(Self::ThreadLocal(
8914 <Token![threadLocal] as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8915 ));
8916 }
8917 Err(::m2_syn::ReconstructError::wrong_category(
8918 stringify!(QuoteSpecifier),
8919 node.identity(),
8920 ))
8921 }
8922}
8923#[derive(Debug, ::m2_syn::Spanned)]
8924pub enum AnyCell {
8925 ExpressionCell(ExpressionCell),
8926 SequenceCell(SequenceCell),
8927 MutedCell(MutedCell),
8928}
8929impl ::m2_syn::ToTokens for AnyCell {
8930 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
8931 match self {
8932 Self::ExpressionCell(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8933 Self::SequenceCell(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8934 Self::MutedCell(node) => ::m2_syn::ToTokens::to_tokens(node, output),
8935 }
8936 }
8937}
8938impl ::m2_syn::PrettyTree for AnyCell {
8939 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
8940 match self {
8941 Self::ExpressionCell(value) => ::m2_syn::PrettyNode::variant(
8942 stringify!(AnyCell),
8943 stringify!(ExpressionCell),
8944 ::m2_syn::Spanned::span(self),
8945 ::m2_syn::PrettyTree::pretty_tree(value),
8946 ),
8947 Self::SequenceCell(value) => ::m2_syn::PrettyNode::variant(
8948 stringify!(AnyCell),
8949 stringify!(SequenceCell),
8950 ::m2_syn::Spanned::span(self),
8951 ::m2_syn::PrettyTree::pretty_tree(value),
8952 ),
8953 Self::MutedCell(value) => ::m2_syn::PrettyNode::variant(
8954 stringify!(AnyCell),
8955 stringify!(MutedCell),
8956 ::m2_syn::Spanned::span(self),
8957 ::m2_syn::PrettyTree::pretty_tree(value),
8958 ),
8959 }
8960 }
8961}
8962impl<N> ::m2_syn::Reconstruct<N> for AnyCell
8963where
8964 N: ::m2_syn::ExternalCstNode,
8965{
8966 fn matches(node: &N) -> bool {
8967 <ExpressionCell as ::m2_syn::Reconstruct<N>>::matches(node)
8968 || <SequenceCell as ::m2_syn::Reconstruct<N>>::matches(node)
8969 || <MutedCell as ::m2_syn::Reconstruct<N>>::matches(node)
8970 }
8971 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
8972 if <ExpressionCell as ::m2_syn::Reconstruct<N>>::matches(&node) {
8973 return Ok(Self::ExpressionCell(
8974 <ExpressionCell as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8975 ));
8976 }
8977 if <SequenceCell as ::m2_syn::Reconstruct<N>>::matches(&node) {
8978 return Ok(Self::SequenceCell(
8979 <SequenceCell as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8980 ));
8981 }
8982 if <MutedCell as ::m2_syn::Reconstruct<N>>::matches(&node) {
8983 return Ok(Self::MutedCell(
8984 <MutedCell as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
8985 ));
8986 }
8987 Err(::m2_syn::ReconstructError::wrong_category(
8988 stringify!(AnyCell),
8989 node.identity(),
8990 ))
8991 }
8992}
8993#[derive(Debug, ::m2_syn::Spanned)]
8994pub enum Component {
8995 EmptyComponent(EmptyComponent),
8996 Expr(Expr),
8997}
8998impl ::m2_syn::ToTokens for Component {
8999 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9000 match self {
9001 Self::EmptyComponent(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9002 Self::Expr(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9003 }
9004 }
9005}
9006impl ::m2_syn::PrettyTree for Component {
9007 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9008 match self {
9009 Self::EmptyComponent(value) => ::m2_syn::PrettyNode::variant(
9010 stringify!(Component),
9011 stringify!(EmptyComponent),
9012 ::m2_syn::Spanned::span(self),
9013 ::m2_syn::PrettyTree::pretty_tree(value),
9014 ),
9015 Self::Expr(value) => ::m2_syn::PrettyNode::variant(
9016 stringify!(Component),
9017 stringify!(Expr),
9018 ::m2_syn::Spanned::span(self),
9019 ::m2_syn::PrettyTree::pretty_tree(value),
9020 ),
9021 }
9022 }
9023}
9024impl<N> ::m2_syn::Reconstruct<N> for Component
9025where
9026 N: ::m2_syn::ExternalCstNode,
9027{
9028 fn matches(node: &N) -> bool {
9029 <EmptyComponent as ::m2_syn::Reconstruct<N>>::matches(node)
9030 || <Expr as ::m2_syn::Reconstruct<N>>::matches(node)
9031 }
9032 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9033 if <EmptyComponent as ::m2_syn::Reconstruct<N>>::matches(&node) {
9034 return Ok(Self::EmptyComponent(
9035 <EmptyComponent as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9036 ));
9037 }
9038 if <Expr as ::m2_syn::Reconstruct<N>>::matches(&node) {
9039 return Ok(Self::Expr(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
9040 node,
9041 )?));
9042 }
9043 Err(::m2_syn::ReconstructError::wrong_category(
9044 stringify!(Component),
9045 node.identity(),
9046 ))
9047 }
9048}
9049#[derive(Debug, ::m2_syn::Spanned)]
9050pub enum SequenceElement {
9051 Component(Component),
9052 MutedGroup(MutedGroup),
9053}
9054impl ::m2_syn::ToTokens for SequenceElement {
9055 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9056 match self {
9057 Self::Component(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9058 Self::MutedGroup(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9059 }
9060 }
9061}
9062impl ::m2_syn::PrettyTree for SequenceElement {
9063 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9064 match self {
9065 Self::Component(value) => ::m2_syn::PrettyNode::variant(
9066 stringify!(SequenceElement),
9067 stringify!(Component),
9068 ::m2_syn::Spanned::span(self),
9069 ::m2_syn::PrettyTree::pretty_tree(value),
9070 ),
9071 Self::MutedGroup(value) => ::m2_syn::PrettyNode::variant(
9072 stringify!(SequenceElement),
9073 stringify!(MutedGroup),
9074 ::m2_syn::Spanned::span(self),
9075 ::m2_syn::PrettyTree::pretty_tree(value),
9076 ),
9077 }
9078 }
9079}
9080impl<N> ::m2_syn::Reconstruct<N> for SequenceElement
9081where
9082 N: ::m2_syn::ExternalCstNode,
9083{
9084 fn matches(node: &N) -> bool {
9085 <Component as ::m2_syn::Reconstruct<N>>::matches(node)
9086 || <MutedGroup as ::m2_syn::Reconstruct<N>>::matches(node)
9087 }
9088 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9089 if <Component as ::m2_syn::Reconstruct<N>>::matches(&node) {
9090 return Ok(Self::Component(
9091 <Component as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9092 ));
9093 }
9094 if <MutedGroup as ::m2_syn::Reconstruct<N>>::matches(&node) {
9095 return Ok(Self::MutedGroup(<MutedGroup as ::m2_syn::Reconstruct<
9096 N,
9097 >>::reconstruct(node)?));
9098 }
9099 Err(::m2_syn::ReconstructError::wrong_category(
9100 stringify!(SequenceElement),
9101 node.identity(),
9102 ))
9103 }
9104}
9105#[derive(Debug, ::m2_syn::Spanned)]
9106pub enum StringElement {
9107 EscapeSequence(EscapeSequence),
9108 StringContent(StringContent),
9109}
9110impl ::m2_syn::ToTokens for StringElement {
9111 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9112 match self {
9113 Self::EscapeSequence(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9114 Self::StringContent(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9115 }
9116 }
9117}
9118impl ::m2_syn::PrettyTree for StringElement {
9119 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9120 match self {
9121 Self::EscapeSequence(value) => ::m2_syn::PrettyNode::variant(
9122 stringify!(StringElement),
9123 stringify!(EscapeSequence),
9124 ::m2_syn::Spanned::span(self),
9125 ::m2_syn::PrettyTree::pretty_tree(value),
9126 ),
9127 Self::StringContent(value) => ::m2_syn::PrettyNode::variant(
9128 stringify!(StringElement),
9129 stringify!(StringContent),
9130 ::m2_syn::Spanned::span(self),
9131 ::m2_syn::PrettyTree::pretty_tree(value),
9132 ),
9133 }
9134 }
9135}
9136impl<N> ::m2_syn::Reconstruct<N> for StringElement
9137where
9138 N: ::m2_syn::ExternalCstNode,
9139{
9140 fn matches(node: &N) -> bool {
9141 <EscapeSequence as ::m2_syn::Reconstruct<N>>::matches(node)
9142 || <StringContent as ::m2_syn::Reconstruct<N>>::matches(node)
9143 }
9144 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9145 if <EscapeSequence as ::m2_syn::Reconstruct<N>>::matches(&node) {
9146 return Ok(Self::EscapeSequence(
9147 <EscapeSequence as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9148 ));
9149 }
9150 if <StringContent as ::m2_syn::Reconstruct<N>>::matches(&node) {
9151 return Ok(Self::StringContent(
9152 <StringContent as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9153 ));
9154 }
9155 Err(::m2_syn::ReconstructError::wrong_category(
9156 stringify!(StringElement),
9157 node.identity(),
9158 ))
9159 }
9160}
9161#[derive(Debug, ::m2_syn::Spanned)]
9162pub enum RawStringElement {
9163 EscapeSequence(EscapeSequence),
9164 RawStringContent(RawStringContent),
9165}
9166impl ::m2_syn::ToTokens for RawStringElement {
9167 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9168 match self {
9169 Self::EscapeSequence(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9170 Self::RawStringContent(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9171 }
9172 }
9173}
9174impl ::m2_syn::PrettyTree for RawStringElement {
9175 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9176 match self {
9177 Self::EscapeSequence(value) => ::m2_syn::PrettyNode::variant(
9178 stringify!(RawStringElement),
9179 stringify!(EscapeSequence),
9180 ::m2_syn::Spanned::span(self),
9181 ::m2_syn::PrettyTree::pretty_tree(value),
9182 ),
9183 Self::RawStringContent(value) => ::m2_syn::PrettyNode::variant(
9184 stringify!(RawStringElement),
9185 stringify!(RawStringContent),
9186 ::m2_syn::Spanned::span(self),
9187 ::m2_syn::PrettyTree::pretty_tree(value),
9188 ),
9189 }
9190 }
9191}
9192impl<N> ::m2_syn::Reconstruct<N> for RawStringElement
9193where
9194 N: ::m2_syn::ExternalCstNode,
9195{
9196 fn matches(node: &N) -> bool {
9197 <EscapeSequence as ::m2_syn::Reconstruct<N>>::matches(node)
9198 || <RawStringContent as ::m2_syn::Reconstruct<N>>::matches(node)
9199 }
9200 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9201 if <EscapeSequence as ::m2_syn::Reconstruct<N>>::matches(&node) {
9202 return Ok(Self::EscapeSequence(
9203 <EscapeSequence as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9204 ));
9205 }
9206 if <RawStringContent as ::m2_syn::Reconstruct<N>>::matches(&node) {
9207 return Ok(Self::RawStringContent(
9208 <RawStringContent as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9209 ));
9210 }
9211 Err(::m2_syn::ReconstructError::wrong_category(
9212 stringify!(RawStringElement),
9213 node.identity(),
9214 ))
9215 }
9216}
9217#[derive(Debug, ::m2_syn::Spanned)]
9218pub enum Collection {
9219 ParenthesizedExpression(ParenthesizedExpression),
9220 Sequence(Sequence),
9221 List(List),
9222 Array(Array),
9223 AngleBarList(AngleBarList),
9224}
9225impl ::m2_syn::ToTokens for Collection {
9226 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9227 match self {
9228 Self::ParenthesizedExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9229 Self::Sequence(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9230 Self::List(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9231 Self::Array(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9232 Self::AngleBarList(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9233 }
9234 }
9235}
9236impl ::m2_syn::PrettyTree for Collection {
9237 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9238 match self {
9239 Self::ParenthesizedExpression(value) => ::m2_syn::PrettyNode::variant(
9240 stringify!(Collection),
9241 stringify!(ParenthesizedExpression),
9242 ::m2_syn::Spanned::span(self),
9243 ::m2_syn::PrettyTree::pretty_tree(value),
9244 ),
9245 Self::Sequence(value) => ::m2_syn::PrettyNode::variant(
9246 stringify!(Collection),
9247 stringify!(Sequence),
9248 ::m2_syn::Spanned::span(self),
9249 ::m2_syn::PrettyTree::pretty_tree(value),
9250 ),
9251 Self::List(value) => ::m2_syn::PrettyNode::variant(
9252 stringify!(Collection),
9253 stringify!(List),
9254 ::m2_syn::Spanned::span(self),
9255 ::m2_syn::PrettyTree::pretty_tree(value),
9256 ),
9257 Self::Array(value) => ::m2_syn::PrettyNode::variant(
9258 stringify!(Collection),
9259 stringify!(Array),
9260 ::m2_syn::Spanned::span(self),
9261 ::m2_syn::PrettyTree::pretty_tree(value),
9262 ),
9263 Self::AngleBarList(value) => ::m2_syn::PrettyNode::variant(
9264 stringify!(Collection),
9265 stringify!(AngleBarList),
9266 ::m2_syn::Spanned::span(self),
9267 ::m2_syn::PrettyTree::pretty_tree(value),
9268 ),
9269 }
9270 }
9271}
9272impl<N> ::m2_syn::Reconstruct<N> for Collection
9273where
9274 N: ::m2_syn::ExternalCstNode,
9275{
9276 fn matches(node: &N) -> bool {
9277 <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9278 || <Sequence as ::m2_syn::Reconstruct<N>>::matches(node)
9279 || <List as ::m2_syn::Reconstruct<N>>::matches(node)
9280 || <Array as ::m2_syn::Reconstruct<N>>::matches(node)
9281 || <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(node)
9282 }
9283 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9284 if <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9285 return Ok(Self::ParenthesizedExpression(
9286 <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9287 ));
9288 }
9289 if <Sequence as ::m2_syn::Reconstruct<N>>::matches(&node) {
9290 return Ok(Self::Sequence(
9291 <Sequence as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9292 ));
9293 }
9294 if <List as ::m2_syn::Reconstruct<N>>::matches(&node) {
9295 return Ok(Self::List(<List as ::m2_syn::Reconstruct<N>>::reconstruct(
9296 node,
9297 )?));
9298 }
9299 if <Array as ::m2_syn::Reconstruct<N>>::matches(&node) {
9300 return Ok(Self::Array(
9301 <Array as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9302 ));
9303 }
9304 if <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(&node) {
9305 return Ok(Self::AngleBarList(
9306 <AngleBarList as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9307 ));
9308 }
9309 Err(::m2_syn::ReconstructError::wrong_category(
9310 stringify!(Collection),
9311 node.identity(),
9312 ))
9313 }
9314}
9315#[derive(Debug, ::m2_syn::Spanned)]
9316pub enum BindingPack {
9317 ParenthesizedExpression(ParenthesizedExpression),
9318 Sequence(Sequence),
9319 List(List),
9320 Array(Array),
9321 AngleBarList(AngleBarList),
9322}
9323impl ::m2_syn::ToTokens for BindingPack {
9324 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9325 match self {
9326 Self::ParenthesizedExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9327 Self::Sequence(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9328 Self::List(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9329 Self::Array(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9330 Self::AngleBarList(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9331 }
9332 }
9333}
9334impl ::m2_syn::PrettyTree for BindingPack {
9335 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9336 match self {
9337 Self::ParenthesizedExpression(value) => ::m2_syn::PrettyNode::variant(
9338 stringify!(BindingPack),
9339 stringify!(ParenthesizedExpression),
9340 ::m2_syn::Spanned::span(self),
9341 ::m2_syn::PrettyTree::pretty_tree(value),
9342 ),
9343 Self::Sequence(value) => ::m2_syn::PrettyNode::variant(
9344 stringify!(BindingPack),
9345 stringify!(Sequence),
9346 ::m2_syn::Spanned::span(self),
9347 ::m2_syn::PrettyTree::pretty_tree(value),
9348 ),
9349 Self::List(value) => ::m2_syn::PrettyNode::variant(
9350 stringify!(BindingPack),
9351 stringify!(List),
9352 ::m2_syn::Spanned::span(self),
9353 ::m2_syn::PrettyTree::pretty_tree(value),
9354 ),
9355 Self::Array(value) => ::m2_syn::PrettyNode::variant(
9356 stringify!(BindingPack),
9357 stringify!(Array),
9358 ::m2_syn::Spanned::span(self),
9359 ::m2_syn::PrettyTree::pretty_tree(value),
9360 ),
9361 Self::AngleBarList(value) => ::m2_syn::PrettyNode::variant(
9362 stringify!(BindingPack),
9363 stringify!(AngleBarList),
9364 ::m2_syn::Spanned::span(self),
9365 ::m2_syn::PrettyTree::pretty_tree(value),
9366 ),
9367 }
9368 }
9369}
9370impl<N> ::m2_syn::Reconstruct<N> for BindingPack
9371where
9372 N: ::m2_syn::ExternalCstNode,
9373{
9374 fn matches(node: &N) -> bool {
9375 <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9376 || <Sequence as ::m2_syn::Reconstruct<N>>::matches(node)
9377 || <List as ::m2_syn::Reconstruct<N>>::matches(node)
9378 || <Array as ::m2_syn::Reconstruct<N>>::matches(node)
9379 || <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(node)
9380 }
9381 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9382 if <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9383 return Ok(Self::ParenthesizedExpression(
9384 <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9385 ));
9386 }
9387 if <Sequence as ::m2_syn::Reconstruct<N>>::matches(&node) {
9388 return Ok(Self::Sequence(
9389 <Sequence as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9390 ));
9391 }
9392 if <List as ::m2_syn::Reconstruct<N>>::matches(&node) {
9393 return Ok(Self::List(<List as ::m2_syn::Reconstruct<N>>::reconstruct(
9394 node,
9395 )?));
9396 }
9397 if <Array as ::m2_syn::Reconstruct<N>>::matches(&node) {
9398 return Ok(Self::Array(
9399 <Array as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9400 ));
9401 }
9402 if <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(&node) {
9403 return Ok(Self::AngleBarList(
9404 <AngleBarList as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9405 ));
9406 }
9407 Err(::m2_syn::ReconstructError::wrong_category(
9408 stringify!(BindingPack),
9409 node.identity(),
9410 ))
9411 }
9412}
9413#[derive(Debug, ::m2_syn::Spanned)]
9414pub enum LambdaParameters {
9415 Symbol(Symbol),
9416 ParenthesizedExpression(ParenthesizedExpression),
9417 Sequence(Sequence),
9418 List(List),
9419 Array(Array),
9420 AngleBarList(AngleBarList),
9421}
9422impl ::m2_syn::ToTokens for LambdaParameters {
9423 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9424 match self {
9425 Self::Symbol(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9426 Self::ParenthesizedExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9427 Self::Sequence(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9428 Self::List(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9429 Self::Array(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9430 Self::AngleBarList(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9431 }
9432 }
9433}
9434impl ::m2_syn::PrettyTree for LambdaParameters {
9435 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9436 match self {
9437 Self::Symbol(value) => ::m2_syn::PrettyNode::variant(
9438 stringify!(LambdaParameters),
9439 stringify!(Symbol),
9440 ::m2_syn::Spanned::span(self),
9441 ::m2_syn::PrettyTree::pretty_tree(value),
9442 ),
9443 Self::ParenthesizedExpression(value) => ::m2_syn::PrettyNode::variant(
9444 stringify!(LambdaParameters),
9445 stringify!(ParenthesizedExpression),
9446 ::m2_syn::Spanned::span(self),
9447 ::m2_syn::PrettyTree::pretty_tree(value),
9448 ),
9449 Self::Sequence(value) => ::m2_syn::PrettyNode::variant(
9450 stringify!(LambdaParameters),
9451 stringify!(Sequence),
9452 ::m2_syn::Spanned::span(self),
9453 ::m2_syn::PrettyTree::pretty_tree(value),
9454 ),
9455 Self::List(value) => ::m2_syn::PrettyNode::variant(
9456 stringify!(LambdaParameters),
9457 stringify!(List),
9458 ::m2_syn::Spanned::span(self),
9459 ::m2_syn::PrettyTree::pretty_tree(value),
9460 ),
9461 Self::Array(value) => ::m2_syn::PrettyNode::variant(
9462 stringify!(LambdaParameters),
9463 stringify!(Array),
9464 ::m2_syn::Spanned::span(self),
9465 ::m2_syn::PrettyTree::pretty_tree(value),
9466 ),
9467 Self::AngleBarList(value) => ::m2_syn::PrettyNode::variant(
9468 stringify!(LambdaParameters),
9469 stringify!(AngleBarList),
9470 ::m2_syn::Spanned::span(self),
9471 ::m2_syn::PrettyTree::pretty_tree(value),
9472 ),
9473 }
9474 }
9475}
9476impl<N> ::m2_syn::Reconstruct<N> for LambdaParameters
9477where
9478 N: ::m2_syn::ExternalCstNode,
9479{
9480 fn matches(node: &N) -> bool {
9481 <Symbol as ::m2_syn::Reconstruct<N>>::matches(node)
9482 || <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9483 || <Sequence as ::m2_syn::Reconstruct<N>>::matches(node)
9484 || <List as ::m2_syn::Reconstruct<N>>::matches(node)
9485 || <Array as ::m2_syn::Reconstruct<N>>::matches(node)
9486 || <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(node)
9487 }
9488 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9489 if <Symbol as ::m2_syn::Reconstruct<N>>::matches(&node) {
9490 return Ok(Self::Symbol(
9491 <Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9492 ));
9493 }
9494 if <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9495 return Ok(Self::ParenthesizedExpression(
9496 <ParenthesizedExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9497 ));
9498 }
9499 if <Sequence as ::m2_syn::Reconstruct<N>>::matches(&node) {
9500 return Ok(Self::Sequence(
9501 <Sequence as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9502 ));
9503 }
9504 if <List as ::m2_syn::Reconstruct<N>>::matches(&node) {
9505 return Ok(Self::List(<List as ::m2_syn::Reconstruct<N>>::reconstruct(
9506 node,
9507 )?));
9508 }
9509 if <Array as ::m2_syn::Reconstruct<N>>::matches(&node) {
9510 return Ok(Self::Array(
9511 <Array as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9512 ));
9513 }
9514 if <AngleBarList as ::m2_syn::Reconstruct<N>>::matches(&node) {
9515 return Ok(Self::AngleBarList(
9516 <AngleBarList as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9517 ));
9518 }
9519 Err(::m2_syn::ReconstructError::wrong_category(
9520 stringify!(LambdaParameters),
9521 node.identity(),
9522 ))
9523 }
9524}
9525#[derive(Debug, ::m2_syn::Spanned)]
9526pub enum OperatorExpr {
9527 AdjacentExpression(AdjacentExpression),
9528 BinaryExpression(BinaryExpression),
9529 PrefixExpression(PrefixExpression),
9530 PostfixExpression(PostfixExpression),
9531}
9532impl ::m2_syn::ToTokens for OperatorExpr {
9533 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9534 match self {
9535 Self::AdjacentExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9536 Self::BinaryExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9537 Self::PrefixExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9538 Self::PostfixExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9539 }
9540 }
9541}
9542impl ::m2_syn::PrettyTree for OperatorExpr {
9543 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9544 match self {
9545 Self::AdjacentExpression(value) => ::m2_syn::PrettyNode::variant(
9546 stringify!(OperatorExpr),
9547 stringify!(AdjacentExpression),
9548 ::m2_syn::Spanned::span(self),
9549 ::m2_syn::PrettyTree::pretty_tree(value),
9550 ),
9551 Self::BinaryExpression(value) => ::m2_syn::PrettyNode::variant(
9552 stringify!(OperatorExpr),
9553 stringify!(BinaryExpression),
9554 ::m2_syn::Spanned::span(self),
9555 ::m2_syn::PrettyTree::pretty_tree(value),
9556 ),
9557 Self::PrefixExpression(value) => ::m2_syn::PrettyNode::variant(
9558 stringify!(OperatorExpr),
9559 stringify!(PrefixExpression),
9560 ::m2_syn::Spanned::span(self),
9561 ::m2_syn::PrettyTree::pretty_tree(value),
9562 ),
9563 Self::PostfixExpression(value) => ::m2_syn::PrettyNode::variant(
9564 stringify!(OperatorExpr),
9565 stringify!(PostfixExpression),
9566 ::m2_syn::Spanned::span(self),
9567 ::m2_syn::PrettyTree::pretty_tree(value),
9568 ),
9569 }
9570 }
9571}
9572impl<N> ::m2_syn::Reconstruct<N> for OperatorExpr
9573where
9574 N: ::m2_syn::ExternalCstNode,
9575{
9576 fn matches(node: &N) -> bool {
9577 <AdjacentExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9578 || <BinaryExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9579 || <PrefixExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9580 || <PostfixExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9581 }
9582 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9583 if <AdjacentExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9584 return Ok(Self::AdjacentExpression(
9585 <AdjacentExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9586 ));
9587 }
9588 if <BinaryExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9589 return Ok(Self::BinaryExpression(
9590 <BinaryExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9591 ));
9592 }
9593 if <PrefixExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9594 return Ok(Self::PrefixExpression(
9595 <PrefixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9596 ));
9597 }
9598 if <PostfixExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
9599 return Ok(Self::PostfixExpression(
9600 <PostfixExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9601 ));
9602 }
9603 Err(::m2_syn::ReconstructError::wrong_category(
9604 stringify!(OperatorExpr),
9605 node.identity(),
9606 ))
9607 }
9608}
9609#[derive(Debug, ::m2_syn::Spanned)]
9610pub enum AssignmentExpr {
9611 Assignment(Assignment),
9612 LocalAssignment(LocalAssignment),
9613 BinaryAssignment(BinaryAssignment),
9614 BinaryInstallation(BinaryInstallation),
9615 PrefixAssignment(PrefixAssignment),
9616 PrefixInstallation(PrefixInstallation),
9617 PostfixAssignment(PostfixAssignment),
9618 PostfixInstallation(PostfixInstallation),
9619 StructuredBinding(StructuredBinding),
9620 LocalStructuredBinding(LocalStructuredBinding),
9621 EvaluatedAssignment(EvaluatedAssignment),
9622}
9623impl ::m2_syn::ToTokens for AssignmentExpr {
9624 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9625 match self {
9626 Self::Assignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9627 Self::LocalAssignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9628 Self::BinaryAssignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9629 Self::BinaryInstallation(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9630 Self::PrefixAssignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9631 Self::PrefixInstallation(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9632 Self::PostfixAssignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9633 Self::PostfixInstallation(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9634 Self::StructuredBinding(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9635 Self::LocalStructuredBinding(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9636 Self::EvaluatedAssignment(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9637 }
9638 }
9639}
9640impl ::m2_syn::PrettyTree for AssignmentExpr {
9641 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9642 match self {
9643 Self::Assignment(value) => ::m2_syn::PrettyNode::variant(
9644 stringify!(AssignmentExpr),
9645 stringify!(Assignment),
9646 ::m2_syn::Spanned::span(self),
9647 ::m2_syn::PrettyTree::pretty_tree(value),
9648 ),
9649 Self::LocalAssignment(value) => ::m2_syn::PrettyNode::variant(
9650 stringify!(AssignmentExpr),
9651 stringify!(LocalAssignment),
9652 ::m2_syn::Spanned::span(self),
9653 ::m2_syn::PrettyTree::pretty_tree(value),
9654 ),
9655 Self::BinaryAssignment(value) => ::m2_syn::PrettyNode::variant(
9656 stringify!(AssignmentExpr),
9657 stringify!(BinaryAssignment),
9658 ::m2_syn::Spanned::span(self),
9659 ::m2_syn::PrettyTree::pretty_tree(value),
9660 ),
9661 Self::BinaryInstallation(value) => ::m2_syn::PrettyNode::variant(
9662 stringify!(AssignmentExpr),
9663 stringify!(BinaryInstallation),
9664 ::m2_syn::Spanned::span(self),
9665 ::m2_syn::PrettyTree::pretty_tree(value),
9666 ),
9667 Self::PrefixAssignment(value) => ::m2_syn::PrettyNode::variant(
9668 stringify!(AssignmentExpr),
9669 stringify!(PrefixAssignment),
9670 ::m2_syn::Spanned::span(self),
9671 ::m2_syn::PrettyTree::pretty_tree(value),
9672 ),
9673 Self::PrefixInstallation(value) => ::m2_syn::PrettyNode::variant(
9674 stringify!(AssignmentExpr),
9675 stringify!(PrefixInstallation),
9676 ::m2_syn::Spanned::span(self),
9677 ::m2_syn::PrettyTree::pretty_tree(value),
9678 ),
9679 Self::PostfixAssignment(value) => ::m2_syn::PrettyNode::variant(
9680 stringify!(AssignmentExpr),
9681 stringify!(PostfixAssignment),
9682 ::m2_syn::Spanned::span(self),
9683 ::m2_syn::PrettyTree::pretty_tree(value),
9684 ),
9685 Self::PostfixInstallation(value) => ::m2_syn::PrettyNode::variant(
9686 stringify!(AssignmentExpr),
9687 stringify!(PostfixInstallation),
9688 ::m2_syn::Spanned::span(self),
9689 ::m2_syn::PrettyTree::pretty_tree(value),
9690 ),
9691 Self::StructuredBinding(value) => ::m2_syn::PrettyNode::variant(
9692 stringify!(AssignmentExpr),
9693 stringify!(StructuredBinding),
9694 ::m2_syn::Spanned::span(self),
9695 ::m2_syn::PrettyTree::pretty_tree(value),
9696 ),
9697 Self::LocalStructuredBinding(value) => ::m2_syn::PrettyNode::variant(
9698 stringify!(AssignmentExpr),
9699 stringify!(LocalStructuredBinding),
9700 ::m2_syn::Spanned::span(self),
9701 ::m2_syn::PrettyTree::pretty_tree(value),
9702 ),
9703 Self::EvaluatedAssignment(value) => ::m2_syn::PrettyNode::variant(
9704 stringify!(AssignmentExpr),
9705 stringify!(EvaluatedAssignment),
9706 ::m2_syn::Spanned::span(self),
9707 ::m2_syn::PrettyTree::pretty_tree(value),
9708 ),
9709 }
9710 }
9711}
9712impl<N> ::m2_syn::Reconstruct<N> for AssignmentExpr
9713where
9714 N: ::m2_syn::ExternalCstNode,
9715{
9716 fn matches(node: &N) -> bool {
9717 <Assignment as ::m2_syn::Reconstruct<N>>::matches(node)
9718 || <LocalAssignment as ::m2_syn::Reconstruct<N>>::matches(node)
9719 || <BinaryAssignment as ::m2_syn::Reconstruct<N>>::matches(node)
9720 || <BinaryInstallation as ::m2_syn::Reconstruct<N>>::matches(node)
9721 || <PrefixAssignment as ::m2_syn::Reconstruct<N>>::matches(node)
9722 || <PrefixInstallation as ::m2_syn::Reconstruct<N>>::matches(node)
9723 || <PostfixAssignment as ::m2_syn::Reconstruct<N>>::matches(node)
9724 || <PostfixInstallation as ::m2_syn::Reconstruct<N>>::matches(node)
9725 || <StructuredBinding as ::m2_syn::Reconstruct<N>>::matches(node)
9726 || <LocalStructuredBinding as ::m2_syn::Reconstruct<N>>::matches(node)
9727 || <EvaluatedAssignment as ::m2_syn::Reconstruct<N>>::matches(node)
9728 }
9729 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
9730 if <Assignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9731 return Ok(Self::Assignment(<Assignment as ::m2_syn::Reconstruct<
9732 N,
9733 >>::reconstruct(node)?));
9734 }
9735 if <LocalAssignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9736 return Ok(Self::LocalAssignment(
9737 <LocalAssignment as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9738 ));
9739 }
9740 if <BinaryAssignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9741 return Ok(Self::BinaryAssignment(
9742 <BinaryAssignment as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9743 ));
9744 }
9745 if <BinaryInstallation as ::m2_syn::Reconstruct<N>>::matches(&node) {
9746 return Ok(Self::BinaryInstallation(
9747 <BinaryInstallation as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9748 ));
9749 }
9750 if <PrefixAssignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9751 return Ok(Self::PrefixAssignment(
9752 <PrefixAssignment as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9753 ));
9754 }
9755 if <PrefixInstallation as ::m2_syn::Reconstruct<N>>::matches(&node) {
9756 return Ok(Self::PrefixInstallation(
9757 <PrefixInstallation as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9758 ));
9759 }
9760 if <PostfixAssignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9761 return Ok(Self::PostfixAssignment(
9762 <PostfixAssignment as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9763 ));
9764 }
9765 if <PostfixInstallation as ::m2_syn::Reconstruct<N>>::matches(&node) {
9766 return Ok(Self::PostfixInstallation(
9767 <PostfixInstallation as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9768 ));
9769 }
9770 if <StructuredBinding as ::m2_syn::Reconstruct<N>>::matches(&node) {
9771 return Ok(Self::StructuredBinding(
9772 <StructuredBinding as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9773 ));
9774 }
9775 if <LocalStructuredBinding as ::m2_syn::Reconstruct<N>>::matches(&node) {
9776 return Ok(Self::LocalStructuredBinding(
9777 <LocalStructuredBinding as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9778 ));
9779 }
9780 if <EvaluatedAssignment as ::m2_syn::Reconstruct<N>>::matches(&node) {
9781 return Ok(Self::EvaluatedAssignment(
9782 <EvaluatedAssignment as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
9783 ));
9784 }
9785 Err(::m2_syn::ReconstructError::wrong_category(
9786 stringify!(AssignmentExpr),
9787 node.identity(),
9788 ))
9789 }
9790}
9791#[derive(Debug, ::m2_syn::Spanned)]
9792pub enum Expr {
9793 Collection(Collection),
9794 OperatorExpr(OperatorExpr),
9795 AssignmentExpr(AssignmentExpr),
9796 OptionExpression(OptionExpression),
9797 LambdaExpression(LambdaExpression),
9798 IfStatement(IfStatement),
9799 ForLoop(ForLoop),
9800 WhileLoop(WhileLoop),
9801 TryStatement(TryStatement),
9802 QuoteExpression(QuoteExpression),
9803 NewStatement(NewStatement),
9804 BreakStatement(BreakStatement),
9805 ContinueStatement(ContinueStatement),
9806 ReturnStatement(ReturnStatement),
9807 CatchStatement(CatchStatement),
9808 ThrowStatement(ThrowStatement),
9809 TrapStatement(TrapStatement),
9810 DebugClause(DebugClause),
9811 FloatLiteral(FloatLiteral),
9812 IntegerLiteral(IntegerLiteral),
9813 RawStringLiteral(RawStringLiteral),
9814 StringLiteral(StringLiteral),
9815 Symbol(Symbol),
9816}
9817impl ::m2_syn::ToTokens for Expr {
9818 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
9819 match self {
9820 Self::Collection(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9821 Self::OperatorExpr(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9822 Self::AssignmentExpr(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9823 Self::OptionExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9824 Self::LambdaExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9825 Self::IfStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9826 Self::ForLoop(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9827 Self::WhileLoop(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9828 Self::TryStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9829 Self::QuoteExpression(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9830 Self::NewStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9831 Self::BreakStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9832 Self::ContinueStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9833 Self::ReturnStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9834 Self::CatchStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9835 Self::ThrowStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9836 Self::TrapStatement(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9837 Self::DebugClause(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9838 Self::FloatLiteral(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9839 Self::IntegerLiteral(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9840 Self::RawStringLiteral(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9841 Self::StringLiteral(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9842 Self::Symbol(node) => ::m2_syn::ToTokens::to_tokens(node, output),
9843 }
9844 }
9845}
9846impl ::m2_syn::PrettyTree for Expr {
9847 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
9848 match self {
9849 Self::Collection(value) => ::m2_syn::PrettyNode::variant(
9850 stringify!(Expr),
9851 stringify!(Collection),
9852 ::m2_syn::Spanned::span(self),
9853 ::m2_syn::PrettyTree::pretty_tree(value),
9854 ),
9855 Self::OperatorExpr(value) => ::m2_syn::PrettyNode::variant(
9856 stringify!(Expr),
9857 stringify!(OperatorExpr),
9858 ::m2_syn::Spanned::span(self),
9859 ::m2_syn::PrettyTree::pretty_tree(value),
9860 ),
9861 Self::AssignmentExpr(value) => ::m2_syn::PrettyNode::variant(
9862 stringify!(Expr),
9863 stringify!(AssignmentExpr),
9864 ::m2_syn::Spanned::span(self),
9865 ::m2_syn::PrettyTree::pretty_tree(value),
9866 ),
9867 Self::OptionExpression(value) => ::m2_syn::PrettyNode::variant(
9868 stringify!(Expr),
9869 stringify!(OptionExpression),
9870 ::m2_syn::Spanned::span(self),
9871 ::m2_syn::PrettyTree::pretty_tree(value),
9872 ),
9873 Self::LambdaExpression(value) => ::m2_syn::PrettyNode::variant(
9874 stringify!(Expr),
9875 stringify!(LambdaExpression),
9876 ::m2_syn::Spanned::span(self),
9877 ::m2_syn::PrettyTree::pretty_tree(value),
9878 ),
9879 Self::IfStatement(value) => ::m2_syn::PrettyNode::variant(
9880 stringify!(Expr),
9881 stringify!(IfStatement),
9882 ::m2_syn::Spanned::span(self),
9883 ::m2_syn::PrettyTree::pretty_tree(value),
9884 ),
9885 Self::ForLoop(value) => ::m2_syn::PrettyNode::variant(
9886 stringify!(Expr),
9887 stringify!(ForLoop),
9888 ::m2_syn::Spanned::span(self),
9889 ::m2_syn::PrettyTree::pretty_tree(value),
9890 ),
9891 Self::WhileLoop(value) => ::m2_syn::PrettyNode::variant(
9892 stringify!(Expr),
9893 stringify!(WhileLoop),
9894 ::m2_syn::Spanned::span(self),
9895 ::m2_syn::PrettyTree::pretty_tree(value),
9896 ),
9897 Self::TryStatement(value) => ::m2_syn::PrettyNode::variant(
9898 stringify!(Expr),
9899 stringify!(TryStatement),
9900 ::m2_syn::Spanned::span(self),
9901 ::m2_syn::PrettyTree::pretty_tree(value),
9902 ),
9903 Self::QuoteExpression(value) => ::m2_syn::PrettyNode::variant(
9904 stringify!(Expr),
9905 stringify!(QuoteExpression),
9906 ::m2_syn::Spanned::span(self),
9907 ::m2_syn::PrettyTree::pretty_tree(value),
9908 ),
9909 Self::NewStatement(value) => ::m2_syn::PrettyNode::variant(
9910 stringify!(Expr),
9911 stringify!(NewStatement),
9912 ::m2_syn::Spanned::span(self),
9913 ::m2_syn::PrettyTree::pretty_tree(value),
9914 ),
9915 Self::BreakStatement(value) => ::m2_syn::PrettyNode::variant(
9916 stringify!(Expr),
9917 stringify!(BreakStatement),
9918 ::m2_syn::Spanned::span(self),
9919 ::m2_syn::PrettyTree::pretty_tree(value),
9920 ),
9921 Self::ContinueStatement(value) => ::m2_syn::PrettyNode::variant(
9922 stringify!(Expr),
9923 stringify!(ContinueStatement),
9924 ::m2_syn::Spanned::span(self),
9925 ::m2_syn::PrettyTree::pretty_tree(value),
9926 ),
9927 Self::ReturnStatement(value) => ::m2_syn::PrettyNode::variant(
9928 stringify!(Expr),
9929 stringify!(ReturnStatement),
9930 ::m2_syn::Spanned::span(self),
9931 ::m2_syn::PrettyTree::pretty_tree(value),
9932 ),
9933 Self::CatchStatement(value) => ::m2_syn::PrettyNode::variant(
9934 stringify!(Expr),
9935 stringify!(CatchStatement),
9936 ::m2_syn::Spanned::span(self),
9937 ::m2_syn::PrettyTree::pretty_tree(value),
9938 ),
9939 Self::ThrowStatement(value) => ::m2_syn::PrettyNode::variant(
9940 stringify!(Expr),
9941 stringify!(ThrowStatement),
9942 ::m2_syn::Spanned::span(self),
9943 ::m2_syn::PrettyTree::pretty_tree(value),
9944 ),
9945 Self::TrapStatement(value) => ::m2_syn::PrettyNode::variant(
9946 stringify!(Expr),
9947 stringify!(TrapStatement),
9948 ::m2_syn::Spanned::span(self),
9949 ::m2_syn::PrettyTree::pretty_tree(value),
9950 ),
9951 Self::DebugClause(value) => ::m2_syn::PrettyNode::variant(
9952 stringify!(Expr),
9953 stringify!(DebugClause),
9954 ::m2_syn::Spanned::span(self),
9955 ::m2_syn::PrettyTree::pretty_tree(value),
9956 ),
9957 Self::FloatLiteral(value) => ::m2_syn::PrettyNode::variant(
9958 stringify!(Expr),
9959 stringify!(FloatLiteral),
9960 ::m2_syn::Spanned::span(self),
9961 ::m2_syn::PrettyTree::pretty_tree(value),
9962 ),
9963 Self::IntegerLiteral(value) => ::m2_syn::PrettyNode::variant(
9964 stringify!(Expr),
9965 stringify!(IntegerLiteral),
9966 ::m2_syn::Spanned::span(self),
9967 ::m2_syn::PrettyTree::pretty_tree(value),
9968 ),
9969 Self::RawStringLiteral(value) => ::m2_syn::PrettyNode::variant(
9970 stringify!(Expr),
9971 stringify!(RawStringLiteral),
9972 ::m2_syn::Spanned::span(self),
9973 ::m2_syn::PrettyTree::pretty_tree(value),
9974 ),
9975 Self::StringLiteral(value) => ::m2_syn::PrettyNode::variant(
9976 stringify!(Expr),
9977 stringify!(StringLiteral),
9978 ::m2_syn::Spanned::span(self),
9979 ::m2_syn::PrettyTree::pretty_tree(value),
9980 ),
9981 Self::Symbol(value) => ::m2_syn::PrettyNode::variant(
9982 stringify!(Expr),
9983 stringify!(Symbol),
9984 ::m2_syn::Spanned::span(self),
9985 ::m2_syn::PrettyTree::pretty_tree(value),
9986 ),
9987 }
9988 }
9989}
9990impl<N> ::m2_syn::Reconstruct<N> for Expr
9991where
9992 N: ::m2_syn::ExternalCstNode,
9993{
9994 fn matches(node: &N) -> bool {
9995 <Collection as ::m2_syn::Reconstruct<N>>::matches(node)
9996 || <OperatorExpr as ::m2_syn::Reconstruct<N>>::matches(node)
9997 || <AssignmentExpr as ::m2_syn::Reconstruct<N>>::matches(node)
9998 || <OptionExpression as ::m2_syn::Reconstruct<N>>::matches(node)
9999 || <LambdaExpression as ::m2_syn::Reconstruct<N>>::matches(node)
10000 || <IfStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10001 || <ForLoop as ::m2_syn::Reconstruct<N>>::matches(node)
10002 || <WhileLoop as ::m2_syn::Reconstruct<N>>::matches(node)
10003 || <TryStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10004 || <QuoteExpression as ::m2_syn::Reconstruct<N>>::matches(node)
10005 || <NewStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10006 || <BreakStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10007 || <ContinueStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10008 || <ReturnStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10009 || <CatchStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10010 || <ThrowStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10011 || <TrapStatement as ::m2_syn::Reconstruct<N>>::matches(node)
10012 || <DebugClause as ::m2_syn::Reconstruct<N>>::matches(node)
10013 || <FloatLiteral as ::m2_syn::Reconstruct<N>>::matches(node)
10014 || <IntegerLiteral as ::m2_syn::Reconstruct<N>>::matches(node)
10015 || <RawStringLiteral as ::m2_syn::Reconstruct<N>>::matches(node)
10016 || <StringLiteral as ::m2_syn::Reconstruct<N>>::matches(node)
10017 || <Symbol as ::m2_syn::Reconstruct<N>>::matches(node)
10018 }
10019 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
10020 if <Collection as ::m2_syn::Reconstruct<N>>::matches(&node) {
10021 return Ok(Self::Collection(<Collection as ::m2_syn::Reconstruct<
10022 N,
10023 >>::reconstruct(node)?));
10024 }
10025 if <OperatorExpr as ::m2_syn::Reconstruct<N>>::matches(&node) {
10026 return Ok(Self::OperatorExpr(
10027 <OperatorExpr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10028 ));
10029 }
10030 if <AssignmentExpr as ::m2_syn::Reconstruct<N>>::matches(&node) {
10031 return Ok(Self::AssignmentExpr(
10032 <AssignmentExpr as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10033 ));
10034 }
10035 if <OptionExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
10036 return Ok(Self::OptionExpression(
10037 <OptionExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10038 ));
10039 }
10040 if <LambdaExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
10041 return Ok(Self::LambdaExpression(
10042 <LambdaExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10043 ));
10044 }
10045 if <IfStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10046 return Ok(Self::IfStatement(<IfStatement as ::m2_syn::Reconstruct<
10047 N,
10048 >>::reconstruct(node)?));
10049 }
10050 if <ForLoop as ::m2_syn::Reconstruct<N>>::matches(&node) {
10051 return Ok(Self::ForLoop(
10052 <ForLoop as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10053 ));
10054 }
10055 if <WhileLoop as ::m2_syn::Reconstruct<N>>::matches(&node) {
10056 return Ok(Self::WhileLoop(
10057 <WhileLoop as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10058 ));
10059 }
10060 if <TryStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10061 return Ok(Self::TryStatement(
10062 <TryStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10063 ));
10064 }
10065 if <QuoteExpression as ::m2_syn::Reconstruct<N>>::matches(&node) {
10066 return Ok(Self::QuoteExpression(
10067 <QuoteExpression as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10068 ));
10069 }
10070 if <NewStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10071 return Ok(Self::NewStatement(
10072 <NewStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10073 ));
10074 }
10075 if <BreakStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10076 return Ok(Self::BreakStatement(
10077 <BreakStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10078 ));
10079 }
10080 if <ContinueStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10081 return Ok(Self::ContinueStatement(
10082 <ContinueStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10083 ));
10084 }
10085 if <ReturnStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10086 return Ok(Self::ReturnStatement(
10087 <ReturnStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10088 ));
10089 }
10090 if <CatchStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10091 return Ok(Self::CatchStatement(
10092 <CatchStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10093 ));
10094 }
10095 if <ThrowStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10096 return Ok(Self::ThrowStatement(
10097 <ThrowStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10098 ));
10099 }
10100 if <TrapStatement as ::m2_syn::Reconstruct<N>>::matches(&node) {
10101 return Ok(Self::TrapStatement(
10102 <TrapStatement as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10103 ));
10104 }
10105 if <DebugClause as ::m2_syn::Reconstruct<N>>::matches(&node) {
10106 return Ok(Self::DebugClause(<DebugClause as ::m2_syn::Reconstruct<
10107 N,
10108 >>::reconstruct(node)?));
10109 }
10110 if <FloatLiteral as ::m2_syn::Reconstruct<N>>::matches(&node) {
10111 return Ok(Self::FloatLiteral(
10112 <FloatLiteral as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10113 ));
10114 }
10115 if <IntegerLiteral as ::m2_syn::Reconstruct<N>>::matches(&node) {
10116 return Ok(Self::IntegerLiteral(
10117 <IntegerLiteral as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10118 ));
10119 }
10120 if <RawStringLiteral as ::m2_syn::Reconstruct<N>>::matches(&node) {
10121 return Ok(Self::RawStringLiteral(
10122 <RawStringLiteral as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10123 ));
10124 }
10125 if <StringLiteral as ::m2_syn::Reconstruct<N>>::matches(&node) {
10126 return Ok(Self::StringLiteral(
10127 <StringLiteral as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10128 ));
10129 }
10130 if <Symbol as ::m2_syn::Reconstruct<N>>::matches(&node) {
10131 return Ok(Self::Symbol(
10132 <Symbol as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10133 ));
10134 }
10135 Err(::m2_syn::ReconstructError::wrong_category(
10136 stringify!(Expr),
10137 node.identity(),
10138 ))
10139 }
10140}
10141#[derive(Debug, ::m2_syn::Spanned)]
10142pub enum SyntaxNode {
10143 SourceFile(SourceFile),
10144 AnyCell(AnyCell),
10145 Expr(Expr),
10146}
10147impl ::m2_syn::ToTokens for SyntaxNode {
10148 fn to_tokens(&self, output: &mut ::m2_syn::TokenStream) {
10149 match self {
10150 Self::SourceFile(node) => ::m2_syn::ToTokens::to_tokens(node, output),
10151 Self::AnyCell(node) => ::m2_syn::ToTokens::to_tokens(node, output),
10152 Self::Expr(node) => ::m2_syn::ToTokens::to_tokens(node, output),
10153 }
10154 }
10155}
10156impl ::m2_syn::PrettyTree for SyntaxNode {
10157 fn pretty_tree(&self) -> ::m2_syn::PrettyNode {
10158 match self {
10159 Self::SourceFile(value) => ::m2_syn::PrettyNode::variant(
10160 stringify!(SyntaxNode),
10161 stringify!(SourceFile),
10162 ::m2_syn::Spanned::span(self),
10163 ::m2_syn::PrettyTree::pretty_tree(value),
10164 ),
10165 Self::AnyCell(value) => ::m2_syn::PrettyNode::variant(
10166 stringify!(SyntaxNode),
10167 stringify!(AnyCell),
10168 ::m2_syn::Spanned::span(self),
10169 ::m2_syn::PrettyTree::pretty_tree(value),
10170 ),
10171 Self::Expr(value) => ::m2_syn::PrettyNode::variant(
10172 stringify!(SyntaxNode),
10173 stringify!(Expr),
10174 ::m2_syn::Spanned::span(self),
10175 ::m2_syn::PrettyTree::pretty_tree(value),
10176 ),
10177 }
10178 }
10179}
10180impl<N> ::m2_syn::Reconstruct<N> for SyntaxNode
10181where
10182 N: ::m2_syn::ExternalCstNode,
10183{
10184 fn matches(node: &N) -> bool {
10185 <SourceFile as ::m2_syn::Reconstruct<N>>::matches(node)
10186 || <AnyCell as ::m2_syn::Reconstruct<N>>::matches(node)
10187 || <Expr as ::m2_syn::Reconstruct<N>>::matches(node)
10188 }
10189 fn reconstruct(node: N) -> Result<Self, ::m2_syn::ReconstructError> {
10190 if <SourceFile as ::m2_syn::Reconstruct<N>>::matches(&node) {
10191 return Ok(Self::SourceFile(<SourceFile as ::m2_syn::Reconstruct<
10192 N,
10193 >>::reconstruct(node)?));
10194 }
10195 if <AnyCell as ::m2_syn::Reconstruct<N>>::matches(&node) {
10196 return Ok(Self::AnyCell(
10197 <AnyCell as ::m2_syn::Reconstruct<N>>::reconstruct(node)?,
10198 ));
10199 }
10200 if <Expr as ::m2_syn::Reconstruct<N>>::matches(&node) {
10201 return Ok(Self::Expr(<Expr as ::m2_syn::Reconstruct<N>>::reconstruct(
10202 node,
10203 )?));
10204 }
10205 Err(::m2_syn::ReconstructError::wrong_category(
10206 stringify!(SyntaxNode),
10207 node.identity(),
10208 ))
10209 }
10210}
10211impl From<Token![+]> for BinaryOperator {
10212 fn from(value: Token![+]) -> Self {
10213 BinaryOperator::Add(value)
10214 }
10215}
10216impl From<Token![+]> for PrefixOperator {
10217 fn from(value: Token![+]) -> Self {
10218 PrefixOperator::Add(value)
10219 }
10220}
10221impl From<Token![++]> for BinaryOperator {
10222 fn from(value: Token![++]) -> Self {
10223 BinaryOperator::AddAdd(value)
10224 }
10225}
10226impl From<Token![++=]> for BinaryOperator {
10227 fn from(value: Token![++=]) -> Self {
10228 BinaryOperator::AddAddEql(value)
10229 }
10230}
10231impl From<Token![+=]> for BinaryOperator {
10232 fn from(value: Token![+=]) -> Self {
10233 BinaryOperator::AddEql(value)
10234 }
10235}
10236impl From<AdjacentExpression> for Component {
10237 fn from(value: AdjacentExpression) -> Self {
10238 Component::Expr(Expr::OperatorExpr(OperatorExpr::AdjacentExpression(value)))
10239 }
10240}
10241impl From<AdjacentExpression> for Expr {
10242 fn from(value: AdjacentExpression) -> Self {
10243 Expr::OperatorExpr(OperatorExpr::AdjacentExpression(value))
10244 }
10245}
10246impl From<AdjacentExpression> for OperatorExpr {
10247 fn from(value: AdjacentExpression) -> Self {
10248 OperatorExpr::AdjacentExpression(value)
10249 }
10250}
10251impl From<AdjacentExpression> for SequenceElement {
10252 fn from(value: AdjacentExpression) -> Self {
10253 SequenceElement::Component(Component::Expr(Expr::OperatorExpr(
10254 OperatorExpr::AdjacentExpression(value),
10255 )))
10256 }
10257}
10258impl From<AdjacentExpression> for SyntaxNode {
10259 fn from(value: AdjacentExpression) -> Self {
10260 SyntaxNode::Expr(Expr::OperatorExpr(OperatorExpr::AdjacentExpression(value)))
10261 }
10262}
10263impl From<Token![&]> for BinaryOperator {
10264 fn from(value: Token![&]) -> Self {
10265 BinaryOperator::Amp(value)
10266 }
10267}
10268impl From<Token![&=]> for BinaryOperator {
10269 fn from(value: Token![&=]) -> Self {
10270 BinaryOperator::AmpEql(value)
10271 }
10272}
10273impl From<Token![and]> for BinaryOperator {
10274 fn from(value: Token![and]) -> Self {
10275 BinaryOperator::And(value)
10276 }
10277}
10278impl From<AngleBarList> for BindingPack {
10279 fn from(value: AngleBarList) -> Self {
10280 BindingPack::AngleBarList(value)
10281 }
10282}
10283impl From<AngleBarList> for Collection {
10284 fn from(value: AngleBarList) -> Self {
10285 Collection::AngleBarList(value)
10286 }
10287}
10288impl From<AngleBarList> for Component {
10289 fn from(value: AngleBarList) -> Self {
10290 Component::Expr(Expr::Collection(Collection::AngleBarList(value)))
10291 }
10292}
10293impl From<AngleBarList> for Expr {
10294 fn from(value: AngleBarList) -> Self {
10295 Expr::Collection(Collection::AngleBarList(value))
10296 }
10297}
10298impl From<AngleBarList> for LambdaParameters {
10299 fn from(value: AngleBarList) -> Self {
10300 LambdaParameters::AngleBarList(value)
10301 }
10302}
10303impl From<AngleBarList> for SequenceElement {
10304 fn from(value: AngleBarList) -> Self {
10305 SequenceElement::Component(Component::Expr(Expr::Collection(Collection::AngleBarList(
10306 value,
10307 ))))
10308 }
10309}
10310impl From<AngleBarList> for SyntaxNode {
10311 fn from(value: AngleBarList) -> Self {
10312 SyntaxNode::Expr(Expr::Collection(Collection::AngleBarList(value)))
10313 }
10314}
10315impl From<AnyCell> for SyntaxNode {
10316 fn from(value: AnyCell) -> Self {
10317 SyntaxNode::AnyCell(value)
10318 }
10319}
10320impl From<Array> for BindingPack {
10321 fn from(value: Array) -> Self {
10322 BindingPack::Array(value)
10323 }
10324}
10325impl From<Array> for Collection {
10326 fn from(value: Array) -> Self {
10327 Collection::Array(value)
10328 }
10329}
10330impl From<Array> for Component {
10331 fn from(value: Array) -> Self {
10332 Component::Expr(Expr::Collection(Collection::Array(value)))
10333 }
10334}
10335impl From<Array> for Expr {
10336 fn from(value: Array) -> Self {
10337 Expr::Collection(Collection::Array(value))
10338 }
10339}
10340impl From<Array> for LambdaParameters {
10341 fn from(value: Array) -> Self {
10342 LambdaParameters::Array(value)
10343 }
10344}
10345impl From<Array> for SequenceElement {
10346 fn from(value: Array) -> Self {
10347 SequenceElement::Component(Component::Expr(Expr::Collection(Collection::Array(value))))
10348 }
10349}
10350impl From<Array> for SyntaxNode {
10351 fn from(value: Array) -> Self {
10352 SyntaxNode::Expr(Expr::Collection(Collection::Array(value)))
10353 }
10354}
10355impl From<Assignment> for AssignmentExpr {
10356 fn from(value: Assignment) -> Self {
10357 AssignmentExpr::Assignment(value)
10358 }
10359}
10360impl From<Assignment> for Component {
10361 fn from(value: Assignment) -> Self {
10362 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::Assignment(value)))
10363 }
10364}
10365impl From<Assignment> for Expr {
10366 fn from(value: Assignment) -> Self {
10367 Expr::AssignmentExpr(AssignmentExpr::Assignment(value))
10368 }
10369}
10370impl From<Assignment> for SequenceElement {
10371 fn from(value: Assignment) -> Self {
10372 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
10373 AssignmentExpr::Assignment(value),
10374 )))
10375 }
10376}
10377impl From<Assignment> for SyntaxNode {
10378 fn from(value: Assignment) -> Self {
10379 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::Assignment(value)))
10380 }
10381}
10382impl From<AssignmentExpr> for Component {
10383 fn from(value: AssignmentExpr) -> Self {
10384 Component::Expr(Expr::AssignmentExpr(value))
10385 }
10386}
10387impl From<AssignmentExpr> for Expr {
10388 fn from(value: AssignmentExpr) -> Self {
10389 Expr::AssignmentExpr(value)
10390 }
10391}
10392impl From<AssignmentExpr> for SequenceElement {
10393 fn from(value: AssignmentExpr) -> Self {
10394 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(value)))
10395 }
10396}
10397impl From<AssignmentExpr> for SyntaxNode {
10398 fn from(value: AssignmentExpr) -> Self {
10399 SyntaxNode::Expr(Expr::AssignmentExpr(value))
10400 }
10401}
10402impl From<Token![@]> for BinaryOperator {
10403 fn from(value: Token![@]) -> Self {
10404 BinaryOperator::Att(value)
10405 }
10406}
10407impl From<Token![@@]> for BinaryOperator {
10408 fn from(value: Token![@@]) -> Self {
10409 BinaryOperator::AttAtt(value)
10410 }
10411}
10412impl From<Token![@@=]> for BinaryOperator {
10413 fn from(value: Token![@@=]) -> Self {
10414 BinaryOperator::AttAttEql(value)
10415 }
10416}
10417impl From<Token![@@?]> for BinaryOperator {
10418 fn from(value: Token![@@?]) -> Self {
10419 BinaryOperator::AttAttQsm(value)
10420 }
10421}
10422impl From<Token![@@?=]> for BinaryOperator {
10423 fn from(value: Token![@@?=]) -> Self {
10424 BinaryOperator::AttAttQsmEql(value)
10425 }
10426}
10427impl From<Token![@=]> for BinaryOperator {
10428 fn from(value: Token![@=]) -> Self {
10429 BinaryOperator::AttEql(value)
10430 }
10431}
10432impl From<BinaryAssignment> for AssignmentExpr {
10433 fn from(value: BinaryAssignment) -> Self {
10434 AssignmentExpr::BinaryAssignment(value)
10435 }
10436}
10437impl From<BinaryAssignment> for Component {
10438 fn from(value: BinaryAssignment) -> Self {
10439 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::BinaryAssignment(
10440 value,
10441 )))
10442 }
10443}
10444impl From<BinaryAssignment> for Expr {
10445 fn from(value: BinaryAssignment) -> Self {
10446 Expr::AssignmentExpr(AssignmentExpr::BinaryAssignment(value))
10447 }
10448}
10449impl From<BinaryAssignment> for SequenceElement {
10450 fn from(value: BinaryAssignment) -> Self {
10451 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
10452 AssignmentExpr::BinaryAssignment(value),
10453 )))
10454 }
10455}
10456impl From<BinaryAssignment> for SyntaxNode {
10457 fn from(value: BinaryAssignment) -> Self {
10458 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::BinaryAssignment(
10459 value,
10460 )))
10461 }
10462}
10463impl From<BinaryExpression> for Component {
10464 fn from(value: BinaryExpression) -> Self {
10465 Component::Expr(Expr::OperatorExpr(OperatorExpr::BinaryExpression(value)))
10466 }
10467}
10468impl From<BinaryExpression> for Expr {
10469 fn from(value: BinaryExpression) -> Self {
10470 Expr::OperatorExpr(OperatorExpr::BinaryExpression(value))
10471 }
10472}
10473impl From<BinaryExpression> for OperatorExpr {
10474 fn from(value: BinaryExpression) -> Self {
10475 OperatorExpr::BinaryExpression(value)
10476 }
10477}
10478impl From<BinaryExpression> for SequenceElement {
10479 fn from(value: BinaryExpression) -> Self {
10480 SequenceElement::Component(Component::Expr(Expr::OperatorExpr(
10481 OperatorExpr::BinaryExpression(value),
10482 )))
10483 }
10484}
10485impl From<BinaryExpression> for SyntaxNode {
10486 fn from(value: BinaryExpression) -> Self {
10487 SyntaxNode::Expr(Expr::OperatorExpr(OperatorExpr::BinaryExpression(value)))
10488 }
10489}
10490impl From<BinaryInstallation> for AssignmentExpr {
10491 fn from(value: BinaryInstallation) -> Self {
10492 AssignmentExpr::BinaryInstallation(value)
10493 }
10494}
10495impl From<BinaryInstallation> for Component {
10496 fn from(value: BinaryInstallation) -> Self {
10497 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::BinaryInstallation(
10498 value,
10499 )))
10500 }
10501}
10502impl From<BinaryInstallation> for Expr {
10503 fn from(value: BinaryInstallation) -> Self {
10504 Expr::AssignmentExpr(AssignmentExpr::BinaryInstallation(value))
10505 }
10506}
10507impl From<BinaryInstallation> for SequenceElement {
10508 fn from(value: BinaryInstallation) -> Self {
10509 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
10510 AssignmentExpr::BinaryInstallation(value),
10511 )))
10512 }
10513}
10514impl From<BinaryInstallation> for SyntaxNode {
10515 fn from(value: BinaryInstallation) -> Self {
10516 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::BinaryInstallation(
10517 value,
10518 )))
10519 }
10520}
10521impl From<Token![!]> for PostfixOperator {
10522 fn from(value: Token![!]) -> Self {
10523 PostfixOperator::Bng(value)
10524 }
10525}
10526impl From<Token![!=]> for BinaryOperator {
10527 fn from(value: Token![!=]) -> Self {
10528 BinaryOperator::BngEql(value)
10529 }
10530}
10531impl From<Token!["⊠"]> for BinaryOperator {
10532 fn from(value: Token!["⊠"]) -> Self {
10533 BinaryOperator::Box(value)
10534 }
10535}
10536impl From<Token!["⊠="]> for BinaryOperator {
10537 fn from(value: Token!["⊠="]) -> Self {
10538 BinaryOperator::BoxEql(value)
10539 }
10540}
10541impl From<BreakStatement> for Component {
10542 fn from(value: BreakStatement) -> Self {
10543 Component::Expr(Expr::BreakStatement(value))
10544 }
10545}
10546impl From<BreakStatement> for Expr {
10547 fn from(value: BreakStatement) -> Self {
10548 Expr::BreakStatement(value)
10549 }
10550}
10551impl From<BreakStatement> for SequenceElement {
10552 fn from(value: BreakStatement) -> Self {
10553 SequenceElement::Component(Component::Expr(Expr::BreakStatement(value)))
10554 }
10555}
10556impl From<BreakStatement> for SyntaxNode {
10557 fn from(value: BreakStatement) -> Self {
10558 SyntaxNode::Expr(Expr::BreakStatement(value))
10559 }
10560}
10561impl From<Token![breakpoint]> for DebugKeyword {
10562 fn from(value: Token![breakpoint]) -> Self {
10563 DebugKeyword::Breakpoint(value)
10564 }
10565}
10566impl From<Token!["\\"]> for BinaryOperator {
10567 fn from(value: Token!["\\"]) -> Self {
10568 BinaryOperator::Bsl(value)
10569 }
10570}
10571impl From<Token!["\\\\"]> for BinaryOperator {
10572 fn from(value: Token!["\\\\"]) -> Self {
10573 BinaryOperator::BslBsl(value)
10574 }
10575}
10576impl From<Token!["\\\\="]> for BinaryOperator {
10577 fn from(value: Token!["\\\\="]) -> Self {
10578 BinaryOperator::BslBslEql(value)
10579 }
10580}
10581impl From<Token!["\\="]> for BinaryOperator {
10582 fn from(value: Token!["\\="]) -> Self {
10583 BinaryOperator::BslEql(value)
10584 }
10585}
10586impl From<CatchStatement> for Component {
10587 fn from(value: CatchStatement) -> Self {
10588 Component::Expr(Expr::CatchStatement(value))
10589 }
10590}
10591impl From<CatchStatement> for Expr {
10592 fn from(value: CatchStatement) -> Self {
10593 Expr::CatchStatement(value)
10594 }
10595}
10596impl From<CatchStatement> for SequenceElement {
10597 fn from(value: CatchStatement) -> Self {
10598 SequenceElement::Component(Component::Expr(Expr::CatchStatement(value)))
10599 }
10600}
10601impl From<CatchStatement> for SyntaxNode {
10602 fn from(value: CatchStatement) -> Self {
10603 SyntaxNode::Expr(Expr::CatchStatement(value))
10604 }
10605}
10606impl From<Token!["·"]> for BinaryOperator {
10607 fn from(value: Token!["·"]) -> Self {
10608 BinaryOperator::Cdt(value)
10609 }
10610}
10611impl From<Token!["·="]> for BinaryOperator {
10612 fn from(value: Token!["·="]) -> Self {
10613 BinaryOperator::CdtEql(value)
10614 }
10615}
10616impl From<Token![:]> for BinaryOperator {
10617 fn from(value: Token![:]) -> Self {
10618 BinaryOperator::Col(value)
10619 }
10620}
10621impl From<Token![:=]> for BinaryOperator {
10622 fn from(value: Token![:=]) -> Self {
10623 BinaryOperator::ColEql(value)
10624 }
10625}
10626impl From<Collection> for Component {
10627 fn from(value: Collection) -> Self {
10628 Component::Expr(Expr::Collection(value))
10629 }
10630}
10631impl From<Collection> for Expr {
10632 fn from(value: Collection) -> Self {
10633 Expr::Collection(value)
10634 }
10635}
10636impl From<Collection> for SequenceElement {
10637 fn from(value: Collection) -> Self {
10638 SequenceElement::Component(Component::Expr(Expr::Collection(value)))
10639 }
10640}
10641impl From<Collection> for SyntaxNode {
10642 fn from(value: Collection) -> Self {
10643 SyntaxNode::Expr(Expr::Collection(value))
10644 }
10645}
10646impl From<Component> for SequenceElement {
10647 fn from(value: Component) -> Self {
10648 SequenceElement::Component(value)
10649 }
10650}
10651impl From<ContinueStatement> for Component {
10652 fn from(value: ContinueStatement) -> Self {
10653 Component::Expr(Expr::ContinueStatement(value))
10654 }
10655}
10656impl From<ContinueStatement> for Expr {
10657 fn from(value: ContinueStatement) -> Self {
10658 Expr::ContinueStatement(value)
10659 }
10660}
10661impl From<ContinueStatement> for SequenceElement {
10662 fn from(value: ContinueStatement) -> Self {
10663 SequenceElement::Component(Component::Expr(Expr::ContinueStatement(value)))
10664 }
10665}
10666impl From<ContinueStatement> for SyntaxNode {
10667 fn from(value: ContinueStatement) -> Self {
10668 SyntaxNode::Expr(Expr::ContinueStatement(value))
10669 }
10670}
10671impl From<Token![^]> for BinaryOperator {
10672 fn from(value: Token![^]) -> Self {
10673 BinaryOperator::Crt(value)
10674 }
10675}
10676impl From<Token![^!]> for PostfixOperator {
10677 fn from(value: Token![^!]) -> Self {
10678 PostfixOperator::CrtBng(value)
10679 }
10680}
10681impl From<Token![^^]> for BinaryOperator {
10682 fn from(value: Token![^^]) -> Self {
10683 BinaryOperator::CrtCrt(value)
10684 }
10685}
10686impl From<Token![^^=]> for BinaryOperator {
10687 fn from(value: Token![^^=]) -> Self {
10688 BinaryOperator::CrtCrtEql(value)
10689 }
10690}
10691impl From<Token![^=]> for BinaryOperator {
10692 fn from(value: Token![^=]) -> Self {
10693 BinaryOperator::CrtEql(value)
10694 }
10695}
10696impl From<Token![^>]> for BinaryOperator {
10697 fn from(value: Token![^>]) -> Self {
10698 BinaryOperator::CrtGst(value)
10699 }
10700}
10701impl From<Token![^>=]> for BinaryOperator {
10702 fn from(value: Token![^>=]) -> Self {
10703 BinaryOperator::CrtGstEql(value)
10704 }
10705}
10706impl From<Token![^<]> for BinaryOperator {
10707 fn from(value: Token![^<]) -> Self {
10708 BinaryOperator::CrtLst(value)
10709 }
10710}
10711impl From<Token![^<=]> for BinaryOperator {
10712 fn from(value: Token![^<=]) -> Self {
10713 BinaryOperator::CrtLstEql(value)
10714 }
10715}
10716impl From<Token![^*]> for PostfixOperator {
10717 fn from(value: Token![^*]) -> Self {
10718 PostfixOperator::CrtMul(value)
10719 }
10720}
10721impl From<Token![^**]> for BinaryOperator {
10722 fn from(value: Token![^**]) -> Self {
10723 BinaryOperator::CrtMulMul(value)
10724 }
10725}
10726impl From<Token![^**=]> for BinaryOperator {
10727 fn from(value: Token![^**=]) -> Self {
10728 BinaryOperator::CrtMulMulEql(value)
10729 }
10730}
10731impl From<Token![^~]> for PostfixOperator {
10732 fn from(value: Token![^~]) -> Self {
10733 PostfixOperator::CrtTld(value)
10734 }
10735}
10736impl From<DebugClause> for Component {
10737 fn from(value: DebugClause) -> Self {
10738 Component::Expr(Expr::DebugClause(value))
10739 }
10740}
10741impl From<DebugClause> for Expr {
10742 fn from(value: DebugClause) -> Self {
10743 Expr::DebugClause(value)
10744 }
10745}
10746impl From<DebugClause> for SequenceElement {
10747 fn from(value: DebugClause) -> Self {
10748 SequenceElement::Component(Component::Expr(Expr::DebugClause(value)))
10749 }
10750}
10751impl From<DebugClause> for SyntaxNode {
10752 fn from(value: DebugClause) -> Self {
10753 SyntaxNode::Expr(Expr::DebugClause(value))
10754 }
10755}
10756impl From<Token![.]> for BinaryOperator {
10757 fn from(value: Token![.]) -> Self {
10758 BinaryOperator::Dot(value)
10759 }
10760}
10761impl From<Token![..]> for BinaryOperator {
10762 fn from(value: Token![..]) -> Self {
10763 BinaryOperator::DotDot(value)
10764 }
10765}
10766impl From<Token![..=]> for BinaryOperator {
10767 fn from(value: Token![..=]) -> Self {
10768 BinaryOperator::DotDotEql(value)
10769 }
10770}
10771impl From<Token![..<]> for BinaryOperator {
10772 fn from(value: Token![..<]) -> Self {
10773 BinaryOperator::DotDotLst(value)
10774 }
10775}
10776impl From<Token![..<=]> for BinaryOperator {
10777 fn from(value: Token![..<=]) -> Self {
10778 BinaryOperator::DotDotLstEql(value)
10779 }
10780}
10781impl From<Token![.?]> for BinaryOperator {
10782 fn from(value: Token![.?]) -> Self {
10783 BinaryOperator::DotQsm(value)
10784 }
10785}
10786impl From<Token![elapsedTime]> for DebugKeyword {
10787 fn from(value: Token![elapsedTime]) -> Self {
10788 DebugKeyword::ElapsedTime(value)
10789 }
10790}
10791impl From<Token![elapsedTiming]> for DebugKeyword {
10792 fn from(value: Token![elapsedTiming]) -> Self {
10793 DebugKeyword::ElapsedTiming(value)
10794 }
10795}
10796impl From<ElseClause> for TryFallback {
10797 fn from(value: ElseClause) -> Self {
10798 TryFallback::ElseClause(value)
10799 }
10800}
10801impl From<EmptyComponent> for Component {
10802 fn from(value: EmptyComponent) -> Self {
10803 Component::EmptyComponent(value)
10804 }
10805}
10806impl From<EmptyComponent> for SequenceElement {
10807 fn from(value: EmptyComponent) -> Self {
10808 SequenceElement::Component(Component::EmptyComponent(value))
10809 }
10810}
10811impl From<Token![=!=]> for BinaryOperator {
10812 fn from(value: Token![=!=]) -> Self {
10813 BinaryOperator::EqlBngEql(value)
10814 }
10815}
10816impl From<Token![==]> for BinaryOperator {
10817 fn from(value: Token![==]) -> Self {
10818 BinaryOperator::EqlEql(value)
10819 }
10820}
10821impl From<Token![===]> for BinaryOperator {
10822 fn from(value: Token![===]) -> Self {
10823 BinaryOperator::EqlEqlEql(value)
10824 }
10825}
10826impl From<Token![===>]> for BinaryOperator {
10827 fn from(value: Token![===>]) -> Self {
10828 BinaryOperator::EqlEqlEqlGst(value)
10829 }
10830}
10831impl From<Token![===>=]> for BinaryOperator {
10832 fn from(value: Token![===>=]) -> Self {
10833 BinaryOperator::EqlEqlEqlGstEql(value)
10834 }
10835}
10836impl From<Token![==>]> for BinaryOperator {
10837 fn from(value: Token![==>]) -> Self {
10838 BinaryOperator::EqlEqlGst(value)
10839 }
10840}
10841impl From<Token![==>=]> for BinaryOperator {
10842 fn from(value: Token![==>=]) -> Self {
10843 BinaryOperator::EqlEqlGstEql(value)
10844 }
10845}
10846impl From<EscapeSequence> for RawStringElement {
10847 fn from(value: EscapeSequence) -> Self {
10848 RawStringElement::EscapeSequence(value)
10849 }
10850}
10851impl From<EscapeSequence> for StringElement {
10852 fn from(value: EscapeSequence) -> Self {
10853 StringElement::EscapeSequence(value)
10854 }
10855}
10856impl From<EvaluatedAssignment> for AssignmentExpr {
10857 fn from(value: EvaluatedAssignment) -> Self {
10858 AssignmentExpr::EvaluatedAssignment(value)
10859 }
10860}
10861impl From<EvaluatedAssignment> for Component {
10862 fn from(value: EvaluatedAssignment) -> Self {
10863 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::EvaluatedAssignment(
10864 value,
10865 )))
10866 }
10867}
10868impl From<EvaluatedAssignment> for Expr {
10869 fn from(value: EvaluatedAssignment) -> Self {
10870 Expr::AssignmentExpr(AssignmentExpr::EvaluatedAssignment(value))
10871 }
10872}
10873impl From<EvaluatedAssignment> for SequenceElement {
10874 fn from(value: EvaluatedAssignment) -> Self {
10875 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
10876 AssignmentExpr::EvaluatedAssignment(value),
10877 )))
10878 }
10879}
10880impl From<EvaluatedAssignment> for SyntaxNode {
10881 fn from(value: EvaluatedAssignment) -> Self {
10882 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::EvaluatedAssignment(
10883 value,
10884 )))
10885 }
10886}
10887impl From<ExceptClause> for TryFallback {
10888 fn from(value: ExceptClause) -> Self {
10889 TryFallback::ExceptClause(value)
10890 }
10891}
10892impl From<Expr> for Component {
10893 fn from(value: Expr) -> Self {
10894 Component::Expr(value)
10895 }
10896}
10897impl From<Expr> for SequenceElement {
10898 fn from(value: Expr) -> Self {
10899 SequenceElement::Component(Component::Expr(value))
10900 }
10901}
10902impl From<Expr> for SyntaxNode {
10903 fn from(value: Expr) -> Self {
10904 SyntaxNode::Expr(value)
10905 }
10906}
10907impl From<ExpressionCell> for AnyCell {
10908 fn from(value: ExpressionCell) -> Self {
10909 AnyCell::ExpressionCell(value)
10910 }
10911}
10912impl From<ExpressionCell> for SyntaxNode {
10913 fn from(value: ExpressionCell) -> Self {
10914 SyntaxNode::AnyCell(AnyCell::ExpressionCell(value))
10915 }
10916}
10917impl From<Token![finish]> for DebugKeyword {
10918 fn from(value: Token![finish]) -> Self {
10919 DebugKeyword::Finish(value)
10920 }
10921}
10922impl From<FloatLiteral> for Component {
10923 fn from(value: FloatLiteral) -> Self {
10924 Component::Expr(Expr::FloatLiteral(value))
10925 }
10926}
10927impl From<FloatLiteral> for Expr {
10928 fn from(value: FloatLiteral) -> Self {
10929 Expr::FloatLiteral(value)
10930 }
10931}
10932impl From<FloatLiteral> for SequenceElement {
10933 fn from(value: FloatLiteral) -> Self {
10934 SequenceElement::Component(Component::Expr(Expr::FloatLiteral(value)))
10935 }
10936}
10937impl From<FloatLiteral> for SyntaxNode {
10938 fn from(value: FloatLiteral) -> Self {
10939 SyntaxNode::Expr(Expr::FloatLiteral(value))
10940 }
10941}
10942impl From<ForLoop> for Component {
10943 fn from(value: ForLoop) -> Self {
10944 Component::Expr(Expr::ForLoop(value))
10945 }
10946}
10947impl From<ForLoop> for Expr {
10948 fn from(value: ForLoop) -> Self {
10949 Expr::ForLoop(value)
10950 }
10951}
10952impl From<ForLoop> for SequenceElement {
10953 fn from(value: ForLoop) -> Self {
10954 SequenceElement::Component(Component::Expr(Expr::ForLoop(value)))
10955 }
10956}
10957impl From<ForLoop> for SyntaxNode {
10958 fn from(value: ForLoop) -> Self {
10959 SyntaxNode::Expr(Expr::ForLoop(value))
10960 }
10961}
10962impl From<Token![global]> for QuoteSpecifier {
10963 fn from(value: Token![global]) -> Self {
10964 QuoteSpecifier::Global(value)
10965 }
10966}
10967impl From<Token![(*)]> for PostfixOperator {
10968 fn from(value: Token![(*)]) -> Self {
10969 PostfixOperator::Graded(value)
10970 }
10971}
10972impl From<Token![>]> for BinaryOperator {
10973 fn from(value: Token![>]) -> Self {
10974 BinaryOperator::Gst(value)
10975 }
10976}
10977impl From<Token![>]> for PrefixOperator {
10978 fn from(value: Token![>]) -> Self {
10979 PrefixOperator::Gst(value)
10980 }
10981}
10982impl From<Token![>=]> for BinaryOperator {
10983 fn from(value: Token![>=]) -> Self {
10984 BinaryOperator::GstEql(value)
10985 }
10986}
10987impl From<Token![>=]> for PrefixOperator {
10988 fn from(value: Token![>=]) -> Self {
10989 PrefixOperator::GstEql(value)
10990 }
10991}
10992impl From<Token![>>]> for BinaryOperator {
10993 fn from(value: Token![>>]) -> Self {
10994 BinaryOperator::GstGst(value)
10995 }
10996}
10997impl From<Token![>>=]> for BinaryOperator {
10998 fn from(value: Token![>>=]) -> Self {
10999 BinaryOperator::GstGstEql(value)
11000 }
11001}
11002impl From<Token![#]> for BinaryOperator {
11003 fn from(value: Token![#]) -> Self {
11004 BinaryOperator::Hsh(value)
11005 }
11006}
11007impl From<Token![#]> for PrefixOperator {
11008 fn from(value: Token![#]) -> Self {
11009 PrefixOperator::Hsh(value)
11010 }
11011}
11012impl From<Token![#?]> for BinaryOperator {
11013 fn from(value: Token![#?]) -> Self {
11014 BinaryOperator::HshQsm(value)
11015 }
11016}
11017impl From<IfStatement> for Component {
11018 fn from(value: IfStatement) -> Self {
11019 Component::Expr(Expr::IfStatement(value))
11020 }
11021}
11022impl From<IfStatement> for Expr {
11023 fn from(value: IfStatement) -> Self {
11024 Expr::IfStatement(value)
11025 }
11026}
11027impl From<IfStatement> for SequenceElement {
11028 fn from(value: IfStatement) -> Self {
11029 SequenceElement::Component(Component::Expr(Expr::IfStatement(value)))
11030 }
11031}
11032impl From<IfStatement> for SyntaxNode {
11033 fn from(value: IfStatement) -> Self {
11034 SyntaxNode::Expr(Expr::IfStatement(value))
11035 }
11036}
11037impl From<IntegerLiteral> for Component {
11038 fn from(value: IntegerLiteral) -> Self {
11039 Component::Expr(Expr::IntegerLiteral(value))
11040 }
11041}
11042impl From<IntegerLiteral> for Expr {
11043 fn from(value: IntegerLiteral) -> Self {
11044 Expr::IntegerLiteral(value)
11045 }
11046}
11047impl From<IntegerLiteral> for SequenceElement {
11048 fn from(value: IntegerLiteral) -> Self {
11049 SequenceElement::Component(Component::Expr(Expr::IntegerLiteral(value)))
11050 }
11051}
11052impl From<IntegerLiteral> for SyntaxNode {
11053 fn from(value: IntegerLiteral) -> Self {
11054 SyntaxNode::Expr(Expr::IntegerLiteral(value))
11055 }
11056}
11057impl From<LambdaExpression> for Component {
11058 fn from(value: LambdaExpression) -> Self {
11059 Component::Expr(Expr::LambdaExpression(value))
11060 }
11061}
11062impl From<LambdaExpression> for Expr {
11063 fn from(value: LambdaExpression) -> Self {
11064 Expr::LambdaExpression(value)
11065 }
11066}
11067impl From<LambdaExpression> for SequenceElement {
11068 fn from(value: LambdaExpression) -> Self {
11069 SequenceElement::Component(Component::Expr(Expr::LambdaExpression(value)))
11070 }
11071}
11072impl From<LambdaExpression> for SyntaxNode {
11073 fn from(value: LambdaExpression) -> Self {
11074 SyntaxNode::Expr(Expr::LambdaExpression(value))
11075 }
11076}
11077impl From<List> for BindingPack {
11078 fn from(value: List) -> Self {
11079 BindingPack::List(value)
11080 }
11081}
11082impl From<List> for Collection {
11083 fn from(value: List) -> Self {
11084 Collection::List(value)
11085 }
11086}
11087impl From<List> for Component {
11088 fn from(value: List) -> Self {
11089 Component::Expr(Expr::Collection(Collection::List(value)))
11090 }
11091}
11092impl From<List> for Expr {
11093 fn from(value: List) -> Self {
11094 Expr::Collection(Collection::List(value))
11095 }
11096}
11097impl From<List> for LambdaParameters {
11098 fn from(value: List) -> Self {
11099 LambdaParameters::List(value)
11100 }
11101}
11102impl From<List> for SequenceElement {
11103 fn from(value: List) -> Self {
11104 SequenceElement::Component(Component::Expr(Expr::Collection(Collection::List(value))))
11105 }
11106}
11107impl From<List> for SyntaxNode {
11108 fn from(value: List) -> Self {
11109 SyntaxNode::Expr(Expr::Collection(Collection::List(value)))
11110 }
11111}
11112impl From<LocalAssignment> for AssignmentExpr {
11113 fn from(value: LocalAssignment) -> Self {
11114 AssignmentExpr::LocalAssignment(value)
11115 }
11116}
11117impl From<LocalAssignment> for Component {
11118 fn from(value: LocalAssignment) -> Self {
11119 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::LocalAssignment(value)))
11120 }
11121}
11122impl From<LocalAssignment> for Expr {
11123 fn from(value: LocalAssignment) -> Self {
11124 Expr::AssignmentExpr(AssignmentExpr::LocalAssignment(value))
11125 }
11126}
11127impl From<LocalAssignment> for SequenceElement {
11128 fn from(value: LocalAssignment) -> Self {
11129 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11130 AssignmentExpr::LocalAssignment(value),
11131 )))
11132 }
11133}
11134impl From<LocalAssignment> for SyntaxNode {
11135 fn from(value: LocalAssignment) -> Self {
11136 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::LocalAssignment(value)))
11137 }
11138}
11139impl From<Token![local]> for QuoteSpecifier {
11140 fn from(value: Token![local]) -> Self {
11141 QuoteSpecifier::Local(value)
11142 }
11143}
11144impl From<LocalStructuredBinding> for AssignmentExpr {
11145 fn from(value: LocalStructuredBinding) -> Self {
11146 AssignmentExpr::LocalStructuredBinding(value)
11147 }
11148}
11149impl From<LocalStructuredBinding> for Component {
11150 fn from(value: LocalStructuredBinding) -> Self {
11151 Component::Expr(Expr::AssignmentExpr(
11152 AssignmentExpr::LocalStructuredBinding(value),
11153 ))
11154 }
11155}
11156impl From<LocalStructuredBinding> for Expr {
11157 fn from(value: LocalStructuredBinding) -> Self {
11158 Expr::AssignmentExpr(AssignmentExpr::LocalStructuredBinding(value))
11159 }
11160}
11161impl From<LocalStructuredBinding> for SequenceElement {
11162 fn from(value: LocalStructuredBinding) -> Self {
11163 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11164 AssignmentExpr::LocalStructuredBinding(value),
11165 )))
11166 }
11167}
11168impl From<LocalStructuredBinding> for SyntaxNode {
11169 fn from(value: LocalStructuredBinding) -> Self {
11170 SyntaxNode::Expr(Expr::AssignmentExpr(
11171 AssignmentExpr::LocalStructuredBinding(value),
11172 ))
11173 }
11174}
11175impl From<Token![<]> for BinaryOperator {
11176 fn from(value: Token![<]) -> Self {
11177 BinaryOperator::Lst(value)
11178 }
11179}
11180impl From<Token![<]> for PrefixOperator {
11181 fn from(value: Token![<]) -> Self {
11182 PrefixOperator::Lst(value)
11183 }
11184}
11185impl From<Token![<=]> for BinaryOperator {
11186 fn from(value: Token![<=]) -> Self {
11187 BinaryOperator::LstEql(value)
11188 }
11189}
11190impl From<Token![<=]> for PrefixOperator {
11191 fn from(value: Token![<=]) -> Self {
11192 PrefixOperator::LstEql(value)
11193 }
11194}
11195impl From<Token![<==]> for BinaryOperator {
11196 fn from(value: Token![<==]) -> Self {
11197 BinaryOperator::LstEqlEql(value)
11198 }
11199}
11200impl From<Token![<==]> for PrefixOperator {
11201 fn from(value: Token![<==]) -> Self {
11202 PrefixOperator::LstEqlEql(value)
11203 }
11204}
11205impl From<Token![<===]> for BinaryOperator {
11206 fn from(value: Token![<===]) -> Self {
11207 BinaryOperator::LstEqlEqlEql(value)
11208 }
11209}
11210impl From<Token![<===]> for PrefixOperator {
11211 fn from(value: Token![<===]) -> Self {
11212 PrefixOperator::LstEqlEqlEql(value)
11213 }
11214}
11215impl From<Token![<==>]> for BinaryOperator {
11216 fn from(value: Token![<==>]) -> Self {
11217 BinaryOperator::LstEqlEqlGst(value)
11218 }
11219}
11220impl From<Token![<==>=]> for BinaryOperator {
11221 fn from(value: Token![<==>=]) -> Self {
11222 BinaryOperator::LstEqlEqlGstEql(value)
11223 }
11224}
11225impl From<Token![<<]> for BinaryOperator {
11226 fn from(value: Token![<<]) -> Self {
11227 BinaryOperator::LstLst(value)
11228 }
11229}
11230impl From<Token![<<]> for PrefixOperator {
11231 fn from(value: Token![<<]) -> Self {
11232 PrefixOperator::LstLst(value)
11233 }
11234}
11235impl From<Token![<<=]> for BinaryOperator {
11236 fn from(value: Token![<<=]) -> Self {
11237 BinaryOperator::LstLstEql(value)
11238 }
11239}
11240impl From<Token![%]> for BinaryOperator {
11241 fn from(value: Token![%]) -> Self {
11242 BinaryOperator::Mod(value)
11243 }
11244}
11245impl From<Token![%=]> for BinaryOperator {
11246 fn from(value: Token![%=]) -> Self {
11247 BinaryOperator::ModEql(value)
11248 }
11249}
11250impl From<Token![*]> for BinaryOperator {
11251 fn from(value: Token![*]) -> Self {
11252 BinaryOperator::Mul(value)
11253 }
11254}
11255impl From<Token![*]> for PrefixOperator {
11256 fn from(value: Token![*]) -> Self {
11257 PrefixOperator::Mul(value)
11258 }
11259}
11260impl From<Token![*=]> for BinaryOperator {
11261 fn from(value: Token![*=]) -> Self {
11262 BinaryOperator::MulEql(value)
11263 }
11264}
11265impl From<Token![**]> for BinaryOperator {
11266 fn from(value: Token![**]) -> Self {
11267 BinaryOperator::MulMul(value)
11268 }
11269}
11270impl From<Token![**=]> for BinaryOperator {
11271 fn from(value: Token![**=]) -> Self {
11272 BinaryOperator::MulMulEql(value)
11273 }
11274}
11275impl From<MutedCell> for AnyCell {
11276 fn from(value: MutedCell) -> Self {
11277 AnyCell::MutedCell(value)
11278 }
11279}
11280impl From<MutedCell> for SyntaxNode {
11281 fn from(value: MutedCell) -> Self {
11282 SyntaxNode::AnyCell(AnyCell::MutedCell(value))
11283 }
11284}
11285impl From<MutedGroup> for SequenceElement {
11286 fn from(value: MutedGroup) -> Self {
11287 SequenceElement::MutedGroup(value)
11288 }
11289}
11290impl From<NewStatement> for Component {
11291 fn from(value: NewStatement) -> Self {
11292 Component::Expr(Expr::NewStatement(value))
11293 }
11294}
11295impl From<NewStatement> for Expr {
11296 fn from(value: NewStatement) -> Self {
11297 Expr::NewStatement(value)
11298 }
11299}
11300impl From<NewStatement> for SequenceElement {
11301 fn from(value: NewStatement) -> Self {
11302 SequenceElement::Component(Component::Expr(Expr::NewStatement(value)))
11303 }
11304}
11305impl From<NewStatement> for SyntaxNode {
11306 fn from(value: NewStatement) -> Self {
11307 SyntaxNode::Expr(Expr::NewStatement(value))
11308 }
11309}
11310impl From<Token![not]> for PrefixOperator {
11311 fn from(value: Token![not]) -> Self {
11312 PrefixOperator::Not(value)
11313 }
11314}
11315impl From<OperatorExpr> for Component {
11316 fn from(value: OperatorExpr) -> Self {
11317 Component::Expr(Expr::OperatorExpr(value))
11318 }
11319}
11320impl From<OperatorExpr> for Expr {
11321 fn from(value: OperatorExpr) -> Self {
11322 Expr::OperatorExpr(value)
11323 }
11324}
11325impl From<OperatorExpr> for SequenceElement {
11326 fn from(value: OperatorExpr) -> Self {
11327 SequenceElement::Component(Component::Expr(Expr::OperatorExpr(value)))
11328 }
11329}
11330impl From<OperatorExpr> for SyntaxNode {
11331 fn from(value: OperatorExpr) -> Self {
11332 SyntaxNode::Expr(Expr::OperatorExpr(value))
11333 }
11334}
11335impl From<OptionExpression> for Component {
11336 fn from(value: OptionExpression) -> Self {
11337 Component::Expr(Expr::OptionExpression(value))
11338 }
11339}
11340impl From<OptionExpression> for Expr {
11341 fn from(value: OptionExpression) -> Self {
11342 Expr::OptionExpression(value)
11343 }
11344}
11345impl From<OptionExpression> for SequenceElement {
11346 fn from(value: OptionExpression) -> Self {
11347 SequenceElement::Component(Component::Expr(Expr::OptionExpression(value)))
11348 }
11349}
11350impl From<OptionExpression> for SyntaxNode {
11351 fn from(value: OptionExpression) -> Self {
11352 SyntaxNode::Expr(Expr::OptionExpression(value))
11353 }
11354}
11355impl From<Token![or]> for BinaryOperator {
11356 fn from(value: Token![or]) -> Self {
11357 BinaryOperator::Or(value)
11358 }
11359}
11360impl From<ParenthesizedExpression> for BindingPack {
11361 fn from(value: ParenthesizedExpression) -> Self {
11362 BindingPack::ParenthesizedExpression(value)
11363 }
11364}
11365impl From<ParenthesizedExpression> for Collection {
11366 fn from(value: ParenthesizedExpression) -> Self {
11367 Collection::ParenthesizedExpression(value)
11368 }
11369}
11370impl From<ParenthesizedExpression> for Component {
11371 fn from(value: ParenthesizedExpression) -> Self {
11372 Component::Expr(Expr::Collection(Collection::ParenthesizedExpression(value)))
11373 }
11374}
11375impl From<ParenthesizedExpression> for Expr {
11376 fn from(value: ParenthesizedExpression) -> Self {
11377 Expr::Collection(Collection::ParenthesizedExpression(value))
11378 }
11379}
11380impl From<ParenthesizedExpression> for LambdaParameters {
11381 fn from(value: ParenthesizedExpression) -> Self {
11382 LambdaParameters::ParenthesizedExpression(value)
11383 }
11384}
11385impl From<ParenthesizedExpression> for SequenceElement {
11386 fn from(value: ParenthesizedExpression) -> Self {
11387 SequenceElement::Component(Component::Expr(Expr::Collection(
11388 Collection::ParenthesizedExpression(value),
11389 )))
11390 }
11391}
11392impl From<ParenthesizedExpression> for SyntaxNode {
11393 fn from(value: ParenthesizedExpression) -> Self {
11394 SyntaxNode::Expr(Expr::Collection(Collection::ParenthesizedExpression(value)))
11395 }
11396}
11397impl From<Token![|]> for BinaryOperator {
11398 fn from(value: Token![|]) -> Self {
11399 BinaryOperator::Pip(value)
11400 }
11401}
11402impl From<Token![|=]> for BinaryOperator {
11403 fn from(value: Token![|=]) -> Self {
11404 BinaryOperator::PipEql(value)
11405 }
11406}
11407impl From<Token![||]> for BinaryOperator {
11408 fn from(value: Token![||]) -> Self {
11409 BinaryOperator::PipPip(value)
11410 }
11411}
11412impl From<Token![||=]> for BinaryOperator {
11413 fn from(value: Token![||=]) -> Self {
11414 BinaryOperator::PipPipEql(value)
11415 }
11416}
11417impl From<Token![|-]> for BinaryOperator {
11418 fn from(value: Token![|-]) -> Self {
11419 BinaryOperator::PipSub(value)
11420 }
11421}
11422impl From<Token![|-]> for PrefixOperator {
11423 fn from(value: Token![|-]) -> Self {
11424 PrefixOperator::PipSub(value)
11425 }
11426}
11427impl From<Token![|-=]> for BinaryOperator {
11428 fn from(value: Token![|-=]) -> Self {
11429 BinaryOperator::PipSubEql(value)
11430 }
11431}
11432impl From<Token![|_]> for BinaryOperator {
11433 fn from(value: Token![|_]) -> Self {
11434 BinaryOperator::PipUbs(value)
11435 }
11436}
11437impl From<Token![|_=]> for BinaryOperator {
11438 fn from(value: Token![|_=]) -> Self {
11439 BinaryOperator::PipUbsEql(value)
11440 }
11441}
11442impl From<PostfixAssignment> for AssignmentExpr {
11443 fn from(value: PostfixAssignment) -> Self {
11444 AssignmentExpr::PostfixAssignment(value)
11445 }
11446}
11447impl From<PostfixAssignment> for Component {
11448 fn from(value: PostfixAssignment) -> Self {
11449 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::PostfixAssignment(
11450 value,
11451 )))
11452 }
11453}
11454impl From<PostfixAssignment> for Expr {
11455 fn from(value: PostfixAssignment) -> Self {
11456 Expr::AssignmentExpr(AssignmentExpr::PostfixAssignment(value))
11457 }
11458}
11459impl From<PostfixAssignment> for SequenceElement {
11460 fn from(value: PostfixAssignment) -> Self {
11461 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11462 AssignmentExpr::PostfixAssignment(value),
11463 )))
11464 }
11465}
11466impl From<PostfixAssignment> for SyntaxNode {
11467 fn from(value: PostfixAssignment) -> Self {
11468 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::PostfixAssignment(
11469 value,
11470 )))
11471 }
11472}
11473impl From<PostfixExpression> for Component {
11474 fn from(value: PostfixExpression) -> Self {
11475 Component::Expr(Expr::OperatorExpr(OperatorExpr::PostfixExpression(value)))
11476 }
11477}
11478impl From<PostfixExpression> for Expr {
11479 fn from(value: PostfixExpression) -> Self {
11480 Expr::OperatorExpr(OperatorExpr::PostfixExpression(value))
11481 }
11482}
11483impl From<PostfixExpression> for OperatorExpr {
11484 fn from(value: PostfixExpression) -> Self {
11485 OperatorExpr::PostfixExpression(value)
11486 }
11487}
11488impl From<PostfixExpression> for SequenceElement {
11489 fn from(value: PostfixExpression) -> Self {
11490 SequenceElement::Component(Component::Expr(Expr::OperatorExpr(
11491 OperatorExpr::PostfixExpression(value),
11492 )))
11493 }
11494}
11495impl From<PostfixExpression> for SyntaxNode {
11496 fn from(value: PostfixExpression) -> Self {
11497 SyntaxNode::Expr(Expr::OperatorExpr(OperatorExpr::PostfixExpression(value)))
11498 }
11499}
11500impl From<PostfixInstallation> for AssignmentExpr {
11501 fn from(value: PostfixInstallation) -> Self {
11502 AssignmentExpr::PostfixInstallation(value)
11503 }
11504}
11505impl From<PostfixInstallation> for Component {
11506 fn from(value: PostfixInstallation) -> Self {
11507 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::PostfixInstallation(
11508 value,
11509 )))
11510 }
11511}
11512impl From<PostfixInstallation> for Expr {
11513 fn from(value: PostfixInstallation) -> Self {
11514 Expr::AssignmentExpr(AssignmentExpr::PostfixInstallation(value))
11515 }
11516}
11517impl From<PostfixInstallation> for SequenceElement {
11518 fn from(value: PostfixInstallation) -> Self {
11519 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11520 AssignmentExpr::PostfixInstallation(value),
11521 )))
11522 }
11523}
11524impl From<PostfixInstallation> for SyntaxNode {
11525 fn from(value: PostfixInstallation) -> Self {
11526 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::PostfixInstallation(
11527 value,
11528 )))
11529 }
11530}
11531impl From<PrefixAssignment> for AssignmentExpr {
11532 fn from(value: PrefixAssignment) -> Self {
11533 AssignmentExpr::PrefixAssignment(value)
11534 }
11535}
11536impl From<PrefixAssignment> for Component {
11537 fn from(value: PrefixAssignment) -> Self {
11538 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::PrefixAssignment(
11539 value,
11540 )))
11541 }
11542}
11543impl From<PrefixAssignment> for Expr {
11544 fn from(value: PrefixAssignment) -> Self {
11545 Expr::AssignmentExpr(AssignmentExpr::PrefixAssignment(value))
11546 }
11547}
11548impl From<PrefixAssignment> for SequenceElement {
11549 fn from(value: PrefixAssignment) -> Self {
11550 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11551 AssignmentExpr::PrefixAssignment(value),
11552 )))
11553 }
11554}
11555impl From<PrefixAssignment> for SyntaxNode {
11556 fn from(value: PrefixAssignment) -> Self {
11557 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::PrefixAssignment(
11558 value,
11559 )))
11560 }
11561}
11562impl From<PrefixExpression> for Component {
11563 fn from(value: PrefixExpression) -> Self {
11564 Component::Expr(Expr::OperatorExpr(OperatorExpr::PrefixExpression(value)))
11565 }
11566}
11567impl From<PrefixExpression> for Expr {
11568 fn from(value: PrefixExpression) -> Self {
11569 Expr::OperatorExpr(OperatorExpr::PrefixExpression(value))
11570 }
11571}
11572impl From<PrefixExpression> for OperatorExpr {
11573 fn from(value: PrefixExpression) -> Self {
11574 OperatorExpr::PrefixExpression(value)
11575 }
11576}
11577impl From<PrefixExpression> for SequenceElement {
11578 fn from(value: PrefixExpression) -> Self {
11579 SequenceElement::Component(Component::Expr(Expr::OperatorExpr(
11580 OperatorExpr::PrefixExpression(value),
11581 )))
11582 }
11583}
11584impl From<PrefixExpression> for SyntaxNode {
11585 fn from(value: PrefixExpression) -> Self {
11586 SyntaxNode::Expr(Expr::OperatorExpr(OperatorExpr::PrefixExpression(value)))
11587 }
11588}
11589impl From<PrefixInstallation> for AssignmentExpr {
11590 fn from(value: PrefixInstallation) -> Self {
11591 AssignmentExpr::PrefixInstallation(value)
11592 }
11593}
11594impl From<PrefixInstallation> for Component {
11595 fn from(value: PrefixInstallation) -> Self {
11596 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::PrefixInstallation(
11597 value,
11598 )))
11599 }
11600}
11601impl From<PrefixInstallation> for Expr {
11602 fn from(value: PrefixInstallation) -> Self {
11603 Expr::AssignmentExpr(AssignmentExpr::PrefixInstallation(value))
11604 }
11605}
11606impl From<PrefixInstallation> for SequenceElement {
11607 fn from(value: PrefixInstallation) -> Self {
11608 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11609 AssignmentExpr::PrefixInstallation(value),
11610 )))
11611 }
11612}
11613impl From<PrefixInstallation> for SyntaxNode {
11614 fn from(value: PrefixInstallation) -> Self {
11615 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::PrefixInstallation(
11616 value,
11617 )))
11618 }
11619}
11620impl From<Token![profile]> for DebugKeyword {
11621 fn from(value: Token![profile]) -> Self {
11622 DebugKeyword::Profile(value)
11623 }
11624}
11625impl From<Token![?]> for BinaryOperator {
11626 fn from(value: Token![?]) -> Self {
11627 BinaryOperator::Qsm(value)
11628 }
11629}
11630impl From<Token![?]> for PrefixOperator {
11631 fn from(value: Token![?]) -> Self {
11632 PrefixOperator::Qsm(value)
11633 }
11634}
11635impl From<Token![??]> for BinaryOperator {
11636 fn from(value: Token![??]) -> Self {
11637 BinaryOperator::QsmQsm(value)
11638 }
11639}
11640impl From<Token![??]> for PrefixOperator {
11641 fn from(value: Token![??]) -> Self {
11642 PrefixOperator::QsmQsm(value)
11643 }
11644}
11645impl From<Token![??=]> for BinaryOperator {
11646 fn from(value: Token![??=]) -> Self {
11647 BinaryOperator::QsmQsmEql(value)
11648 }
11649}
11650impl From<QuoteExpression> for Component {
11651 fn from(value: QuoteExpression) -> Self {
11652 Component::Expr(Expr::QuoteExpression(value))
11653 }
11654}
11655impl From<QuoteExpression> for Expr {
11656 fn from(value: QuoteExpression) -> Self {
11657 Expr::QuoteExpression(value)
11658 }
11659}
11660impl From<QuoteExpression> for SequenceElement {
11661 fn from(value: QuoteExpression) -> Self {
11662 SequenceElement::Component(Component::Expr(Expr::QuoteExpression(value)))
11663 }
11664}
11665impl From<QuoteExpression> for SyntaxNode {
11666 fn from(value: QuoteExpression) -> Self {
11667 SyntaxNode::Expr(Expr::QuoteExpression(value))
11668 }
11669}
11670impl From<RawStringContent> for RawStringElement {
11671 fn from(value: RawStringContent) -> Self {
11672 RawStringElement::RawStringContent(value)
11673 }
11674}
11675impl From<RawStringLiteral> for Component {
11676 fn from(value: RawStringLiteral) -> Self {
11677 Component::Expr(Expr::RawStringLiteral(value))
11678 }
11679}
11680impl From<RawStringLiteral> for Expr {
11681 fn from(value: RawStringLiteral) -> Self {
11682 Expr::RawStringLiteral(value)
11683 }
11684}
11685impl From<RawStringLiteral> for SequenceElement {
11686 fn from(value: RawStringLiteral) -> Self {
11687 SequenceElement::Component(Component::Expr(Expr::RawStringLiteral(value)))
11688 }
11689}
11690impl From<RawStringLiteral> for SyntaxNode {
11691 fn from(value: RawStringLiteral) -> Self {
11692 SyntaxNode::Expr(Expr::RawStringLiteral(value))
11693 }
11694}
11695impl From<ReturnStatement> for Component {
11696 fn from(value: ReturnStatement) -> Self {
11697 Component::Expr(Expr::ReturnStatement(value))
11698 }
11699}
11700impl From<ReturnStatement> for Expr {
11701 fn from(value: ReturnStatement) -> Self {
11702 Expr::ReturnStatement(value)
11703 }
11704}
11705impl From<ReturnStatement> for SequenceElement {
11706 fn from(value: ReturnStatement) -> Self {
11707 SequenceElement::Component(Component::Expr(Expr::ReturnStatement(value)))
11708 }
11709}
11710impl From<ReturnStatement> for SyntaxNode {
11711 fn from(value: ReturnStatement) -> Self {
11712 SyntaxNode::Expr(Expr::ReturnStatement(value))
11713 }
11714}
11715impl From<Sequence> for BindingPack {
11716 fn from(value: Sequence) -> Self {
11717 BindingPack::Sequence(value)
11718 }
11719}
11720impl From<Sequence> for Collection {
11721 fn from(value: Sequence) -> Self {
11722 Collection::Sequence(value)
11723 }
11724}
11725impl From<Sequence> for Component {
11726 fn from(value: Sequence) -> Self {
11727 Component::Expr(Expr::Collection(Collection::Sequence(value)))
11728 }
11729}
11730impl From<Sequence> for Expr {
11731 fn from(value: Sequence) -> Self {
11732 Expr::Collection(Collection::Sequence(value))
11733 }
11734}
11735impl From<Sequence> for LambdaParameters {
11736 fn from(value: Sequence) -> Self {
11737 LambdaParameters::Sequence(value)
11738 }
11739}
11740impl From<Sequence> for SequenceElement {
11741 fn from(value: Sequence) -> Self {
11742 SequenceElement::Component(Component::Expr(Expr::Collection(Collection::Sequence(
11743 value,
11744 ))))
11745 }
11746}
11747impl From<Sequence> for SyntaxNode {
11748 fn from(value: Sequence) -> Self {
11749 SyntaxNode::Expr(Expr::Collection(Collection::Sequence(value)))
11750 }
11751}
11752impl From<SequenceCell> for AnyCell {
11753 fn from(value: SequenceCell) -> Self {
11754 AnyCell::SequenceCell(value)
11755 }
11756}
11757impl From<SequenceCell> for SyntaxNode {
11758 fn from(value: SequenceCell) -> Self {
11759 SyntaxNode::AnyCell(AnyCell::SequenceCell(value))
11760 }
11761}
11762impl From<Token!["⧢"]> for BinaryOperator {
11763 fn from(value: Token!["⧢"]) -> Self {
11764 BinaryOperator::Sfp(value)
11765 }
11766}
11767impl From<Token!["⧢="]> for BinaryOperator {
11768 fn from(value: Token!["⧢="]) -> Self {
11769 BinaryOperator::SfpEql(value)
11770 }
11771}
11772impl From<Token![shield]> for DebugKeyword {
11773 fn from(value: Token![shield]) -> Self {
11774 DebugKeyword::Shield(value)
11775 }
11776}
11777impl From<Token![/]> for BinaryOperator {
11778 fn from(value: Token![/]) -> Self {
11779 BinaryOperator::Slh(value)
11780 }
11781}
11782impl From<Token![/=]> for BinaryOperator {
11783 fn from(value: Token![/=]) -> Self {
11784 BinaryOperator::SlhEql(value)
11785 }
11786}
11787impl From<Token![/ /]> for BinaryOperator {
11788 fn from(value: Token![/ /]) -> Self {
11789 BinaryOperator::SlhSlh(value)
11790 }
11791}
11792impl From<Token![/ /=]> for BinaryOperator {
11793 fn from(value: Token![/ /=]) -> Self {
11794 BinaryOperator::SlhSlhEql(value)
11795 }
11796}
11797impl From<SourceFile> for SyntaxNode {
11798 fn from(value: SourceFile) -> Self {
11799 SyntaxNode::SourceFile(value)
11800 }
11801}
11802impl From<Token![SPACE]> for BinaryOperator {
11803 fn from(value: Token![SPACE]) -> Self {
11804 BinaryOperator::Space(value)
11805 }
11806}
11807impl From<Token![step]> for DebugKeyword {
11808 fn from(value: Token![step]) -> Self {
11809 DebugKeyword::Step(value)
11810 }
11811}
11812impl From<StringContent> for StringElement {
11813 fn from(value: StringContent) -> Self {
11814 StringElement::StringContent(value)
11815 }
11816}
11817impl From<StringLiteral> for Component {
11818 fn from(value: StringLiteral) -> Self {
11819 Component::Expr(Expr::StringLiteral(value))
11820 }
11821}
11822impl From<StringLiteral> for Expr {
11823 fn from(value: StringLiteral) -> Self {
11824 Expr::StringLiteral(value)
11825 }
11826}
11827impl From<StringLiteral> for SequenceElement {
11828 fn from(value: StringLiteral) -> Self {
11829 SequenceElement::Component(Component::Expr(Expr::StringLiteral(value)))
11830 }
11831}
11832impl From<StringLiteral> for SyntaxNode {
11833 fn from(value: StringLiteral) -> Self {
11834 SyntaxNode::Expr(Expr::StringLiteral(value))
11835 }
11836}
11837impl From<StructuredBinding> for AssignmentExpr {
11838 fn from(value: StructuredBinding) -> Self {
11839 AssignmentExpr::StructuredBinding(value)
11840 }
11841}
11842impl From<StructuredBinding> for Component {
11843 fn from(value: StructuredBinding) -> Self {
11844 Component::Expr(Expr::AssignmentExpr(AssignmentExpr::StructuredBinding(
11845 value,
11846 )))
11847 }
11848}
11849impl From<StructuredBinding> for Expr {
11850 fn from(value: StructuredBinding) -> Self {
11851 Expr::AssignmentExpr(AssignmentExpr::StructuredBinding(value))
11852 }
11853}
11854impl From<StructuredBinding> for SequenceElement {
11855 fn from(value: StructuredBinding) -> Self {
11856 SequenceElement::Component(Component::Expr(Expr::AssignmentExpr(
11857 AssignmentExpr::StructuredBinding(value),
11858 )))
11859 }
11860}
11861impl From<StructuredBinding> for SyntaxNode {
11862 fn from(value: StructuredBinding) -> Self {
11863 SyntaxNode::Expr(Expr::AssignmentExpr(AssignmentExpr::StructuredBinding(
11864 value,
11865 )))
11866 }
11867}
11868impl From<Token![-]> for BinaryOperator {
11869 fn from(value: Token![-]) -> Self {
11870 BinaryOperator::Sub(value)
11871 }
11872}
11873impl From<Token![-]> for PrefixOperator {
11874 fn from(value: Token![-]) -> Self {
11875 PrefixOperator::Sub(value)
11876 }
11877}
11878impl From<Token![-=]> for BinaryOperator {
11879 fn from(value: Token![-=]) -> Self {
11880 BinaryOperator::SubEql(value)
11881 }
11882}
11883impl From<Symbol> for Component {
11884 fn from(value: Symbol) -> Self {
11885 Component::Expr(Expr::Symbol(value))
11886 }
11887}
11888impl From<Symbol> for Expr {
11889 fn from(value: Symbol) -> Self {
11890 Expr::Symbol(value)
11891 }
11892}
11893impl From<Symbol> for LambdaParameters {
11894 fn from(value: Symbol) -> Self {
11895 LambdaParameters::Symbol(value)
11896 }
11897}
11898impl From<Symbol> for SequenceElement {
11899 fn from(value: Symbol) -> Self {
11900 SequenceElement::Component(Component::Expr(Expr::Symbol(value)))
11901 }
11902}
11903impl From<Symbol> for SyntaxNode {
11904 fn from(value: Symbol) -> Self {
11905 SyntaxNode::Expr(Expr::Symbol(value))
11906 }
11907}
11908impl From<Token![symbol]> for QuoteSpecifier {
11909 fn from(value: Token![symbol]) -> Self {
11910 QuoteSpecifier::Symbol(value)
11911 }
11912}
11913impl From<Token![TEST]> for DebugKeyword {
11914 fn from(value: Token![TEST]) -> Self {
11915 DebugKeyword::Test(value)
11916 }
11917}
11918impl From<Token![threadLocal]> for QuoteSpecifier {
11919 fn from(value: Token![threadLocal]) -> Self {
11920 QuoteSpecifier::ThreadLocal(value)
11921 }
11922}
11923impl From<Token![threadVariable]> for QuoteSpecifier {
11924 fn from(value: Token![threadVariable]) -> Self {
11925 QuoteSpecifier::ThreadVariable(value)
11926 }
11927}
11928impl From<ThrowStatement> for Component {
11929 fn from(value: ThrowStatement) -> Self {
11930 Component::Expr(Expr::ThrowStatement(value))
11931 }
11932}
11933impl From<ThrowStatement> for Expr {
11934 fn from(value: ThrowStatement) -> Self {
11935 Expr::ThrowStatement(value)
11936 }
11937}
11938impl From<ThrowStatement> for SequenceElement {
11939 fn from(value: ThrowStatement) -> Self {
11940 SequenceElement::Component(Component::Expr(Expr::ThrowStatement(value)))
11941 }
11942}
11943impl From<ThrowStatement> for SyntaxNode {
11944 fn from(value: ThrowStatement) -> Self {
11945 SyntaxNode::Expr(Expr::ThrowStatement(value))
11946 }
11947}
11948impl From<Token![time]> for DebugKeyword {
11949 fn from(value: Token![time]) -> Self {
11950 DebugKeyword::Time(value)
11951 }
11952}
11953impl From<Token![timing]> for DebugKeyword {
11954 fn from(value: Token![timing]) -> Self {
11955 DebugKeyword::Timing(value)
11956 }
11957}
11958impl From<Token![~]> for BinaryOperator {
11959 fn from(value: Token![~]) -> Self {
11960 BinaryOperator::Tld(value)
11961 }
11962}
11963impl From<Token![~]> for PrefixOperator {
11964 fn from(value: Token![~]) -> Self {
11965 PrefixOperator::Tld(value)
11966 }
11967}
11968impl From<Token![~=]> for BinaryOperator {
11969 fn from(value: Token![~=]) -> Self {
11970 BinaryOperator::TldEql(value)
11971 }
11972}
11973impl From<TrapStatement> for Component {
11974 fn from(value: TrapStatement) -> Self {
11975 Component::Expr(Expr::TrapStatement(value))
11976 }
11977}
11978impl From<TrapStatement> for Expr {
11979 fn from(value: TrapStatement) -> Self {
11980 Expr::TrapStatement(value)
11981 }
11982}
11983impl From<TrapStatement> for SequenceElement {
11984 fn from(value: TrapStatement) -> Self {
11985 SequenceElement::Component(Component::Expr(Expr::TrapStatement(value)))
11986 }
11987}
11988impl From<TrapStatement> for SyntaxNode {
11989 fn from(value: TrapStatement) -> Self {
11990 SyntaxNode::Expr(Expr::TrapStatement(value))
11991 }
11992}
11993impl From<TryStatement> for Component {
11994 fn from(value: TryStatement) -> Self {
11995 Component::Expr(Expr::TryStatement(value))
11996 }
11997}
11998impl From<TryStatement> for Expr {
11999 fn from(value: TryStatement) -> Self {
12000 Expr::TryStatement(value)
12001 }
12002}
12003impl From<TryStatement> for SequenceElement {
12004 fn from(value: TryStatement) -> Self {
12005 SequenceElement::Component(Component::Expr(Expr::TryStatement(value)))
12006 }
12007}
12008impl From<TryStatement> for SyntaxNode {
12009 fn from(value: TryStatement) -> Self {
12010 SyntaxNode::Expr(Expr::TryStatement(value))
12011 }
12012}
12013impl From<Token![_]> for BinaryOperator {
12014 fn from(value: Token![_]) -> Self {
12015 BinaryOperator::Ubs(value)
12016 }
12017}
12018impl From<Token![_!]> for PostfixOperator {
12019 fn from(value: Token![_!]) -> Self {
12020 PostfixOperator::UbsBng(value)
12021 }
12022}
12023impl From<Token![_=]> for BinaryOperator {
12024 fn from(value: Token![_=]) -> Self {
12025 BinaryOperator::UbsEql(value)
12026 }
12027}
12028impl From<Token![_>]> for BinaryOperator {
12029 fn from(value: Token![_>]) -> Self {
12030 BinaryOperator::UbsGst(value)
12031 }
12032}
12033impl From<Token![_>=]> for BinaryOperator {
12034 fn from(value: Token![_>=]) -> Self {
12035 BinaryOperator::UbsGstEql(value)
12036 }
12037}
12038impl From<Token![_<]> for BinaryOperator {
12039 fn from(value: Token![_<]) -> Self {
12040 BinaryOperator::UbsLst(value)
12041 }
12042}
12043impl From<Token![_<=]> for BinaryOperator {
12044 fn from(value: Token![_<=]) -> Self {
12045 BinaryOperator::UbsLstEql(value)
12046 }
12047}
12048impl From<Token![_*]> for PostfixOperator {
12049 fn from(value: Token![_*]) -> Self {
12050 PostfixOperator::UbsMul(value)
12051 }
12052}
12053impl From<Token![_~]> for PostfixOperator {
12054 fn from(value: Token![_~]) -> Self {
12055 PostfixOperator::UbsTld(value)
12056 }
12057}
12058impl From<WhileLoop> for Component {
12059 fn from(value: WhileLoop) -> Self {
12060 Component::Expr(Expr::WhileLoop(value))
12061 }
12062}
12063impl From<WhileLoop> for Expr {
12064 fn from(value: WhileLoop) -> Self {
12065 Expr::WhileLoop(value)
12066 }
12067}
12068impl From<WhileLoop> for SequenceElement {
12069 fn from(value: WhileLoop) -> Self {
12070 SequenceElement::Component(Component::Expr(Expr::WhileLoop(value)))
12071 }
12072}
12073impl From<WhileLoop> for SyntaxNode {
12074 fn from(value: WhileLoop) -> Self {
12075 SyntaxNode::Expr(Expr::WhileLoop(value))
12076 }
12077}
12078impl From<Token![xor]> for BinaryOperator {
12079 fn from(value: Token![xor]) -> Self {
12080 BinaryOperator::Xor(value)
12081 }
12082}