aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast/generated/tokens.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src/ast/generated/tokens.rs')
-rw-r--r--crates/ra_syntax/src/ast/generated/tokens.rs3059
1 files changed, 3058 insertions, 1 deletions
diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
index 4494af1be..27b2d2977 100644
--- a/crates/ra_syntax/src/ast/generated/tokens.rs
+++ b/crates/ra_syntax/src/ast/generated/tokens.rs
@@ -1 +1,3058 @@
1//! Generated file, do not edit by hand, see `xtask/src/codegen` \ No newline at end of file 1//! Generated file, do not edit by hand, see `xtask/src/codegen`
2
3use crate::{
4 ast::AstToken,
5 SyntaxKind::{self, *},
6 SyntaxToken,
7};
8#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9pub struct Semi {
10 pub(crate) syntax: SyntaxToken,
11}
12impl std::fmt::Display for Semi {
13 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14 std::fmt::Display::fmt(&self.syntax, f)
15 }
16}
17impl AstToken for Semi {
18 fn can_cast(kind: SyntaxKind) -> bool {
19 match kind {
20 SEMI => true,
21 _ => false,
22 }
23 }
24 fn cast(syntax: SyntaxToken) -> Option<Self> {
25 if Self::can_cast(syntax.kind()) {
26 Some(Self { syntax })
27 } else {
28 None
29 }
30 }
31 fn syntax(&self) -> &SyntaxToken {
32 &self.syntax
33 }
34}
35#[derive(Debug, Clone, PartialEq, Eq, Hash)]
36pub struct Comma {
37 pub(crate) syntax: SyntaxToken,
38}
39impl std::fmt::Display for Comma {
40 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
41 std::fmt::Display::fmt(&self.syntax, f)
42 }
43}
44impl AstToken for Comma {
45 fn can_cast(kind: SyntaxKind) -> bool {
46 match kind {
47 COMMA => true,
48 _ => false,
49 }
50 }
51 fn cast(syntax: SyntaxToken) -> Option<Self> {
52 if Self::can_cast(syntax.kind()) {
53 Some(Self { syntax })
54 } else {
55 None
56 }
57 }
58 fn syntax(&self) -> &SyntaxToken {
59 &self.syntax
60 }
61}
62#[derive(Debug, Clone, PartialEq, Eq, Hash)]
63pub struct LParen {
64 pub(crate) syntax: SyntaxToken,
65}
66impl std::fmt::Display for LParen {
67 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
68 std::fmt::Display::fmt(&self.syntax, f)
69 }
70}
71impl AstToken for LParen {
72 fn can_cast(kind: SyntaxKind) -> bool {
73 match kind {
74 L_PAREN => true,
75 _ => false,
76 }
77 }
78 fn cast(syntax: SyntaxToken) -> Option<Self> {
79 if Self::can_cast(syntax.kind()) {
80 Some(Self { syntax })
81 } else {
82 None
83 }
84 }
85 fn syntax(&self) -> &SyntaxToken {
86 &self.syntax
87 }
88}
89#[derive(Debug, Clone, PartialEq, Eq, Hash)]
90pub struct RParen {
91 pub(crate) syntax: SyntaxToken,
92}
93impl std::fmt::Display for RParen {
94 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
95 std::fmt::Display::fmt(&self.syntax, f)
96 }
97}
98impl AstToken for RParen {
99 fn can_cast(kind: SyntaxKind) -> bool {
100 match kind {
101 R_PAREN => true,
102 _ => false,
103 }
104 }
105 fn cast(syntax: SyntaxToken) -> Option<Self> {
106 if Self::can_cast(syntax.kind()) {
107 Some(Self { syntax })
108 } else {
109 None
110 }
111 }
112 fn syntax(&self) -> &SyntaxToken {
113 &self.syntax
114 }
115}
116#[derive(Debug, Clone, PartialEq, Eq, Hash)]
117pub struct LCurly {
118 pub(crate) syntax: SyntaxToken,
119}
120impl std::fmt::Display for LCurly {
121 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
122 std::fmt::Display::fmt(&self.syntax, f)
123 }
124}
125impl AstToken for LCurly {
126 fn can_cast(kind: SyntaxKind) -> bool {
127 match kind {
128 L_CURLY => true,
129 _ => false,
130 }
131 }
132 fn cast(syntax: SyntaxToken) -> Option<Self> {
133 if Self::can_cast(syntax.kind()) {
134 Some(Self { syntax })
135 } else {
136 None
137 }
138 }
139 fn syntax(&self) -> &SyntaxToken {
140 &self.syntax
141 }
142}
143#[derive(Debug, Clone, PartialEq, Eq, Hash)]
144pub struct RCurly {
145 pub(crate) syntax: SyntaxToken,
146}
147impl std::fmt::Display for RCurly {
148 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
149 std::fmt::Display::fmt(&self.syntax, f)
150 }
151}
152impl AstToken for RCurly {
153 fn can_cast(kind: SyntaxKind) -> bool {
154 match kind {
155 R_CURLY => true,
156 _ => false,
157 }
158 }
159 fn cast(syntax: SyntaxToken) -> Option<Self> {
160 if Self::can_cast(syntax.kind()) {
161 Some(Self { syntax })
162 } else {
163 None
164 }
165 }
166 fn syntax(&self) -> &SyntaxToken {
167 &self.syntax
168 }
169}
170#[derive(Debug, Clone, PartialEq, Eq, Hash)]
171pub struct LBrack {
172 pub(crate) syntax: SyntaxToken,
173}
174impl std::fmt::Display for LBrack {
175 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
176 std::fmt::Display::fmt(&self.syntax, f)
177 }
178}
179impl AstToken for LBrack {
180 fn can_cast(kind: SyntaxKind) -> bool {
181 match kind {
182 L_BRACK => true,
183 _ => false,
184 }
185 }
186 fn cast(syntax: SyntaxToken) -> Option<Self> {
187 if Self::can_cast(syntax.kind()) {
188 Some(Self { syntax })
189 } else {
190 None
191 }
192 }
193 fn syntax(&self) -> &SyntaxToken {
194 &self.syntax
195 }
196}
197#[derive(Debug, Clone, PartialEq, Eq, Hash)]
198pub struct RBrack {
199 pub(crate) syntax: SyntaxToken,
200}
201impl std::fmt::Display for RBrack {
202 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
203 std::fmt::Display::fmt(&self.syntax, f)
204 }
205}
206impl AstToken for RBrack {
207 fn can_cast(kind: SyntaxKind) -> bool {
208 match kind {
209 R_BRACK => true,
210 _ => false,
211 }
212 }
213 fn cast(syntax: SyntaxToken) -> Option<Self> {
214 if Self::can_cast(syntax.kind()) {
215 Some(Self { syntax })
216 } else {
217 None
218 }
219 }
220 fn syntax(&self) -> &SyntaxToken {
221 &self.syntax
222 }
223}
224#[derive(Debug, Clone, PartialEq, Eq, Hash)]
225pub struct LAngle {
226 pub(crate) syntax: SyntaxToken,
227}
228impl std::fmt::Display for LAngle {
229 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
230 std::fmt::Display::fmt(&self.syntax, f)
231 }
232}
233impl AstToken for LAngle {
234 fn can_cast(kind: SyntaxKind) -> bool {
235 match kind {
236 L_ANGLE => true,
237 _ => false,
238 }
239 }
240 fn cast(syntax: SyntaxToken) -> Option<Self> {
241 if Self::can_cast(syntax.kind()) {
242 Some(Self { syntax })
243 } else {
244 None
245 }
246 }
247 fn syntax(&self) -> &SyntaxToken {
248 &self.syntax
249 }
250}
251#[derive(Debug, Clone, PartialEq, Eq, Hash)]
252pub struct RAngle {
253 pub(crate) syntax: SyntaxToken,
254}
255impl std::fmt::Display for RAngle {
256 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
257 std::fmt::Display::fmt(&self.syntax, f)
258 }
259}
260impl AstToken for RAngle {
261 fn can_cast(kind: SyntaxKind) -> bool {
262 match kind {
263 R_ANGLE => true,
264 _ => false,
265 }
266 }
267 fn cast(syntax: SyntaxToken) -> Option<Self> {
268 if Self::can_cast(syntax.kind()) {
269 Some(Self { syntax })
270 } else {
271 None
272 }
273 }
274 fn syntax(&self) -> &SyntaxToken {
275 &self.syntax
276 }
277}
278#[derive(Debug, Clone, PartialEq, Eq, Hash)]
279pub struct At {
280 pub(crate) syntax: SyntaxToken,
281}
282impl std::fmt::Display for At {
283 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
284 std::fmt::Display::fmt(&self.syntax, f)
285 }
286}
287impl AstToken for At {
288 fn can_cast(kind: SyntaxKind) -> bool {
289 match kind {
290 AT => true,
291 _ => false,
292 }
293 }
294 fn cast(syntax: SyntaxToken) -> Option<Self> {
295 if Self::can_cast(syntax.kind()) {
296 Some(Self { syntax })
297 } else {
298 None
299 }
300 }
301 fn syntax(&self) -> &SyntaxToken {
302 &self.syntax
303 }
304}
305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
306pub struct Pound {
307 pub(crate) syntax: SyntaxToken,
308}
309impl std::fmt::Display for Pound {
310 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
311 std::fmt::Display::fmt(&self.syntax, f)
312 }
313}
314impl AstToken for Pound {
315 fn can_cast(kind: SyntaxKind) -> bool {
316 match kind {
317 POUND => true,
318 _ => false,
319 }
320 }
321 fn cast(syntax: SyntaxToken) -> Option<Self> {
322 if Self::can_cast(syntax.kind()) {
323 Some(Self { syntax })
324 } else {
325 None
326 }
327 }
328 fn syntax(&self) -> &SyntaxToken {
329 &self.syntax
330 }
331}
332#[derive(Debug, Clone, PartialEq, Eq, Hash)]
333pub struct Tilde {
334 pub(crate) syntax: SyntaxToken,
335}
336impl std::fmt::Display for Tilde {
337 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
338 std::fmt::Display::fmt(&self.syntax, f)
339 }
340}
341impl AstToken for Tilde {
342 fn can_cast(kind: SyntaxKind) -> bool {
343 match kind {
344 TILDE => true,
345 _ => false,
346 }
347 }
348 fn cast(syntax: SyntaxToken) -> Option<Self> {
349 if Self::can_cast(syntax.kind()) {
350 Some(Self { syntax })
351 } else {
352 None
353 }
354 }
355 fn syntax(&self) -> &SyntaxToken {
356 &self.syntax
357 }
358}
359#[derive(Debug, Clone, PartialEq, Eq, Hash)]
360pub struct Question {
361 pub(crate) syntax: SyntaxToken,
362}
363impl std::fmt::Display for Question {
364 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
365 std::fmt::Display::fmt(&self.syntax, f)
366 }
367}
368impl AstToken for Question {
369 fn can_cast(kind: SyntaxKind) -> bool {
370 match kind {
371 QUESTION => true,
372 _ => false,
373 }
374 }
375 fn cast(syntax: SyntaxToken) -> Option<Self> {
376 if Self::can_cast(syntax.kind()) {
377 Some(Self { syntax })
378 } else {
379 None
380 }
381 }
382 fn syntax(&self) -> &SyntaxToken {
383 &self.syntax
384 }
385}
386#[derive(Debug, Clone, PartialEq, Eq, Hash)]
387pub struct Dollar {
388 pub(crate) syntax: SyntaxToken,
389}
390impl std::fmt::Display for Dollar {
391 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
392 std::fmt::Display::fmt(&self.syntax, f)
393 }
394}
395impl AstToken for Dollar {
396 fn can_cast(kind: SyntaxKind) -> bool {
397 match kind {
398 DOLLAR => true,
399 _ => false,
400 }
401 }
402 fn cast(syntax: SyntaxToken) -> Option<Self> {
403 if Self::can_cast(syntax.kind()) {
404 Some(Self { syntax })
405 } else {
406 None
407 }
408 }
409 fn syntax(&self) -> &SyntaxToken {
410 &self.syntax
411 }
412}
413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
414pub struct Amp {
415 pub(crate) syntax: SyntaxToken,
416}
417impl std::fmt::Display for Amp {
418 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
419 std::fmt::Display::fmt(&self.syntax, f)
420 }
421}
422impl AstToken for Amp {
423 fn can_cast(kind: SyntaxKind) -> bool {
424 match kind {
425 AMP => true,
426 _ => false,
427 }
428 }
429 fn cast(syntax: SyntaxToken) -> Option<Self> {
430 if Self::can_cast(syntax.kind()) {
431 Some(Self { syntax })
432 } else {
433 None
434 }
435 }
436 fn syntax(&self) -> &SyntaxToken {
437 &self.syntax
438 }
439}
440#[derive(Debug, Clone, PartialEq, Eq, Hash)]
441pub struct Pipe {
442 pub(crate) syntax: SyntaxToken,
443}
444impl std::fmt::Display for Pipe {
445 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
446 std::fmt::Display::fmt(&self.syntax, f)
447 }
448}
449impl AstToken for Pipe {
450 fn can_cast(kind: SyntaxKind) -> bool {
451 match kind {
452 PIPE => true,
453 _ => false,
454 }
455 }
456 fn cast(syntax: SyntaxToken) -> Option<Self> {
457 if Self::can_cast(syntax.kind()) {
458 Some(Self { syntax })
459 } else {
460 None
461 }
462 }
463 fn syntax(&self) -> &SyntaxToken {
464 &self.syntax
465 }
466}
467#[derive(Debug, Clone, PartialEq, Eq, Hash)]
468pub struct Plus {
469 pub(crate) syntax: SyntaxToken,
470}
471impl std::fmt::Display for Plus {
472 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
473 std::fmt::Display::fmt(&self.syntax, f)
474 }
475}
476impl AstToken for Plus {
477 fn can_cast(kind: SyntaxKind) -> bool {
478 match kind {
479 PLUS => true,
480 _ => false,
481 }
482 }
483 fn cast(syntax: SyntaxToken) -> Option<Self> {
484 if Self::can_cast(syntax.kind()) {
485 Some(Self { syntax })
486 } else {
487 None
488 }
489 }
490 fn syntax(&self) -> &SyntaxToken {
491 &self.syntax
492 }
493}
494#[derive(Debug, Clone, PartialEq, Eq, Hash)]
495pub struct Star {
496 pub(crate) syntax: SyntaxToken,
497}
498impl std::fmt::Display for Star {
499 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
500 std::fmt::Display::fmt(&self.syntax, f)
501 }
502}
503impl AstToken for Star {
504 fn can_cast(kind: SyntaxKind) -> bool {
505 match kind {
506 STAR => true,
507 _ => false,
508 }
509 }
510 fn cast(syntax: SyntaxToken) -> Option<Self> {
511 if Self::can_cast(syntax.kind()) {
512 Some(Self { syntax })
513 } else {
514 None
515 }
516 }
517 fn syntax(&self) -> &SyntaxToken {
518 &self.syntax
519 }
520}
521#[derive(Debug, Clone, PartialEq, Eq, Hash)]
522pub struct Slash {
523 pub(crate) syntax: SyntaxToken,
524}
525impl std::fmt::Display for Slash {
526 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
527 std::fmt::Display::fmt(&self.syntax, f)
528 }
529}
530impl AstToken for Slash {
531 fn can_cast(kind: SyntaxKind) -> bool {
532 match kind {
533 SLASH => true,
534 _ => false,
535 }
536 }
537 fn cast(syntax: SyntaxToken) -> Option<Self> {
538 if Self::can_cast(syntax.kind()) {
539 Some(Self { syntax })
540 } else {
541 None
542 }
543 }
544 fn syntax(&self) -> &SyntaxToken {
545 &self.syntax
546 }
547}
548#[derive(Debug, Clone, PartialEq, Eq, Hash)]
549pub struct Caret {
550 pub(crate) syntax: SyntaxToken,
551}
552impl std::fmt::Display for Caret {
553 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
554 std::fmt::Display::fmt(&self.syntax, f)
555 }
556}
557impl AstToken for Caret {
558 fn can_cast(kind: SyntaxKind) -> bool {
559 match kind {
560 CARET => true,
561 _ => false,
562 }
563 }
564 fn cast(syntax: SyntaxToken) -> Option<Self> {
565 if Self::can_cast(syntax.kind()) {
566 Some(Self { syntax })
567 } else {
568 None
569 }
570 }
571 fn syntax(&self) -> &SyntaxToken {
572 &self.syntax
573 }
574}
575#[derive(Debug, Clone, PartialEq, Eq, Hash)]
576pub struct Percent {
577 pub(crate) syntax: SyntaxToken,
578}
579impl std::fmt::Display for Percent {
580 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
581 std::fmt::Display::fmt(&self.syntax, f)
582 }
583}
584impl AstToken for Percent {
585 fn can_cast(kind: SyntaxKind) -> bool {
586 match kind {
587 PERCENT => true,
588 _ => false,
589 }
590 }
591 fn cast(syntax: SyntaxToken) -> Option<Self> {
592 if Self::can_cast(syntax.kind()) {
593 Some(Self { syntax })
594 } else {
595 None
596 }
597 }
598 fn syntax(&self) -> &SyntaxToken {
599 &self.syntax
600 }
601}
602#[derive(Debug, Clone, PartialEq, Eq, Hash)]
603pub struct Underscore {
604 pub(crate) syntax: SyntaxToken,
605}
606impl std::fmt::Display for Underscore {
607 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
608 std::fmt::Display::fmt(&self.syntax, f)
609 }
610}
611impl AstToken for Underscore {
612 fn can_cast(kind: SyntaxKind) -> bool {
613 match kind {
614 UNDERSCORE => true,
615 _ => false,
616 }
617 }
618 fn cast(syntax: SyntaxToken) -> Option<Self> {
619 if Self::can_cast(syntax.kind()) {
620 Some(Self { syntax })
621 } else {
622 None
623 }
624 }
625 fn syntax(&self) -> &SyntaxToken {
626 &self.syntax
627 }
628}
629#[derive(Debug, Clone, PartialEq, Eq, Hash)]
630pub struct Dot {
631 pub(crate) syntax: SyntaxToken,
632}
633impl std::fmt::Display for Dot {
634 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
635 std::fmt::Display::fmt(&self.syntax, f)
636 }
637}
638impl AstToken for Dot {
639 fn can_cast(kind: SyntaxKind) -> bool {
640 match kind {
641 DOT => true,
642 _ => false,
643 }
644 }
645 fn cast(syntax: SyntaxToken) -> Option<Self> {
646 if Self::can_cast(syntax.kind()) {
647 Some(Self { syntax })
648 } else {
649 None
650 }
651 }
652 fn syntax(&self) -> &SyntaxToken {
653 &self.syntax
654 }
655}
656#[derive(Debug, Clone, PartialEq, Eq, Hash)]
657pub struct Dotdot {
658 pub(crate) syntax: SyntaxToken,
659}
660impl std::fmt::Display for Dotdot {
661 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
662 std::fmt::Display::fmt(&self.syntax, f)
663 }
664}
665impl AstToken for Dotdot {
666 fn can_cast(kind: SyntaxKind) -> bool {
667 match kind {
668 DOTDOT => true,
669 _ => false,
670 }
671 }
672 fn cast(syntax: SyntaxToken) -> Option<Self> {
673 if Self::can_cast(syntax.kind()) {
674 Some(Self { syntax })
675 } else {
676 None
677 }
678 }
679 fn syntax(&self) -> &SyntaxToken {
680 &self.syntax
681 }
682}
683#[derive(Debug, Clone, PartialEq, Eq, Hash)]
684pub struct Dotdotdot {
685 pub(crate) syntax: SyntaxToken,
686}
687impl std::fmt::Display for Dotdotdot {
688 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
689 std::fmt::Display::fmt(&self.syntax, f)
690 }
691}
692impl AstToken for Dotdotdot {
693 fn can_cast(kind: SyntaxKind) -> bool {
694 match kind {
695 DOTDOTDOT => true,
696 _ => false,
697 }
698 }
699 fn cast(syntax: SyntaxToken) -> Option<Self> {
700 if Self::can_cast(syntax.kind()) {
701 Some(Self { syntax })
702 } else {
703 None
704 }
705 }
706 fn syntax(&self) -> &SyntaxToken {
707 &self.syntax
708 }
709}
710#[derive(Debug, Clone, PartialEq, Eq, Hash)]
711pub struct Dotdoteq {
712 pub(crate) syntax: SyntaxToken,
713}
714impl std::fmt::Display for Dotdoteq {
715 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
716 std::fmt::Display::fmt(&self.syntax, f)
717 }
718}
719impl AstToken for Dotdoteq {
720 fn can_cast(kind: SyntaxKind) -> bool {
721 match kind {
722 DOTDOTEQ => true,
723 _ => false,
724 }
725 }
726 fn cast(syntax: SyntaxToken) -> Option<Self> {
727 if Self::can_cast(syntax.kind()) {
728 Some(Self { syntax })
729 } else {
730 None
731 }
732 }
733 fn syntax(&self) -> &SyntaxToken {
734 &self.syntax
735 }
736}
737#[derive(Debug, Clone, PartialEq, Eq, Hash)]
738pub struct Colon {
739 pub(crate) syntax: SyntaxToken,
740}
741impl std::fmt::Display for Colon {
742 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
743 std::fmt::Display::fmt(&self.syntax, f)
744 }
745}
746impl AstToken for Colon {
747 fn can_cast(kind: SyntaxKind) -> bool {
748 match kind {
749 COLON => true,
750 _ => false,
751 }
752 }
753 fn cast(syntax: SyntaxToken) -> Option<Self> {
754 if Self::can_cast(syntax.kind()) {
755 Some(Self { syntax })
756 } else {
757 None
758 }
759 }
760 fn syntax(&self) -> &SyntaxToken {
761 &self.syntax
762 }
763}
764#[derive(Debug, Clone, PartialEq, Eq, Hash)]
765pub struct Coloncolon {
766 pub(crate) syntax: SyntaxToken,
767}
768impl std::fmt::Display for Coloncolon {
769 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
770 std::fmt::Display::fmt(&self.syntax, f)
771 }
772}
773impl AstToken for Coloncolon {
774 fn can_cast(kind: SyntaxKind) -> bool {
775 match kind {
776 COLONCOLON => true,
777 _ => false,
778 }
779 }
780 fn cast(syntax: SyntaxToken) -> Option<Self> {
781 if Self::can_cast(syntax.kind()) {
782 Some(Self { syntax })
783 } else {
784 None
785 }
786 }
787 fn syntax(&self) -> &SyntaxToken {
788 &self.syntax
789 }
790}
791#[derive(Debug, Clone, PartialEq, Eq, Hash)]
792pub struct Eq {
793 pub(crate) syntax: SyntaxToken,
794}
795impl std::fmt::Display for Eq {
796 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
797 std::fmt::Display::fmt(&self.syntax, f)
798 }
799}
800impl AstToken for Eq {
801 fn can_cast(kind: SyntaxKind) -> bool {
802 match kind {
803 EQ => true,
804 _ => false,
805 }
806 }
807 fn cast(syntax: SyntaxToken) -> Option<Self> {
808 if Self::can_cast(syntax.kind()) {
809 Some(Self { syntax })
810 } else {
811 None
812 }
813 }
814 fn syntax(&self) -> &SyntaxToken {
815 &self.syntax
816 }
817}
818#[derive(Debug, Clone, PartialEq, Eq, Hash)]
819pub struct Eqeq {
820 pub(crate) syntax: SyntaxToken,
821}
822impl std::fmt::Display for Eqeq {
823 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
824 std::fmt::Display::fmt(&self.syntax, f)
825 }
826}
827impl AstToken for Eqeq {
828 fn can_cast(kind: SyntaxKind) -> bool {
829 match kind {
830 EQEQ => true,
831 _ => false,
832 }
833 }
834 fn cast(syntax: SyntaxToken) -> Option<Self> {
835 if Self::can_cast(syntax.kind()) {
836 Some(Self { syntax })
837 } else {
838 None
839 }
840 }
841 fn syntax(&self) -> &SyntaxToken {
842 &self.syntax
843 }
844}
845#[derive(Debug, Clone, PartialEq, Eq, Hash)]
846pub struct FatArrow {
847 pub(crate) syntax: SyntaxToken,
848}
849impl std::fmt::Display for FatArrow {
850 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
851 std::fmt::Display::fmt(&self.syntax, f)
852 }
853}
854impl AstToken for FatArrow {
855 fn can_cast(kind: SyntaxKind) -> bool {
856 match kind {
857 FAT_ARROW => true,
858 _ => false,
859 }
860 }
861 fn cast(syntax: SyntaxToken) -> Option<Self> {
862 if Self::can_cast(syntax.kind()) {
863 Some(Self { syntax })
864 } else {
865 None
866 }
867 }
868 fn syntax(&self) -> &SyntaxToken {
869 &self.syntax
870 }
871}
872#[derive(Debug, Clone, PartialEq, Eq, Hash)]
873pub struct Excl {
874 pub(crate) syntax: SyntaxToken,
875}
876impl std::fmt::Display for Excl {
877 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
878 std::fmt::Display::fmt(&self.syntax, f)
879 }
880}
881impl AstToken for Excl {
882 fn can_cast(kind: SyntaxKind) -> bool {
883 match kind {
884 EXCL => true,
885 _ => false,
886 }
887 }
888 fn cast(syntax: SyntaxToken) -> Option<Self> {
889 if Self::can_cast(syntax.kind()) {
890 Some(Self { syntax })
891 } else {
892 None
893 }
894 }
895 fn syntax(&self) -> &SyntaxToken {
896 &self.syntax
897 }
898}
899#[derive(Debug, Clone, PartialEq, Eq, Hash)]
900pub struct Neq {
901 pub(crate) syntax: SyntaxToken,
902}
903impl std::fmt::Display for Neq {
904 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
905 std::fmt::Display::fmt(&self.syntax, f)
906 }
907}
908impl AstToken for Neq {
909 fn can_cast(kind: SyntaxKind) -> bool {
910 match kind {
911 NEQ => true,
912 _ => false,
913 }
914 }
915 fn cast(syntax: SyntaxToken) -> Option<Self> {
916 if Self::can_cast(syntax.kind()) {
917 Some(Self { syntax })
918 } else {
919 None
920 }
921 }
922 fn syntax(&self) -> &SyntaxToken {
923 &self.syntax
924 }
925}
926#[derive(Debug, Clone, PartialEq, Eq, Hash)]
927pub struct Minus {
928 pub(crate) syntax: SyntaxToken,
929}
930impl std::fmt::Display for Minus {
931 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
932 std::fmt::Display::fmt(&self.syntax, f)
933 }
934}
935impl AstToken for Minus {
936 fn can_cast(kind: SyntaxKind) -> bool {
937 match kind {
938 MINUS => true,
939 _ => false,
940 }
941 }
942 fn cast(syntax: SyntaxToken) -> Option<Self> {
943 if Self::can_cast(syntax.kind()) {
944 Some(Self { syntax })
945 } else {
946 None
947 }
948 }
949 fn syntax(&self) -> &SyntaxToken {
950 &self.syntax
951 }
952}
953#[derive(Debug, Clone, PartialEq, Eq, Hash)]
954pub struct ThinArrow {
955 pub(crate) syntax: SyntaxToken,
956}
957impl std::fmt::Display for ThinArrow {
958 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
959 std::fmt::Display::fmt(&self.syntax, f)
960 }
961}
962impl AstToken for ThinArrow {
963 fn can_cast(kind: SyntaxKind) -> bool {
964 match kind {
965 THIN_ARROW => true,
966 _ => false,
967 }
968 }
969 fn cast(syntax: SyntaxToken) -> Option<Self> {
970 if Self::can_cast(syntax.kind()) {
971 Some(Self { syntax })
972 } else {
973 None
974 }
975 }
976 fn syntax(&self) -> &SyntaxToken {
977 &self.syntax
978 }
979}
980#[derive(Debug, Clone, PartialEq, Eq, Hash)]
981pub struct Lteq {
982 pub(crate) syntax: SyntaxToken,
983}
984impl std::fmt::Display for Lteq {
985 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
986 std::fmt::Display::fmt(&self.syntax, f)
987 }
988}
989impl AstToken for Lteq {
990 fn can_cast(kind: SyntaxKind) -> bool {
991 match kind {
992 LTEQ => true,
993 _ => false,
994 }
995 }
996 fn cast(syntax: SyntaxToken) -> Option<Self> {
997 if Self::can_cast(syntax.kind()) {
998 Some(Self { syntax })
999 } else {
1000 None
1001 }
1002 }
1003 fn syntax(&self) -> &SyntaxToken {
1004 &self.syntax
1005 }
1006}
1007#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1008pub struct Gteq {
1009 pub(crate) syntax: SyntaxToken,
1010}
1011impl std::fmt::Display for Gteq {
1012 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1013 std::fmt::Display::fmt(&self.syntax, f)
1014 }
1015}
1016impl AstToken for Gteq {
1017 fn can_cast(kind: SyntaxKind) -> bool {
1018 match kind {
1019 GTEQ => true,
1020 _ => false,
1021 }
1022 }
1023 fn cast(syntax: SyntaxToken) -> Option<Self> {
1024 if Self::can_cast(syntax.kind()) {
1025 Some(Self { syntax })
1026 } else {
1027 None
1028 }
1029 }
1030 fn syntax(&self) -> &SyntaxToken {
1031 &self.syntax
1032 }
1033}
1034#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1035pub struct Pluseq {
1036 pub(crate) syntax: SyntaxToken,
1037}
1038impl std::fmt::Display for Pluseq {
1039 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1040 std::fmt::Display::fmt(&self.syntax, f)
1041 }
1042}
1043impl AstToken for Pluseq {
1044 fn can_cast(kind: SyntaxKind) -> bool {
1045 match kind {
1046 PLUSEQ => true,
1047 _ => false,
1048 }
1049 }
1050 fn cast(syntax: SyntaxToken) -> Option<Self> {
1051 if Self::can_cast(syntax.kind()) {
1052 Some(Self { syntax })
1053 } else {
1054 None
1055 }
1056 }
1057 fn syntax(&self) -> &SyntaxToken {
1058 &self.syntax
1059 }
1060}
1061#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1062pub struct Minuseq {
1063 pub(crate) syntax: SyntaxToken,
1064}
1065impl std::fmt::Display for Minuseq {
1066 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1067 std::fmt::Display::fmt(&self.syntax, f)
1068 }
1069}
1070impl AstToken for Minuseq {
1071 fn can_cast(kind: SyntaxKind) -> bool {
1072 match kind {
1073 MINUSEQ => true,
1074 _ => false,
1075 }
1076 }
1077 fn cast(syntax: SyntaxToken) -> Option<Self> {
1078 if Self::can_cast(syntax.kind()) {
1079 Some(Self { syntax })
1080 } else {
1081 None
1082 }
1083 }
1084 fn syntax(&self) -> &SyntaxToken {
1085 &self.syntax
1086 }
1087}
1088#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1089pub struct Pipeeq {
1090 pub(crate) syntax: SyntaxToken,
1091}
1092impl std::fmt::Display for Pipeeq {
1093 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1094 std::fmt::Display::fmt(&self.syntax, f)
1095 }
1096}
1097impl AstToken for Pipeeq {
1098 fn can_cast(kind: SyntaxKind) -> bool {
1099 match kind {
1100 PIPEEQ => true,
1101 _ => false,
1102 }
1103 }
1104 fn cast(syntax: SyntaxToken) -> Option<Self> {
1105 if Self::can_cast(syntax.kind()) {
1106 Some(Self { syntax })
1107 } else {
1108 None
1109 }
1110 }
1111 fn syntax(&self) -> &SyntaxToken {
1112 &self.syntax
1113 }
1114}
1115#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1116pub struct Ampeq {
1117 pub(crate) syntax: SyntaxToken,
1118}
1119impl std::fmt::Display for Ampeq {
1120 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1121 std::fmt::Display::fmt(&self.syntax, f)
1122 }
1123}
1124impl AstToken for Ampeq {
1125 fn can_cast(kind: SyntaxKind) -> bool {
1126 match kind {
1127 AMPEQ => true,
1128 _ => false,
1129 }
1130 }
1131 fn cast(syntax: SyntaxToken) -> Option<Self> {
1132 if Self::can_cast(syntax.kind()) {
1133 Some(Self { syntax })
1134 } else {
1135 None
1136 }
1137 }
1138 fn syntax(&self) -> &SyntaxToken {
1139 &self.syntax
1140 }
1141}
1142#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1143pub struct Careteq {
1144 pub(crate) syntax: SyntaxToken,
1145}
1146impl std::fmt::Display for Careteq {
1147 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1148 std::fmt::Display::fmt(&self.syntax, f)
1149 }
1150}
1151impl AstToken for Careteq {
1152 fn can_cast(kind: SyntaxKind) -> bool {
1153 match kind {
1154 CARETEQ => true,
1155 _ => false,
1156 }
1157 }
1158 fn cast(syntax: SyntaxToken) -> Option<Self> {
1159 if Self::can_cast(syntax.kind()) {
1160 Some(Self { syntax })
1161 } else {
1162 None
1163 }
1164 }
1165 fn syntax(&self) -> &SyntaxToken {
1166 &self.syntax
1167 }
1168}
1169#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1170pub struct Slasheq {
1171 pub(crate) syntax: SyntaxToken,
1172}
1173impl std::fmt::Display for Slasheq {
1174 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1175 std::fmt::Display::fmt(&self.syntax, f)
1176 }
1177}
1178impl AstToken for Slasheq {
1179 fn can_cast(kind: SyntaxKind) -> bool {
1180 match kind {
1181 SLASHEQ => true,
1182 _ => false,
1183 }
1184 }
1185 fn cast(syntax: SyntaxToken) -> Option<Self> {
1186 if Self::can_cast(syntax.kind()) {
1187 Some(Self { syntax })
1188 } else {
1189 None
1190 }
1191 }
1192 fn syntax(&self) -> &SyntaxToken {
1193 &self.syntax
1194 }
1195}
1196#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1197pub struct Stareq {
1198 pub(crate) syntax: SyntaxToken,
1199}
1200impl std::fmt::Display for Stareq {
1201 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1202 std::fmt::Display::fmt(&self.syntax, f)
1203 }
1204}
1205impl AstToken for Stareq {
1206 fn can_cast(kind: SyntaxKind) -> bool {
1207 match kind {
1208 STAREQ => true,
1209 _ => false,
1210 }
1211 }
1212 fn cast(syntax: SyntaxToken) -> Option<Self> {
1213 if Self::can_cast(syntax.kind()) {
1214 Some(Self { syntax })
1215 } else {
1216 None
1217 }
1218 }
1219 fn syntax(&self) -> &SyntaxToken {
1220 &self.syntax
1221 }
1222}
1223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1224pub struct Percenteq {
1225 pub(crate) syntax: SyntaxToken,
1226}
1227impl std::fmt::Display for Percenteq {
1228 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1229 std::fmt::Display::fmt(&self.syntax, f)
1230 }
1231}
1232impl AstToken for Percenteq {
1233 fn can_cast(kind: SyntaxKind) -> bool {
1234 match kind {
1235 PERCENTEQ => true,
1236 _ => false,
1237 }
1238 }
1239 fn cast(syntax: SyntaxToken) -> Option<Self> {
1240 if Self::can_cast(syntax.kind()) {
1241 Some(Self { syntax })
1242 } else {
1243 None
1244 }
1245 }
1246 fn syntax(&self) -> &SyntaxToken {
1247 &self.syntax
1248 }
1249}
1250#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1251pub struct Ampamp {
1252 pub(crate) syntax: SyntaxToken,
1253}
1254impl std::fmt::Display for Ampamp {
1255 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1256 std::fmt::Display::fmt(&self.syntax, f)
1257 }
1258}
1259impl AstToken for Ampamp {
1260 fn can_cast(kind: SyntaxKind) -> bool {
1261 match kind {
1262 AMPAMP => true,
1263 _ => false,
1264 }
1265 }
1266 fn cast(syntax: SyntaxToken) -> Option<Self> {
1267 if Self::can_cast(syntax.kind()) {
1268 Some(Self { syntax })
1269 } else {
1270 None
1271 }
1272 }
1273 fn syntax(&self) -> &SyntaxToken {
1274 &self.syntax
1275 }
1276}
1277#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1278pub struct Pipepipe {
1279 pub(crate) syntax: SyntaxToken,
1280}
1281impl std::fmt::Display for Pipepipe {
1282 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1283 std::fmt::Display::fmt(&self.syntax, f)
1284 }
1285}
1286impl AstToken for Pipepipe {
1287 fn can_cast(kind: SyntaxKind) -> bool {
1288 match kind {
1289 PIPEPIPE => true,
1290 _ => false,
1291 }
1292 }
1293 fn cast(syntax: SyntaxToken) -> Option<Self> {
1294 if Self::can_cast(syntax.kind()) {
1295 Some(Self { syntax })
1296 } else {
1297 None
1298 }
1299 }
1300 fn syntax(&self) -> &SyntaxToken {
1301 &self.syntax
1302 }
1303}
1304#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1305pub struct Shl {
1306 pub(crate) syntax: SyntaxToken,
1307}
1308impl std::fmt::Display for Shl {
1309 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1310 std::fmt::Display::fmt(&self.syntax, f)
1311 }
1312}
1313impl AstToken for Shl {
1314 fn can_cast(kind: SyntaxKind) -> bool {
1315 match kind {
1316 SHL => true,
1317 _ => false,
1318 }
1319 }
1320 fn cast(syntax: SyntaxToken) -> Option<Self> {
1321 if Self::can_cast(syntax.kind()) {
1322 Some(Self { syntax })
1323 } else {
1324 None
1325 }
1326 }
1327 fn syntax(&self) -> &SyntaxToken {
1328 &self.syntax
1329 }
1330}
1331#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1332pub struct Shr {
1333 pub(crate) syntax: SyntaxToken,
1334}
1335impl std::fmt::Display for Shr {
1336 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1337 std::fmt::Display::fmt(&self.syntax, f)
1338 }
1339}
1340impl AstToken for Shr {
1341 fn can_cast(kind: SyntaxKind) -> bool {
1342 match kind {
1343 SHR => true,
1344 _ => false,
1345 }
1346 }
1347 fn cast(syntax: SyntaxToken) -> Option<Self> {
1348 if Self::can_cast(syntax.kind()) {
1349 Some(Self { syntax })
1350 } else {
1351 None
1352 }
1353 }
1354 fn syntax(&self) -> &SyntaxToken {
1355 &self.syntax
1356 }
1357}
1358#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1359pub struct Shleq {
1360 pub(crate) syntax: SyntaxToken,
1361}
1362impl std::fmt::Display for Shleq {
1363 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1364 std::fmt::Display::fmt(&self.syntax, f)
1365 }
1366}
1367impl AstToken for Shleq {
1368 fn can_cast(kind: SyntaxKind) -> bool {
1369 match kind {
1370 SHLEQ => true,
1371 _ => false,
1372 }
1373 }
1374 fn cast(syntax: SyntaxToken) -> Option<Self> {
1375 if Self::can_cast(syntax.kind()) {
1376 Some(Self { syntax })
1377 } else {
1378 None
1379 }
1380 }
1381 fn syntax(&self) -> &SyntaxToken {
1382 &self.syntax
1383 }
1384}
1385#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1386pub struct Shreq {
1387 pub(crate) syntax: SyntaxToken,
1388}
1389impl std::fmt::Display for Shreq {
1390 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1391 std::fmt::Display::fmt(&self.syntax, f)
1392 }
1393}
1394impl AstToken for Shreq {
1395 fn can_cast(kind: SyntaxKind) -> bool {
1396 match kind {
1397 SHREQ => true,
1398 _ => false,
1399 }
1400 }
1401 fn cast(syntax: SyntaxToken) -> Option<Self> {
1402 if Self::can_cast(syntax.kind()) {
1403 Some(Self { syntax })
1404 } else {
1405 None
1406 }
1407 }
1408 fn syntax(&self) -> &SyntaxToken {
1409 &self.syntax
1410 }
1411}
1412#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1413pub struct AsKw {
1414 pub(crate) syntax: SyntaxToken,
1415}
1416impl std::fmt::Display for AsKw {
1417 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1418 std::fmt::Display::fmt(&self.syntax, f)
1419 }
1420}
1421impl AstToken for AsKw {
1422 fn can_cast(kind: SyntaxKind) -> bool {
1423 match kind {
1424 AS_KW => true,
1425 _ => false,
1426 }
1427 }
1428 fn cast(syntax: SyntaxToken) -> Option<Self> {
1429 if Self::can_cast(syntax.kind()) {
1430 Some(Self { syntax })
1431 } else {
1432 None
1433 }
1434 }
1435 fn syntax(&self) -> &SyntaxToken {
1436 &self.syntax
1437 }
1438}
1439#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1440pub struct AsyncKw {
1441 pub(crate) syntax: SyntaxToken,
1442}
1443impl std::fmt::Display for AsyncKw {
1444 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1445 std::fmt::Display::fmt(&self.syntax, f)
1446 }
1447}
1448impl AstToken for AsyncKw {
1449 fn can_cast(kind: SyntaxKind) -> bool {
1450 match kind {
1451 ASYNC_KW => true,
1452 _ => false,
1453 }
1454 }
1455 fn cast(syntax: SyntaxToken) -> Option<Self> {
1456 if Self::can_cast(syntax.kind()) {
1457 Some(Self { syntax })
1458 } else {
1459 None
1460 }
1461 }
1462 fn syntax(&self) -> &SyntaxToken {
1463 &self.syntax
1464 }
1465}
1466#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1467pub struct AwaitKw {
1468 pub(crate) syntax: SyntaxToken,
1469}
1470impl std::fmt::Display for AwaitKw {
1471 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1472 std::fmt::Display::fmt(&self.syntax, f)
1473 }
1474}
1475impl AstToken for AwaitKw {
1476 fn can_cast(kind: SyntaxKind) -> bool {
1477 match kind {
1478 AWAIT_KW => true,
1479 _ => false,
1480 }
1481 }
1482 fn cast(syntax: SyntaxToken) -> Option<Self> {
1483 if Self::can_cast(syntax.kind()) {
1484 Some(Self { syntax })
1485 } else {
1486 None
1487 }
1488 }
1489 fn syntax(&self) -> &SyntaxToken {
1490 &self.syntax
1491 }
1492}
1493#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1494pub struct BoxKw {
1495 pub(crate) syntax: SyntaxToken,
1496}
1497impl std::fmt::Display for BoxKw {
1498 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1499 std::fmt::Display::fmt(&self.syntax, f)
1500 }
1501}
1502impl AstToken for BoxKw {
1503 fn can_cast(kind: SyntaxKind) -> bool {
1504 match kind {
1505 BOX_KW => true,
1506 _ => false,
1507 }
1508 }
1509 fn cast(syntax: SyntaxToken) -> Option<Self> {
1510 if Self::can_cast(syntax.kind()) {
1511 Some(Self { syntax })
1512 } else {
1513 None
1514 }
1515 }
1516 fn syntax(&self) -> &SyntaxToken {
1517 &self.syntax
1518 }
1519}
1520#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1521pub struct BreakKw {
1522 pub(crate) syntax: SyntaxToken,
1523}
1524impl std::fmt::Display for BreakKw {
1525 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1526 std::fmt::Display::fmt(&self.syntax, f)
1527 }
1528}
1529impl AstToken for BreakKw {
1530 fn can_cast(kind: SyntaxKind) -> bool {
1531 match kind {
1532 BREAK_KW => true,
1533 _ => false,
1534 }
1535 }
1536 fn cast(syntax: SyntaxToken) -> Option<Self> {
1537 if Self::can_cast(syntax.kind()) {
1538 Some(Self { syntax })
1539 } else {
1540 None
1541 }
1542 }
1543 fn syntax(&self) -> &SyntaxToken {
1544 &self.syntax
1545 }
1546}
1547#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1548pub struct ConstKw {
1549 pub(crate) syntax: SyntaxToken,
1550}
1551impl std::fmt::Display for ConstKw {
1552 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1553 std::fmt::Display::fmt(&self.syntax, f)
1554 }
1555}
1556impl AstToken for ConstKw {
1557 fn can_cast(kind: SyntaxKind) -> bool {
1558 match kind {
1559 CONST_KW => true,
1560 _ => false,
1561 }
1562 }
1563 fn cast(syntax: SyntaxToken) -> Option<Self> {
1564 if Self::can_cast(syntax.kind()) {
1565 Some(Self { syntax })
1566 } else {
1567 None
1568 }
1569 }
1570 fn syntax(&self) -> &SyntaxToken {
1571 &self.syntax
1572 }
1573}
1574#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1575pub struct ContinueKw {
1576 pub(crate) syntax: SyntaxToken,
1577}
1578impl std::fmt::Display for ContinueKw {
1579 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1580 std::fmt::Display::fmt(&self.syntax, f)
1581 }
1582}
1583impl AstToken for ContinueKw {
1584 fn can_cast(kind: SyntaxKind) -> bool {
1585 match kind {
1586 CONTINUE_KW => true,
1587 _ => false,
1588 }
1589 }
1590 fn cast(syntax: SyntaxToken) -> Option<Self> {
1591 if Self::can_cast(syntax.kind()) {
1592 Some(Self { syntax })
1593 } else {
1594 None
1595 }
1596 }
1597 fn syntax(&self) -> &SyntaxToken {
1598 &self.syntax
1599 }
1600}
1601#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1602pub struct CrateKw {
1603 pub(crate) syntax: SyntaxToken,
1604}
1605impl std::fmt::Display for CrateKw {
1606 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1607 std::fmt::Display::fmt(&self.syntax, f)
1608 }
1609}
1610impl AstToken for CrateKw {
1611 fn can_cast(kind: SyntaxKind) -> bool {
1612 match kind {
1613 CRATE_KW => true,
1614 _ => false,
1615 }
1616 }
1617 fn cast(syntax: SyntaxToken) -> Option<Self> {
1618 if Self::can_cast(syntax.kind()) {
1619 Some(Self { syntax })
1620 } else {
1621 None
1622 }
1623 }
1624 fn syntax(&self) -> &SyntaxToken {
1625 &self.syntax
1626 }
1627}
1628#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1629pub struct DynKw {
1630 pub(crate) syntax: SyntaxToken,
1631}
1632impl std::fmt::Display for DynKw {
1633 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1634 std::fmt::Display::fmt(&self.syntax, f)
1635 }
1636}
1637impl AstToken for DynKw {
1638 fn can_cast(kind: SyntaxKind) -> bool {
1639 match kind {
1640 DYN_KW => true,
1641 _ => false,
1642 }
1643 }
1644 fn cast(syntax: SyntaxToken) -> Option<Self> {
1645 if Self::can_cast(syntax.kind()) {
1646 Some(Self { syntax })
1647 } else {
1648 None
1649 }
1650 }
1651 fn syntax(&self) -> &SyntaxToken {
1652 &self.syntax
1653 }
1654}
1655#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1656pub struct ElseKw {
1657 pub(crate) syntax: SyntaxToken,
1658}
1659impl std::fmt::Display for ElseKw {
1660 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1661 std::fmt::Display::fmt(&self.syntax, f)
1662 }
1663}
1664impl AstToken for ElseKw {
1665 fn can_cast(kind: SyntaxKind) -> bool {
1666 match kind {
1667 ELSE_KW => true,
1668 _ => false,
1669 }
1670 }
1671 fn cast(syntax: SyntaxToken) -> Option<Self> {
1672 if Self::can_cast(syntax.kind()) {
1673 Some(Self { syntax })
1674 } else {
1675 None
1676 }
1677 }
1678 fn syntax(&self) -> &SyntaxToken {
1679 &self.syntax
1680 }
1681}
1682#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1683pub struct EnumKw {
1684 pub(crate) syntax: SyntaxToken,
1685}
1686impl std::fmt::Display for EnumKw {
1687 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1688 std::fmt::Display::fmt(&self.syntax, f)
1689 }
1690}
1691impl AstToken for EnumKw {
1692 fn can_cast(kind: SyntaxKind) -> bool {
1693 match kind {
1694 ENUM_KW => true,
1695 _ => false,
1696 }
1697 }
1698 fn cast(syntax: SyntaxToken) -> Option<Self> {
1699 if Self::can_cast(syntax.kind()) {
1700 Some(Self { syntax })
1701 } else {
1702 None
1703 }
1704 }
1705 fn syntax(&self) -> &SyntaxToken {
1706 &self.syntax
1707 }
1708}
1709#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1710pub struct ExternKw {
1711 pub(crate) syntax: SyntaxToken,
1712}
1713impl std::fmt::Display for ExternKw {
1714 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1715 std::fmt::Display::fmt(&self.syntax, f)
1716 }
1717}
1718impl AstToken for ExternKw {
1719 fn can_cast(kind: SyntaxKind) -> bool {
1720 match kind {
1721 EXTERN_KW => true,
1722 _ => false,
1723 }
1724 }
1725 fn cast(syntax: SyntaxToken) -> Option<Self> {
1726 if Self::can_cast(syntax.kind()) {
1727 Some(Self { syntax })
1728 } else {
1729 None
1730 }
1731 }
1732 fn syntax(&self) -> &SyntaxToken {
1733 &self.syntax
1734 }
1735}
1736#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1737pub struct FalseKw {
1738 pub(crate) syntax: SyntaxToken,
1739}
1740impl std::fmt::Display for FalseKw {
1741 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1742 std::fmt::Display::fmt(&self.syntax, f)
1743 }
1744}
1745impl AstToken for FalseKw {
1746 fn can_cast(kind: SyntaxKind) -> bool {
1747 match kind {
1748 FALSE_KW => true,
1749 _ => false,
1750 }
1751 }
1752 fn cast(syntax: SyntaxToken) -> Option<Self> {
1753 if Self::can_cast(syntax.kind()) {
1754 Some(Self { syntax })
1755 } else {
1756 None
1757 }
1758 }
1759 fn syntax(&self) -> &SyntaxToken {
1760 &self.syntax
1761 }
1762}
1763#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1764pub struct FnKw {
1765 pub(crate) syntax: SyntaxToken,
1766}
1767impl std::fmt::Display for FnKw {
1768 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1769 std::fmt::Display::fmt(&self.syntax, f)
1770 }
1771}
1772impl AstToken for FnKw {
1773 fn can_cast(kind: SyntaxKind) -> bool {
1774 match kind {
1775 FN_KW => true,
1776 _ => false,
1777 }
1778 }
1779 fn cast(syntax: SyntaxToken) -> Option<Self> {
1780 if Self::can_cast(syntax.kind()) {
1781 Some(Self { syntax })
1782 } else {
1783 None
1784 }
1785 }
1786 fn syntax(&self) -> &SyntaxToken {
1787 &self.syntax
1788 }
1789}
1790#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1791pub struct ForKw {
1792 pub(crate) syntax: SyntaxToken,
1793}
1794impl std::fmt::Display for ForKw {
1795 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1796 std::fmt::Display::fmt(&self.syntax, f)
1797 }
1798}
1799impl AstToken for ForKw {
1800 fn can_cast(kind: SyntaxKind) -> bool {
1801 match kind {
1802 FOR_KW => true,
1803 _ => false,
1804 }
1805 }
1806 fn cast(syntax: SyntaxToken) -> Option<Self> {
1807 if Self::can_cast(syntax.kind()) {
1808 Some(Self { syntax })
1809 } else {
1810 None
1811 }
1812 }
1813 fn syntax(&self) -> &SyntaxToken {
1814 &self.syntax
1815 }
1816}
1817#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1818pub struct IfKw {
1819 pub(crate) syntax: SyntaxToken,
1820}
1821impl std::fmt::Display for IfKw {
1822 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1823 std::fmt::Display::fmt(&self.syntax, f)
1824 }
1825}
1826impl AstToken for IfKw {
1827 fn can_cast(kind: SyntaxKind) -> bool {
1828 match kind {
1829 IF_KW => true,
1830 _ => false,
1831 }
1832 }
1833 fn cast(syntax: SyntaxToken) -> Option<Self> {
1834 if Self::can_cast(syntax.kind()) {
1835 Some(Self { syntax })
1836 } else {
1837 None
1838 }
1839 }
1840 fn syntax(&self) -> &SyntaxToken {
1841 &self.syntax
1842 }
1843}
1844#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1845pub struct ImplKw {
1846 pub(crate) syntax: SyntaxToken,
1847}
1848impl std::fmt::Display for ImplKw {
1849 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1850 std::fmt::Display::fmt(&self.syntax, f)
1851 }
1852}
1853impl AstToken for ImplKw {
1854 fn can_cast(kind: SyntaxKind) -> bool {
1855 match kind {
1856 IMPL_KW => true,
1857 _ => false,
1858 }
1859 }
1860 fn cast(syntax: SyntaxToken) -> Option<Self> {
1861 if Self::can_cast(syntax.kind()) {
1862 Some(Self { syntax })
1863 } else {
1864 None
1865 }
1866 }
1867 fn syntax(&self) -> &SyntaxToken {
1868 &self.syntax
1869 }
1870}
1871#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1872pub struct InKw {
1873 pub(crate) syntax: SyntaxToken,
1874}
1875impl std::fmt::Display for InKw {
1876 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1877 std::fmt::Display::fmt(&self.syntax, f)
1878 }
1879}
1880impl AstToken for InKw {
1881 fn can_cast(kind: SyntaxKind) -> bool {
1882 match kind {
1883 IN_KW => true,
1884 _ => false,
1885 }
1886 }
1887 fn cast(syntax: SyntaxToken) -> Option<Self> {
1888 if Self::can_cast(syntax.kind()) {
1889 Some(Self { syntax })
1890 } else {
1891 None
1892 }
1893 }
1894 fn syntax(&self) -> &SyntaxToken {
1895 &self.syntax
1896 }
1897}
1898#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1899pub struct LetKw {
1900 pub(crate) syntax: SyntaxToken,
1901}
1902impl std::fmt::Display for LetKw {
1903 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1904 std::fmt::Display::fmt(&self.syntax, f)
1905 }
1906}
1907impl AstToken for LetKw {
1908 fn can_cast(kind: SyntaxKind) -> bool {
1909 match kind {
1910 LET_KW => true,
1911 _ => false,
1912 }
1913 }
1914 fn cast(syntax: SyntaxToken) -> Option<Self> {
1915 if Self::can_cast(syntax.kind()) {
1916 Some(Self { syntax })
1917 } else {
1918 None
1919 }
1920 }
1921 fn syntax(&self) -> &SyntaxToken {
1922 &self.syntax
1923 }
1924}
1925#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1926pub struct LoopKw {
1927 pub(crate) syntax: SyntaxToken,
1928}
1929impl std::fmt::Display for LoopKw {
1930 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1931 std::fmt::Display::fmt(&self.syntax, f)
1932 }
1933}
1934impl AstToken for LoopKw {
1935 fn can_cast(kind: SyntaxKind) -> bool {
1936 match kind {
1937 LOOP_KW => true,
1938 _ => false,
1939 }
1940 }
1941 fn cast(syntax: SyntaxToken) -> Option<Self> {
1942 if Self::can_cast(syntax.kind()) {
1943 Some(Self { syntax })
1944 } else {
1945 None
1946 }
1947 }
1948 fn syntax(&self) -> &SyntaxToken {
1949 &self.syntax
1950 }
1951}
1952#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1953pub struct MacroKw {
1954 pub(crate) syntax: SyntaxToken,
1955}
1956impl std::fmt::Display for MacroKw {
1957 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1958 std::fmt::Display::fmt(&self.syntax, f)
1959 }
1960}
1961impl AstToken for MacroKw {
1962 fn can_cast(kind: SyntaxKind) -> bool {
1963 match kind {
1964 MACRO_KW => true,
1965 _ => false,
1966 }
1967 }
1968 fn cast(syntax: SyntaxToken) -> Option<Self> {
1969 if Self::can_cast(syntax.kind()) {
1970 Some(Self { syntax })
1971 } else {
1972 None
1973 }
1974 }
1975 fn syntax(&self) -> &SyntaxToken {
1976 &self.syntax
1977 }
1978}
1979#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1980pub struct MatchKw {
1981 pub(crate) syntax: SyntaxToken,
1982}
1983impl std::fmt::Display for MatchKw {
1984 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1985 std::fmt::Display::fmt(&self.syntax, f)
1986 }
1987}
1988impl AstToken for MatchKw {
1989 fn can_cast(kind: SyntaxKind) -> bool {
1990 match kind {
1991 MATCH_KW => true,
1992 _ => false,
1993 }
1994 }
1995 fn cast(syntax: SyntaxToken) -> Option<Self> {
1996 if Self::can_cast(syntax.kind()) {
1997 Some(Self { syntax })
1998 } else {
1999 None
2000 }
2001 }
2002 fn syntax(&self) -> &SyntaxToken {
2003 &self.syntax
2004 }
2005}
2006#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2007pub struct ModKw {
2008 pub(crate) syntax: SyntaxToken,
2009}
2010impl std::fmt::Display for ModKw {
2011 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2012 std::fmt::Display::fmt(&self.syntax, f)
2013 }
2014}
2015impl AstToken for ModKw {
2016 fn can_cast(kind: SyntaxKind) -> bool {
2017 match kind {
2018 MOD_KW => true,
2019 _ => false,
2020 }
2021 }
2022 fn cast(syntax: SyntaxToken) -> Option<Self> {
2023 if Self::can_cast(syntax.kind()) {
2024 Some(Self { syntax })
2025 } else {
2026 None
2027 }
2028 }
2029 fn syntax(&self) -> &SyntaxToken {
2030 &self.syntax
2031 }
2032}
2033#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2034pub struct MoveKw {
2035 pub(crate) syntax: SyntaxToken,
2036}
2037impl std::fmt::Display for MoveKw {
2038 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2039 std::fmt::Display::fmt(&self.syntax, f)
2040 }
2041}
2042impl AstToken for MoveKw {
2043 fn can_cast(kind: SyntaxKind) -> bool {
2044 match kind {
2045 MOVE_KW => true,
2046 _ => false,
2047 }
2048 }
2049 fn cast(syntax: SyntaxToken) -> Option<Self> {
2050 if Self::can_cast(syntax.kind()) {
2051 Some(Self { syntax })
2052 } else {
2053 None
2054 }
2055 }
2056 fn syntax(&self) -> &SyntaxToken {
2057 &self.syntax
2058 }
2059}
2060#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2061pub struct MutKw {
2062 pub(crate) syntax: SyntaxToken,
2063}
2064impl std::fmt::Display for MutKw {
2065 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2066 std::fmt::Display::fmt(&self.syntax, f)
2067 }
2068}
2069impl AstToken for MutKw {
2070 fn can_cast(kind: SyntaxKind) -> bool {
2071 match kind {
2072 MUT_KW => true,
2073 _ => false,
2074 }
2075 }
2076 fn cast(syntax: SyntaxToken) -> Option<Self> {
2077 if Self::can_cast(syntax.kind()) {
2078 Some(Self { syntax })
2079 } else {
2080 None
2081 }
2082 }
2083 fn syntax(&self) -> &SyntaxToken {
2084 &self.syntax
2085 }
2086}
2087#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2088pub struct PubKw {
2089 pub(crate) syntax: SyntaxToken,
2090}
2091impl std::fmt::Display for PubKw {
2092 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2093 std::fmt::Display::fmt(&self.syntax, f)
2094 }
2095}
2096impl AstToken for PubKw {
2097 fn can_cast(kind: SyntaxKind) -> bool {
2098 match kind {
2099 PUB_KW => true,
2100 _ => false,
2101 }
2102 }
2103 fn cast(syntax: SyntaxToken) -> Option<Self> {
2104 if Self::can_cast(syntax.kind()) {
2105 Some(Self { syntax })
2106 } else {
2107 None
2108 }
2109 }
2110 fn syntax(&self) -> &SyntaxToken {
2111 &self.syntax
2112 }
2113}
2114#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2115pub struct RefKw {
2116 pub(crate) syntax: SyntaxToken,
2117}
2118impl std::fmt::Display for RefKw {
2119 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2120 std::fmt::Display::fmt(&self.syntax, f)
2121 }
2122}
2123impl AstToken for RefKw {
2124 fn can_cast(kind: SyntaxKind) -> bool {
2125 match kind {
2126 REF_KW => true,
2127 _ => false,
2128 }
2129 }
2130 fn cast(syntax: SyntaxToken) -> Option<Self> {
2131 if Self::can_cast(syntax.kind()) {
2132 Some(Self { syntax })
2133 } else {
2134 None
2135 }
2136 }
2137 fn syntax(&self) -> &SyntaxToken {
2138 &self.syntax
2139 }
2140}
2141#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2142pub struct ReturnKw {
2143 pub(crate) syntax: SyntaxToken,
2144}
2145impl std::fmt::Display for ReturnKw {
2146 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2147 std::fmt::Display::fmt(&self.syntax, f)
2148 }
2149}
2150impl AstToken for ReturnKw {
2151 fn can_cast(kind: SyntaxKind) -> bool {
2152 match kind {
2153 RETURN_KW => true,
2154 _ => false,
2155 }
2156 }
2157 fn cast(syntax: SyntaxToken) -> Option<Self> {
2158 if Self::can_cast(syntax.kind()) {
2159 Some(Self { syntax })
2160 } else {
2161 None
2162 }
2163 }
2164 fn syntax(&self) -> &SyntaxToken {
2165 &self.syntax
2166 }
2167}
2168#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2169pub struct SelfKw {
2170 pub(crate) syntax: SyntaxToken,
2171}
2172impl std::fmt::Display for SelfKw {
2173 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2174 std::fmt::Display::fmt(&self.syntax, f)
2175 }
2176}
2177impl AstToken for SelfKw {
2178 fn can_cast(kind: SyntaxKind) -> bool {
2179 match kind {
2180 SELF_KW => true,
2181 _ => false,
2182 }
2183 }
2184 fn cast(syntax: SyntaxToken) -> Option<Self> {
2185 if Self::can_cast(syntax.kind()) {
2186 Some(Self { syntax })
2187 } else {
2188 None
2189 }
2190 }
2191 fn syntax(&self) -> &SyntaxToken {
2192 &self.syntax
2193 }
2194}
2195#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2196pub struct StaticKw {
2197 pub(crate) syntax: SyntaxToken,
2198}
2199impl std::fmt::Display for StaticKw {
2200 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2201 std::fmt::Display::fmt(&self.syntax, f)
2202 }
2203}
2204impl AstToken for StaticKw {
2205 fn can_cast(kind: SyntaxKind) -> bool {
2206 match kind {
2207 STATIC_KW => true,
2208 _ => false,
2209 }
2210 }
2211 fn cast(syntax: SyntaxToken) -> Option<Self> {
2212 if Self::can_cast(syntax.kind()) {
2213 Some(Self { syntax })
2214 } else {
2215 None
2216 }
2217 }
2218 fn syntax(&self) -> &SyntaxToken {
2219 &self.syntax
2220 }
2221}
2222#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2223pub struct StructKw {
2224 pub(crate) syntax: SyntaxToken,
2225}
2226impl std::fmt::Display for StructKw {
2227 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2228 std::fmt::Display::fmt(&self.syntax, f)
2229 }
2230}
2231impl AstToken for StructKw {
2232 fn can_cast(kind: SyntaxKind) -> bool {
2233 match kind {
2234 STRUCT_KW => true,
2235 _ => false,
2236 }
2237 }
2238 fn cast(syntax: SyntaxToken) -> Option<Self> {
2239 if Self::can_cast(syntax.kind()) {
2240 Some(Self { syntax })
2241 } else {
2242 None
2243 }
2244 }
2245 fn syntax(&self) -> &SyntaxToken {
2246 &self.syntax
2247 }
2248}
2249#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2250pub struct SuperKw {
2251 pub(crate) syntax: SyntaxToken,
2252}
2253impl std::fmt::Display for SuperKw {
2254 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2255 std::fmt::Display::fmt(&self.syntax, f)
2256 }
2257}
2258impl AstToken for SuperKw {
2259 fn can_cast(kind: SyntaxKind) -> bool {
2260 match kind {
2261 SUPER_KW => true,
2262 _ => false,
2263 }
2264 }
2265 fn cast(syntax: SyntaxToken) -> Option<Self> {
2266 if Self::can_cast(syntax.kind()) {
2267 Some(Self { syntax })
2268 } else {
2269 None
2270 }
2271 }
2272 fn syntax(&self) -> &SyntaxToken {
2273 &self.syntax
2274 }
2275}
2276#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2277pub struct TraitKw {
2278 pub(crate) syntax: SyntaxToken,
2279}
2280impl std::fmt::Display for TraitKw {
2281 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2282 std::fmt::Display::fmt(&self.syntax, f)
2283 }
2284}
2285impl AstToken for TraitKw {
2286 fn can_cast(kind: SyntaxKind) -> bool {
2287 match kind {
2288 TRAIT_KW => true,
2289 _ => false,
2290 }
2291 }
2292 fn cast(syntax: SyntaxToken) -> Option<Self> {
2293 if Self::can_cast(syntax.kind()) {
2294 Some(Self { syntax })
2295 } else {
2296 None
2297 }
2298 }
2299 fn syntax(&self) -> &SyntaxToken {
2300 &self.syntax
2301 }
2302}
2303#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2304pub struct TrueKw {
2305 pub(crate) syntax: SyntaxToken,
2306}
2307impl std::fmt::Display for TrueKw {
2308 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2309 std::fmt::Display::fmt(&self.syntax, f)
2310 }
2311}
2312impl AstToken for TrueKw {
2313 fn can_cast(kind: SyntaxKind) -> bool {
2314 match kind {
2315 TRUE_KW => true,
2316 _ => false,
2317 }
2318 }
2319 fn cast(syntax: SyntaxToken) -> Option<Self> {
2320 if Self::can_cast(syntax.kind()) {
2321 Some(Self { syntax })
2322 } else {
2323 None
2324 }
2325 }
2326 fn syntax(&self) -> &SyntaxToken {
2327 &self.syntax
2328 }
2329}
2330#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2331pub struct TryKw {
2332 pub(crate) syntax: SyntaxToken,
2333}
2334impl std::fmt::Display for TryKw {
2335 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2336 std::fmt::Display::fmt(&self.syntax, f)
2337 }
2338}
2339impl AstToken for TryKw {
2340 fn can_cast(kind: SyntaxKind) -> bool {
2341 match kind {
2342 TRY_KW => true,
2343 _ => false,
2344 }
2345 }
2346 fn cast(syntax: SyntaxToken) -> Option<Self> {
2347 if Self::can_cast(syntax.kind()) {
2348 Some(Self { syntax })
2349 } else {
2350 None
2351 }
2352 }
2353 fn syntax(&self) -> &SyntaxToken {
2354 &self.syntax
2355 }
2356}
2357#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2358pub struct TypeKw {
2359 pub(crate) syntax: SyntaxToken,
2360}
2361impl std::fmt::Display for TypeKw {
2362 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2363 std::fmt::Display::fmt(&self.syntax, f)
2364 }
2365}
2366impl AstToken for TypeKw {
2367 fn can_cast(kind: SyntaxKind) -> bool {
2368 match kind {
2369 TYPE_KW => true,
2370 _ => false,
2371 }
2372 }
2373 fn cast(syntax: SyntaxToken) -> Option<Self> {
2374 if Self::can_cast(syntax.kind()) {
2375 Some(Self { syntax })
2376 } else {
2377 None
2378 }
2379 }
2380 fn syntax(&self) -> &SyntaxToken {
2381 &self.syntax
2382 }
2383}
2384#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2385pub struct UnsafeKw {
2386 pub(crate) syntax: SyntaxToken,
2387}
2388impl std::fmt::Display for UnsafeKw {
2389 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2390 std::fmt::Display::fmt(&self.syntax, f)
2391 }
2392}
2393impl AstToken for UnsafeKw {
2394 fn can_cast(kind: SyntaxKind) -> bool {
2395 match kind {
2396 UNSAFE_KW => true,
2397 _ => false,
2398 }
2399 }
2400 fn cast(syntax: SyntaxToken) -> Option<Self> {
2401 if Self::can_cast(syntax.kind()) {
2402 Some(Self { syntax })
2403 } else {
2404 None
2405 }
2406 }
2407 fn syntax(&self) -> &SyntaxToken {
2408 &self.syntax
2409 }
2410}
2411#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2412pub struct UseKw {
2413 pub(crate) syntax: SyntaxToken,
2414}
2415impl std::fmt::Display for UseKw {
2416 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2417 std::fmt::Display::fmt(&self.syntax, f)
2418 }
2419}
2420impl AstToken for UseKw {
2421 fn can_cast(kind: SyntaxKind) -> bool {
2422 match kind {
2423 USE_KW => true,
2424 _ => false,
2425 }
2426 }
2427 fn cast(syntax: SyntaxToken) -> Option<Self> {
2428 if Self::can_cast(syntax.kind()) {
2429 Some(Self { syntax })
2430 } else {
2431 None
2432 }
2433 }
2434 fn syntax(&self) -> &SyntaxToken {
2435 &self.syntax
2436 }
2437}
2438#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2439pub struct WhereKw {
2440 pub(crate) syntax: SyntaxToken,
2441}
2442impl std::fmt::Display for WhereKw {
2443 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2444 std::fmt::Display::fmt(&self.syntax, f)
2445 }
2446}
2447impl AstToken for WhereKw {
2448 fn can_cast(kind: SyntaxKind) -> bool {
2449 match kind {
2450 WHERE_KW => true,
2451 _ => false,
2452 }
2453 }
2454 fn cast(syntax: SyntaxToken) -> Option<Self> {
2455 if Self::can_cast(syntax.kind()) {
2456 Some(Self { syntax })
2457 } else {
2458 None
2459 }
2460 }
2461 fn syntax(&self) -> &SyntaxToken {
2462 &self.syntax
2463 }
2464}
2465#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2466pub struct WhileKw {
2467 pub(crate) syntax: SyntaxToken,
2468}
2469impl std::fmt::Display for WhileKw {
2470 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2471 std::fmt::Display::fmt(&self.syntax, f)
2472 }
2473}
2474impl AstToken for WhileKw {
2475 fn can_cast(kind: SyntaxKind) -> bool {
2476 match kind {
2477 WHILE_KW => true,
2478 _ => false,
2479 }
2480 }
2481 fn cast(syntax: SyntaxToken) -> Option<Self> {
2482 if Self::can_cast(syntax.kind()) {
2483 Some(Self { syntax })
2484 } else {
2485 None
2486 }
2487 }
2488 fn syntax(&self) -> &SyntaxToken {
2489 &self.syntax
2490 }
2491}
2492#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2493pub struct AutoKw {
2494 pub(crate) syntax: SyntaxToken,
2495}
2496impl std::fmt::Display for AutoKw {
2497 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2498 std::fmt::Display::fmt(&self.syntax, f)
2499 }
2500}
2501impl AstToken for AutoKw {
2502 fn can_cast(kind: SyntaxKind) -> bool {
2503 match kind {
2504 AUTO_KW => true,
2505 _ => false,
2506 }
2507 }
2508 fn cast(syntax: SyntaxToken) -> Option<Self> {
2509 if Self::can_cast(syntax.kind()) {
2510 Some(Self { syntax })
2511 } else {
2512 None
2513 }
2514 }
2515 fn syntax(&self) -> &SyntaxToken {
2516 &self.syntax
2517 }
2518}
2519#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2520pub struct DefaultKw {
2521 pub(crate) syntax: SyntaxToken,
2522}
2523impl std::fmt::Display for DefaultKw {
2524 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2525 std::fmt::Display::fmt(&self.syntax, f)
2526 }
2527}
2528impl AstToken for DefaultKw {
2529 fn can_cast(kind: SyntaxKind) -> bool {
2530 match kind {
2531 DEFAULT_KW => true,
2532 _ => false,
2533 }
2534 }
2535 fn cast(syntax: SyntaxToken) -> Option<Self> {
2536 if Self::can_cast(syntax.kind()) {
2537 Some(Self { syntax })
2538 } else {
2539 None
2540 }
2541 }
2542 fn syntax(&self) -> &SyntaxToken {
2543 &self.syntax
2544 }
2545}
2546#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2547pub struct ExistentialKw {
2548 pub(crate) syntax: SyntaxToken,
2549}
2550impl std::fmt::Display for ExistentialKw {
2551 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2552 std::fmt::Display::fmt(&self.syntax, f)
2553 }
2554}
2555impl AstToken for ExistentialKw {
2556 fn can_cast(kind: SyntaxKind) -> bool {
2557 match kind {
2558 EXISTENTIAL_KW => true,
2559 _ => false,
2560 }
2561 }
2562 fn cast(syntax: SyntaxToken) -> Option<Self> {
2563 if Self::can_cast(syntax.kind()) {
2564 Some(Self { syntax })
2565 } else {
2566 None
2567 }
2568 }
2569 fn syntax(&self) -> &SyntaxToken {
2570 &self.syntax
2571 }
2572}
2573#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2574pub struct UnionKw {
2575 pub(crate) syntax: SyntaxToken,
2576}
2577impl std::fmt::Display for UnionKw {
2578 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2579 std::fmt::Display::fmt(&self.syntax, f)
2580 }
2581}
2582impl AstToken for UnionKw {
2583 fn can_cast(kind: SyntaxKind) -> bool {
2584 match kind {
2585 UNION_KW => true,
2586 _ => false,
2587 }
2588 }
2589 fn cast(syntax: SyntaxToken) -> Option<Self> {
2590 if Self::can_cast(syntax.kind()) {
2591 Some(Self { syntax })
2592 } else {
2593 None
2594 }
2595 }
2596 fn syntax(&self) -> &SyntaxToken {
2597 &self.syntax
2598 }
2599}
2600#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2601pub struct RawKw {
2602 pub(crate) syntax: SyntaxToken,
2603}
2604impl std::fmt::Display for RawKw {
2605 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2606 std::fmt::Display::fmt(&self.syntax, f)
2607 }
2608}
2609impl AstToken for RawKw {
2610 fn can_cast(kind: SyntaxKind) -> bool {
2611 match kind {
2612 RAW_KW => true,
2613 _ => false,
2614 }
2615 }
2616 fn cast(syntax: SyntaxToken) -> Option<Self> {
2617 if Self::can_cast(syntax.kind()) {
2618 Some(Self { syntax })
2619 } else {
2620 None
2621 }
2622 }
2623 fn syntax(&self) -> &SyntaxToken {
2624 &self.syntax
2625 }
2626}
2627#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2628pub struct IntNumber {
2629 pub(crate) syntax: SyntaxToken,
2630}
2631impl std::fmt::Display for IntNumber {
2632 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2633 std::fmt::Display::fmt(&self.syntax, f)
2634 }
2635}
2636impl AstToken for IntNumber {
2637 fn can_cast(kind: SyntaxKind) -> bool {
2638 match kind {
2639 INT_NUMBER => true,
2640 _ => false,
2641 }
2642 }
2643 fn cast(syntax: SyntaxToken) -> Option<Self> {
2644 if Self::can_cast(syntax.kind()) {
2645 Some(Self { syntax })
2646 } else {
2647 None
2648 }
2649 }
2650 fn syntax(&self) -> &SyntaxToken {
2651 &self.syntax
2652 }
2653}
2654#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2655pub struct FloatNumber {
2656 pub(crate) syntax: SyntaxToken,
2657}
2658impl std::fmt::Display for FloatNumber {
2659 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2660 std::fmt::Display::fmt(&self.syntax, f)
2661 }
2662}
2663impl AstToken for FloatNumber {
2664 fn can_cast(kind: SyntaxKind) -> bool {
2665 match kind {
2666 FLOAT_NUMBER => true,
2667 _ => false,
2668 }
2669 }
2670 fn cast(syntax: SyntaxToken) -> Option<Self> {
2671 if Self::can_cast(syntax.kind()) {
2672 Some(Self { syntax })
2673 } else {
2674 None
2675 }
2676 }
2677 fn syntax(&self) -> &SyntaxToken {
2678 &self.syntax
2679 }
2680}
2681#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2682pub struct Char {
2683 pub(crate) syntax: SyntaxToken,
2684}
2685impl std::fmt::Display for Char {
2686 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2687 std::fmt::Display::fmt(&self.syntax, f)
2688 }
2689}
2690impl AstToken for Char {
2691 fn can_cast(kind: SyntaxKind) -> bool {
2692 match kind {
2693 CHAR => true,
2694 _ => false,
2695 }
2696 }
2697 fn cast(syntax: SyntaxToken) -> Option<Self> {
2698 if Self::can_cast(syntax.kind()) {
2699 Some(Self { syntax })
2700 } else {
2701 None
2702 }
2703 }
2704 fn syntax(&self) -> &SyntaxToken {
2705 &self.syntax
2706 }
2707}
2708#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2709pub struct Byte {
2710 pub(crate) syntax: SyntaxToken,
2711}
2712impl std::fmt::Display for Byte {
2713 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2714 std::fmt::Display::fmt(&self.syntax, f)
2715 }
2716}
2717impl AstToken for Byte {
2718 fn can_cast(kind: SyntaxKind) -> bool {
2719 match kind {
2720 BYTE => true,
2721 _ => false,
2722 }
2723 }
2724 fn cast(syntax: SyntaxToken) -> Option<Self> {
2725 if Self::can_cast(syntax.kind()) {
2726 Some(Self { syntax })
2727 } else {
2728 None
2729 }
2730 }
2731 fn syntax(&self) -> &SyntaxToken {
2732 &self.syntax
2733 }
2734}
2735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2736pub struct String {
2737 pub(crate) syntax: SyntaxToken,
2738}
2739impl std::fmt::Display for String {
2740 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2741 std::fmt::Display::fmt(&self.syntax, f)
2742 }
2743}
2744impl AstToken for String {
2745 fn can_cast(kind: SyntaxKind) -> bool {
2746 match kind {
2747 STRING => true,
2748 _ => false,
2749 }
2750 }
2751 fn cast(syntax: SyntaxToken) -> Option<Self> {
2752 if Self::can_cast(syntax.kind()) {
2753 Some(Self { syntax })
2754 } else {
2755 None
2756 }
2757 }
2758 fn syntax(&self) -> &SyntaxToken {
2759 &self.syntax
2760 }
2761}
2762#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2763pub struct RawString {
2764 pub(crate) syntax: SyntaxToken,
2765}
2766impl std::fmt::Display for RawString {
2767 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2768 std::fmt::Display::fmt(&self.syntax, f)
2769 }
2770}
2771impl AstToken for RawString {
2772 fn can_cast(kind: SyntaxKind) -> bool {
2773 match kind {
2774 RAW_STRING => true,
2775 _ => false,
2776 }
2777 }
2778 fn cast(syntax: SyntaxToken) -> Option<Self> {
2779 if Self::can_cast(syntax.kind()) {
2780 Some(Self { syntax })
2781 } else {
2782 None
2783 }
2784 }
2785 fn syntax(&self) -> &SyntaxToken {
2786 &self.syntax
2787 }
2788}
2789#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2790pub struct ByteString {
2791 pub(crate) syntax: SyntaxToken,
2792}
2793impl std::fmt::Display for ByteString {
2794 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2795 std::fmt::Display::fmt(&self.syntax, f)
2796 }
2797}
2798impl AstToken for ByteString {
2799 fn can_cast(kind: SyntaxKind) -> bool {
2800 match kind {
2801 BYTE_STRING => true,
2802 _ => false,
2803 }
2804 }
2805 fn cast(syntax: SyntaxToken) -> Option<Self> {
2806 if Self::can_cast(syntax.kind()) {
2807 Some(Self { syntax })
2808 } else {
2809 None
2810 }
2811 }
2812 fn syntax(&self) -> &SyntaxToken {
2813 &self.syntax
2814 }
2815}
2816#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2817pub struct RawByteString {
2818 pub(crate) syntax: SyntaxToken,
2819}
2820impl std::fmt::Display for RawByteString {
2821 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2822 std::fmt::Display::fmt(&self.syntax, f)
2823 }
2824}
2825impl AstToken for RawByteString {
2826 fn can_cast(kind: SyntaxKind) -> bool {
2827 match kind {
2828 RAW_BYTE_STRING => true,
2829 _ => false,
2830 }
2831 }
2832 fn cast(syntax: SyntaxToken) -> Option<Self> {
2833 if Self::can_cast(syntax.kind()) {
2834 Some(Self { syntax })
2835 } else {
2836 None
2837 }
2838 }
2839 fn syntax(&self) -> &SyntaxToken {
2840 &self.syntax
2841 }
2842}
2843#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2844pub struct Error {
2845 pub(crate) syntax: SyntaxToken,
2846}
2847impl std::fmt::Display for Error {
2848 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2849 std::fmt::Display::fmt(&self.syntax, f)
2850 }
2851}
2852impl AstToken for Error {
2853 fn can_cast(kind: SyntaxKind) -> bool {
2854 match kind {
2855 ERROR => true,
2856 _ => false,
2857 }
2858 }
2859 fn cast(syntax: SyntaxToken) -> Option<Self> {
2860 if Self::can_cast(syntax.kind()) {
2861 Some(Self { syntax })
2862 } else {
2863 None
2864 }
2865 }
2866 fn syntax(&self) -> &SyntaxToken {
2867 &self.syntax
2868 }
2869}
2870#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2871pub struct Ident {
2872 pub(crate) syntax: SyntaxToken,
2873}
2874impl std::fmt::Display for Ident {
2875 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2876 std::fmt::Display::fmt(&self.syntax, f)
2877 }
2878}
2879impl AstToken for Ident {
2880 fn can_cast(kind: SyntaxKind) -> bool {
2881 match kind {
2882 IDENT => true,
2883 _ => false,
2884 }
2885 }
2886 fn cast(syntax: SyntaxToken) -> Option<Self> {
2887 if Self::can_cast(syntax.kind()) {
2888 Some(Self { syntax })
2889 } else {
2890 None
2891 }
2892 }
2893 fn syntax(&self) -> &SyntaxToken {
2894 &self.syntax
2895 }
2896}
2897#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2898pub struct Whitespace {
2899 pub(crate) syntax: SyntaxToken,
2900}
2901impl std::fmt::Display for Whitespace {
2902 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2903 std::fmt::Display::fmt(&self.syntax, f)
2904 }
2905}
2906impl AstToken for Whitespace {
2907 fn can_cast(kind: SyntaxKind) -> bool {
2908 match kind {
2909 WHITESPACE => true,
2910 _ => false,
2911 }
2912 }
2913 fn cast(syntax: SyntaxToken) -> Option<Self> {
2914 if Self::can_cast(syntax.kind()) {
2915 Some(Self { syntax })
2916 } else {
2917 None
2918 }
2919 }
2920 fn syntax(&self) -> &SyntaxToken {
2921 &self.syntax
2922 }
2923}
2924#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2925pub struct Lifetime {
2926 pub(crate) syntax: SyntaxToken,
2927}
2928impl std::fmt::Display for Lifetime {
2929 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2930 std::fmt::Display::fmt(&self.syntax, f)
2931 }
2932}
2933impl AstToken for Lifetime {
2934 fn can_cast(kind: SyntaxKind) -> bool {
2935 match kind {
2936 LIFETIME => true,
2937 _ => false,
2938 }
2939 }
2940 fn cast(syntax: SyntaxToken) -> Option<Self> {
2941 if Self::can_cast(syntax.kind()) {
2942 Some(Self { syntax })
2943 } else {
2944 None
2945 }
2946 }
2947 fn syntax(&self) -> &SyntaxToken {
2948 &self.syntax
2949 }
2950}
2951#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2952pub struct Comment {
2953 pub(crate) syntax: SyntaxToken,
2954}
2955impl std::fmt::Display for Comment {
2956 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2957 std::fmt::Display::fmt(&self.syntax, f)
2958 }
2959}
2960impl AstToken for Comment {
2961 fn can_cast(kind: SyntaxKind) -> bool {
2962 match kind {
2963 COMMENT => true,
2964 _ => false,
2965 }
2966 }
2967 fn cast(syntax: SyntaxToken) -> Option<Self> {
2968 if Self::can_cast(syntax.kind()) {
2969 Some(Self { syntax })
2970 } else {
2971 None
2972 }
2973 }
2974 fn syntax(&self) -> &SyntaxToken {
2975 &self.syntax
2976 }
2977}
2978#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2979pub struct Shebang {
2980 pub(crate) syntax: SyntaxToken,
2981}
2982impl std::fmt::Display for Shebang {
2983 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2984 std::fmt::Display::fmt(&self.syntax, f)
2985 }
2986}
2987impl AstToken for Shebang {
2988 fn can_cast(kind: SyntaxKind) -> bool {
2989 match kind {
2990 SHEBANG => true,
2991 _ => false,
2992 }
2993 }
2994 fn cast(syntax: SyntaxToken) -> Option<Self> {
2995 if Self::can_cast(syntax.kind()) {
2996 Some(Self { syntax })
2997 } else {
2998 None
2999 }
3000 }
3001 fn syntax(&self) -> &SyntaxToken {
3002 &self.syntax
3003 }
3004}
3005#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3006pub struct LDollar {
3007 pub(crate) syntax: SyntaxToken,
3008}
3009impl std::fmt::Display for LDollar {
3010 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3011 std::fmt::Display::fmt(&self.syntax, f)
3012 }
3013}
3014impl AstToken for LDollar {
3015 fn can_cast(kind: SyntaxKind) -> bool {
3016 match kind {
3017 L_DOLLAR => true,
3018 _ => false,
3019 }
3020 }
3021 fn cast(syntax: SyntaxToken) -> Option<Self> {
3022 if Self::can_cast(syntax.kind()) {
3023 Some(Self { syntax })
3024 } else {
3025 None
3026 }
3027 }
3028 fn syntax(&self) -> &SyntaxToken {
3029 &self.syntax
3030 }
3031}
3032#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3033pub struct RDollar {
3034 pub(crate) syntax: SyntaxToken,
3035}
3036impl std::fmt::Display for RDollar {
3037 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3038 std::fmt::Display::fmt(&self.syntax, f)
3039 }
3040}
3041impl AstToken for RDollar {
3042 fn can_cast(kind: SyntaxKind) -> bool {
3043 match kind {
3044 R_DOLLAR => true,
3045 _ => false,
3046 }
3047 }
3048 fn cast(syntax: SyntaxToken) -> Option<Self> {
3049 if Self::can_cast(syntax.kind()) {
3050 Some(Self { syntax })
3051 } else {
3052 None
3053 }
3054 }
3055 fn syntax(&self) -> &SyntaxToken {
3056 &self.syntax
3057 }
3058}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-07 11:38:57 +0100