1#![allow(bad_style, missing_docs, unreachable_pub)]
4use crate::Edition;
5#[doc = r" The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`."]
6#[derive(Debug)]
7#[repr(u16)]
8pub enum SyntaxKind {
9 #[doc(hidden)]
10 TOMBSTONE,
11 #[doc(hidden)]
12 EOF,
13 DOLLAR,
14 SEMICOLON,
15 COMMA,
16 L_PAREN,
17 R_PAREN,
18 L_CURLY,
19 R_CURLY,
20 L_BRACK,
21 R_BRACK,
22 L_ANGLE,
23 R_ANGLE,
24 AT,
25 POUND,
26 TILDE,
27 QUESTION,
28 AMP,
29 PIPE,
30 PLUS,
31 STAR,
32 SLASH,
33 CARET,
34 PERCENT,
35 UNDERSCORE,
36 DOT,
37 DOT2,
38 DOT3,
39 DOT2EQ,
40 COLON,
41 COLON2,
42 EQ,
43 EQ2,
44 FAT_ARROW,
45 BANG,
46 NEQ,
47 MINUS,
48 THIN_ARROW,
49 LTEQ,
50 GTEQ,
51 PLUSEQ,
52 MINUSEQ,
53 PIPEEQ,
54 AMPEQ,
55 CARETEQ,
56 SLASHEQ,
57 STAREQ,
58 PERCENTEQ,
59 AMP2,
60 PIPE2,
61 SHL,
62 SHR,
63 SHLEQ,
64 SHREQ,
65 SELF_TYPE_KW,
66 ABSTRACT_KW,
67 AS_KW,
68 BECOME_KW,
69 BOX_KW,
70 BREAK_KW,
71 CONST_KW,
72 CONTINUE_KW,
73 CRATE_KW,
74 DO_KW,
75 ELSE_KW,
76 ENUM_KW,
77 EXTERN_KW,
78 FALSE_KW,
79 FINAL_KW,
80 FN_KW,
81 FOR_KW,
82 IF_KW,
83 IMPL_KW,
84 IN_KW,
85 LET_KW,
86 LOOP_KW,
87 MACRO_KW,
88 MATCH_KW,
89 MOD_KW,
90 MOVE_KW,
91 MUT_KW,
92 OVERRIDE_KW,
93 PRIV_KW,
94 PUB_KW,
95 REF_KW,
96 RETURN_KW,
97 SELF_KW,
98 STATIC_KW,
99 STRUCT_KW,
100 SUPER_KW,
101 TRAIT_KW,
102 TRUE_KW,
103 TYPE_KW,
104 TYPEOF_KW,
105 UNSAFE_KW,
106 UNSIZED_KW,
107 USE_KW,
108 VIRTUAL_KW,
109 WHERE_KW,
110 WHILE_KW,
111 YIELD_KW,
112 ASM_KW,
113 ASYNC_KW,
114 ATT_SYNTAX_KW,
115 AUTO_KW,
116 AWAIT_KW,
117 BUILTIN_KW,
118 CLOBBER_ABI_KW,
119 DEFAULT_KW,
120 DYN_KW,
121 FORMAT_ARGS_KW,
122 GEN_KW,
123 GLOBAL_ASM_KW,
124 INLATEOUT_KW,
125 INOUT_KW,
126 LABEL_KW,
127 LATEOUT_KW,
128 MACRO_RULES_KW,
129 MAY_UNWIND_KW,
130 NAKED_ASM_KW,
131 NOMEM_KW,
132 NORETURN_KW,
133 NOSTACK_KW,
134 OFFSET_OF_KW,
135 OPTIONS_KW,
136 OUT_KW,
137 PRESERVES_FLAGS_KW,
138 PURE_KW,
139 RAW_KW,
140 READONLY_KW,
141 SAFE_KW,
142 SYM_KW,
143 TRY_KW,
144 UNION_KW,
145 YEET_KW,
146 BYTE,
147 BYTE_STRING,
148 CHAR,
149 C_STRING,
150 FLOAT_NUMBER,
151 INT_NUMBER,
152 STRING,
153 COMMENT,
154 ERROR,
155 FRONTMATTER,
156 IDENT,
157 LIFETIME_IDENT,
158 NEWLINE,
159 SHEBANG,
160 WHITESPACE,
161 ABI,
162 ARG_LIST,
163 ARRAY_EXPR,
164 ARRAY_TYPE,
165 ASM_CLOBBER_ABI,
166 ASM_CONST,
167 ASM_DIR_SPEC,
168 ASM_EXPR,
169 ASM_LABEL,
170 ASM_OPERAND_EXPR,
171 ASM_OPERAND_NAMED,
172 ASM_OPTION,
173 ASM_OPTIONS,
174 ASM_REG_OPERAND,
175 ASM_REG_SPEC,
176 ASM_SYM,
177 ASSOC_ITEM_LIST,
178 ASSOC_TYPE_ARG,
179 ATTR,
180 AWAIT_EXPR,
181 BECOME_EXPR,
182 BIN_EXPR,
183 BLOCK_EXPR,
184 BOX_PAT,
185 BREAK_EXPR,
186 CALL_EXPR,
187 CAST_EXPR,
188 CLOSURE_EXPR,
189 CONST,
190 CONST_ARG,
191 CONST_BLOCK_PAT,
192 CONST_PARAM,
193 CONTINUE_EXPR,
194 DYN_TRAIT_TYPE,
195 ENUM,
196 EXPR_STMT,
197 EXTERN_BLOCK,
198 EXTERN_CRATE,
199 EXTERN_ITEM_LIST,
200 FIELD_EXPR,
201 FN,
202 FN_PTR_TYPE,
203 FORMAT_ARGS_ARG,
204 FORMAT_ARGS_EXPR,
205 FOR_BINDER,
206 FOR_EXPR,
207 FOR_TYPE,
208 GENERIC_ARG_LIST,
209 GENERIC_PARAM_LIST,
210 IDENT_PAT,
211 IF_EXPR,
212 IMPL,
213 IMPL_TRAIT_TYPE,
214 INDEX_EXPR,
215 INFER_TYPE,
216 ITEM_LIST,
217 LABEL,
218 LET_ELSE,
219 LET_EXPR,
220 LET_STMT,
221 LIFETIME,
222 LIFETIME_ARG,
223 LIFETIME_PARAM,
224 LITERAL,
225 LITERAL_PAT,
226 LOOP_EXPR,
227 MACRO_CALL,
228 MACRO_DEF,
229 MACRO_EXPR,
230 MACRO_ITEMS,
231 MACRO_PAT,
232 MACRO_RULES,
233 MACRO_STMTS,
234 MACRO_TYPE,
235 MATCH_ARM,
236 MATCH_ARM_LIST,
237 MATCH_EXPR,
238 MATCH_GUARD,
239 META,
240 METHOD_CALL_EXPR,
241 MODULE,
242 NAME,
243 NAME_REF,
244 NEVER_TYPE,
245 OFFSET_OF_EXPR,
246 OR_PAT,
247 PARAM,
248 PARAM_LIST,
249 PARENTHESIZED_ARG_LIST,
250 PAREN_EXPR,
251 PAREN_PAT,
252 PAREN_TYPE,
253 PATH,
254 PATH_EXPR,
255 PATH_PAT,
256 PATH_SEGMENT,
257 PATH_TYPE,
258 PREFIX_EXPR,
259 PTR_TYPE,
260 RANGE_EXPR,
261 RANGE_PAT,
262 RECORD_EXPR,
263 RECORD_EXPR_FIELD,
264 RECORD_EXPR_FIELD_LIST,
265 RECORD_FIELD,
266 RECORD_FIELD_LIST,
267 RECORD_PAT,
268 RECORD_PAT_FIELD,
269 RECORD_PAT_FIELD_LIST,
270 REF_EXPR,
271 REF_PAT,
272 REF_TYPE,
273 RENAME,
274 REST_PAT,
275 RETURN_EXPR,
276 RETURN_TYPE_SYNTAX,
277 RET_TYPE,
278 SELF_PARAM,
279 SLICE_PAT,
280 SLICE_TYPE,
281 SOURCE_FILE,
282 STATIC,
283 STMT_LIST,
284 STRUCT,
285 TOKEN_TREE,
286 TRAIT,
287 TRY_EXPR,
288 TUPLE_EXPR,
289 TUPLE_FIELD,
290 TUPLE_FIELD_LIST,
291 TUPLE_PAT,
292 TUPLE_STRUCT_PAT,
293 TUPLE_TYPE,
294 TYPE_ALIAS,
295 TYPE_ANCHOR,
296 TYPE_ARG,
297 TYPE_BOUND,
298 TYPE_BOUND_LIST,
299 TYPE_PARAM,
300 UNDERSCORE_EXPR,
301 UNION,
302 USE,
303 USE_BOUND_GENERIC_ARGS,
304 USE_TREE,
305 USE_TREE_LIST,
306 VARIANT,
307 VARIANT_LIST,
308 VISIBILITY,
309 WHERE_CLAUSE,
310 WHERE_PRED,
311 WHILE_EXPR,
312 WILDCARD_PAT,
313 YEET_EXPR,
314 YIELD_EXPR,
315 #[doc(hidden)]
316 __LAST,
317}
318use self::SyntaxKind::*;
319impl SyntaxKind {
320 #[allow(unreachable_patterns)]
321 pub const fn text(self) -> &'static str {
322 match self {
323 TOMBSTONE
324 | EOF
325 | __LAST
326 | BYTE
327 | BYTE_STRING
328 | CHAR
329 | C_STRING
330 | FLOAT_NUMBER
331 | INT_NUMBER
332 | STRING
333 | ABI
334 | ARG_LIST
335 | ARRAY_EXPR
336 | ARRAY_TYPE
337 | ASM_CLOBBER_ABI
338 | ASM_CONST
339 | ASM_DIR_SPEC
340 | ASM_EXPR
341 | ASM_LABEL
342 | ASM_OPERAND_EXPR
343 | ASM_OPERAND_NAMED
344 | ASM_OPTION
345 | ASM_OPTIONS
346 | ASM_REG_OPERAND
347 | ASM_REG_SPEC
348 | ASM_SYM
349 | ASSOC_ITEM_LIST
350 | ASSOC_TYPE_ARG
351 | ATTR
352 | AWAIT_EXPR
353 | BECOME_EXPR
354 | BIN_EXPR
355 | BLOCK_EXPR
356 | BOX_PAT
357 | BREAK_EXPR
358 | CALL_EXPR
359 | CAST_EXPR
360 | CLOSURE_EXPR
361 | CONST
362 | CONST_ARG
363 | CONST_BLOCK_PAT
364 | CONST_PARAM
365 | CONTINUE_EXPR
366 | DYN_TRAIT_TYPE
367 | ENUM
368 | EXPR_STMT
369 | EXTERN_BLOCK
370 | EXTERN_CRATE
371 | EXTERN_ITEM_LIST
372 | FIELD_EXPR
373 | FN
374 | FN_PTR_TYPE
375 | FORMAT_ARGS_ARG
376 | FORMAT_ARGS_EXPR
377 | FOR_BINDER
378 | FOR_EXPR
379 | FOR_TYPE
380 | GENERIC_ARG_LIST
381 | GENERIC_PARAM_LIST
382 | IDENT_PAT
383 | IF_EXPR
384 | IMPL
385 | IMPL_TRAIT_TYPE
386 | INDEX_EXPR
387 | INFER_TYPE
388 | ITEM_LIST
389 | LABEL
390 | LET_ELSE
391 | LET_EXPR
392 | LET_STMT
393 | LIFETIME
394 | LIFETIME_ARG
395 | LIFETIME_PARAM
396 | LITERAL
397 | LITERAL_PAT
398 | LOOP_EXPR
399 | MACRO_CALL
400 | MACRO_DEF
401 | MACRO_EXPR
402 | MACRO_ITEMS
403 | MACRO_PAT
404 | MACRO_RULES
405 | MACRO_STMTS
406 | MACRO_TYPE
407 | MATCH_ARM
408 | MATCH_ARM_LIST
409 | MATCH_EXPR
410 | MATCH_GUARD
411 | META
412 | METHOD_CALL_EXPR
413 | MODULE
414 | NAME
415 | NAME_REF
416 | NEVER_TYPE
417 | OFFSET_OF_EXPR
418 | OR_PAT
419 | PARAM
420 | PARAM_LIST
421 | PARENTHESIZED_ARG_LIST
422 | PAREN_EXPR
423 | PAREN_PAT
424 | PAREN_TYPE
425 | PATH
426 | PATH_EXPR
427 | PATH_PAT
428 | PATH_SEGMENT
429 | PATH_TYPE
430 | PREFIX_EXPR
431 | PTR_TYPE
432 | RANGE_EXPR
433 | RANGE_PAT
434 | RECORD_EXPR
435 | RECORD_EXPR_FIELD
436 | RECORD_EXPR_FIELD_LIST
437 | RECORD_FIELD
438 | RECORD_FIELD_LIST
439 | RECORD_PAT
440 | RECORD_PAT_FIELD
441 | RECORD_PAT_FIELD_LIST
442 | REF_EXPR
443 | REF_PAT
444 | REF_TYPE
445 | RENAME
446 | REST_PAT
447 | RETURN_EXPR
448 | RETURN_TYPE_SYNTAX
449 | RET_TYPE
450 | SELF_PARAM
451 | SLICE_PAT
452 | SLICE_TYPE
453 | SOURCE_FILE
454 | STATIC
455 | STMT_LIST
456 | STRUCT
457 | TOKEN_TREE
458 | TRAIT
459 | TRY_EXPR
460 | TUPLE_EXPR
461 | TUPLE_FIELD
462 | TUPLE_FIELD_LIST
463 | TUPLE_PAT
464 | TUPLE_STRUCT_PAT
465 | TUPLE_TYPE
466 | TYPE_ALIAS
467 | TYPE_ANCHOR
468 | TYPE_ARG
469 | TYPE_BOUND
470 | TYPE_BOUND_LIST
471 | TYPE_PARAM
472 | UNDERSCORE_EXPR
473 | UNION
474 | USE
475 | USE_BOUND_GENERIC_ARGS
476 | USE_TREE
477 | USE_TREE_LIST
478 | VARIANT
479 | VARIANT_LIST
480 | VISIBILITY
481 | WHERE_CLAUSE
482 | WHERE_PRED
483 | WHILE_EXPR
484 | WILDCARD_PAT
485 | YEET_EXPR
486 | YIELD_EXPR
487 | COMMENT
488 | ERROR
489 | FRONTMATTER
490 | IDENT
491 | LIFETIME_IDENT
492 | NEWLINE
493 | SHEBANG
494 | WHITESPACE => panic!("no text for these `SyntaxKind`s"),
495 DOLLAR => "$",
496 SEMICOLON => ";",
497 COMMA => ",",
498 L_PAREN => "(",
499 R_PAREN => ")",
500 L_CURLY => "{",
501 R_CURLY => "}",
502 L_BRACK => "[",
503 R_BRACK => "]",
504 L_ANGLE => "<",
505 R_ANGLE => ">",
506 AT => "@",
507 POUND => "#",
508 TILDE => "~",
509 QUESTION => "?",
510 AMP => "&",
511 PIPE => "|",
512 PLUS => "+",
513 STAR => "*",
514 SLASH => "/",
515 CARET => "^",
516 PERCENT => "%",
517 UNDERSCORE => "_",
518 DOT => ".",
519 DOT2 => "..",
520 DOT3 => "...",
521 DOT2EQ => "..=",
522 COLON => ":",
523 COLON2 => "::",
524 EQ => "=",
525 EQ2 => "==",
526 FAT_ARROW => "=>",
527 BANG => "!",
528 NEQ => "!=",
529 MINUS => "-",
530 THIN_ARROW => "->",
531 LTEQ => "<=",
532 GTEQ => ">=",
533 PLUSEQ => "+=",
534 MINUSEQ => "-=",
535 PIPEEQ => "|=",
536 AMPEQ => "&=",
537 CARETEQ => "^=",
538 SLASHEQ => "/=",
539 STAREQ => "*=",
540 PERCENTEQ => "%=",
541 AMP2 => "&&",
542 PIPE2 => "||",
543 SHL => "<<",
544 SHR => ">>",
545 SHLEQ => "<<=",
546 SHREQ => ">>=",
547 SELF_TYPE_KW => "Self",
548 ABSTRACT_KW => "abstract",
549 AS_KW => "as",
550 BECOME_KW => "become",
551 BOX_KW => "box",
552 BREAK_KW => "break",
553 CONST_KW => "const",
554 CONTINUE_KW => "continue",
555 CRATE_KW => "crate",
556 DO_KW => "do",
557 ELSE_KW => "else",
558 ENUM_KW => "enum",
559 EXTERN_KW => "extern",
560 FALSE_KW => "false",
561 FINAL_KW => "final",
562 FN_KW => "fn",
563 FOR_KW => "for",
564 IF_KW => "if",
565 IMPL_KW => "impl",
566 IN_KW => "in",
567 LET_KW => "let",
568 LOOP_KW => "loop",
569 MACRO_KW => "macro",
570 MATCH_KW => "match",
571 MOD_KW => "mod",
572 MOVE_KW => "move",
573 MUT_KW => "mut",
574 OVERRIDE_KW => "override",
575 PRIV_KW => "priv",
576 PUB_KW => "pub",
577 REF_KW => "ref",
578 RETURN_KW => "return",
579 SELF_KW => "self",
580 STATIC_KW => "static",
581 STRUCT_KW => "struct",
582 SUPER_KW => "super",
583 TRAIT_KW => "trait",
584 TRUE_KW => "true",
585 TYPE_KW => "type",
586 TYPEOF_KW => "typeof",
587 UNSAFE_KW => "unsafe",
588 UNSIZED_KW => "unsized",
589 USE_KW => "use",
590 VIRTUAL_KW => "virtual",
591 WHERE_KW => "where",
592 WHILE_KW => "while",
593 YIELD_KW => "yield",
594 ASM_KW => "asm",
595 ATT_SYNTAX_KW => "att_syntax",
596 AUTO_KW => "auto",
597 BUILTIN_KW => "builtin",
598 CLOBBER_ABI_KW => "clobber_abi",
599 DEFAULT_KW => "default",
600 DYN_KW => "dyn",
601 FORMAT_ARGS_KW => "format_args",
602 GLOBAL_ASM_KW => "global_asm",
603 INLATEOUT_KW => "inlateout",
604 INOUT_KW => "inout",
605 LABEL_KW => "label",
606 LATEOUT_KW => "lateout",
607 MACRO_RULES_KW => "macro_rules",
608 MAY_UNWIND_KW => "may_unwind",
609 NAKED_ASM_KW => "naked_asm",
610 NOMEM_KW => "nomem",
611 NORETURN_KW => "noreturn",
612 NOSTACK_KW => "nostack",
613 OFFSET_OF_KW => "offset_of",
614 OPTIONS_KW => "options",
615 OUT_KW => "out",
616 PRESERVES_FLAGS_KW => "preserves_flags",
617 PURE_KW => "pure",
618 RAW_KW => "raw",
619 READONLY_KW => "readonly",
620 SAFE_KW => "safe",
621 SYM_KW => "sym",
622 UNION_KW => "union",
623 YEET_KW => "yeet",
624 ASYNC_KW => "async",
625 AWAIT_KW => "await",
626 DYN_KW => "dyn",
627 GEN_KW => "gen",
628 TRY_KW => "try",
629 }
630 }
631 #[doc = r" Checks whether this syntax kind is a strict keyword for the given edition."]
632 #[doc = r" Strict keywords are identifiers that are always considered keywords."]
633 pub fn is_strict_keyword(self, edition: Edition) -> bool {
634 matches!(
635 self,
636 SELF_TYPE_KW
637 | ABSTRACT_KW
638 | AS_KW
639 | BECOME_KW
640 | BOX_KW
641 | BREAK_KW
642 | CONST_KW
643 | CONTINUE_KW
644 | CRATE_KW
645 | DO_KW
646 | ELSE_KW
647 | ENUM_KW
648 | EXTERN_KW
649 | FALSE_KW
650 | FINAL_KW
651 | FN_KW
652 | FOR_KW
653 | IF_KW
654 | IMPL_KW
655 | IN_KW
656 | LET_KW
657 | LOOP_KW
658 | MACRO_KW
659 | MATCH_KW
660 | MOD_KW
661 | MOVE_KW
662 | MUT_KW
663 | OVERRIDE_KW
664 | PRIV_KW
665 | PUB_KW
666 | REF_KW
667 | RETURN_KW
668 | SELF_KW
669 | STATIC_KW
670 | STRUCT_KW
671 | SUPER_KW
672 | TRAIT_KW
673 | TRUE_KW
674 | TYPE_KW
675 | TYPEOF_KW
676 | UNSAFE_KW
677 | UNSIZED_KW
678 | USE_KW
679 | VIRTUAL_KW
680 | WHERE_KW
681 | WHILE_KW
682 | YIELD_KW
683 ) || match self {
684 ASYNC_KW if Edition::Edition2018 <= edition => true,
685 AWAIT_KW if Edition::Edition2018 <= edition => true,
686 DYN_KW if Edition::Edition2018 <= edition => true,
687 GEN_KW if Edition::Edition2024 <= edition => true,
688 TRY_KW if Edition::Edition2018 <= edition => true,
689 _ => false,
690 }
691 }
692 #[doc = r" Checks whether this syntax kind is a weak keyword for the given edition."]
693 #[doc = r" Weak keywords are identifiers that are considered keywords only in certain contexts."]
694 pub fn is_contextual_keyword(self, edition: Edition) -> bool {
695 match self {
696 ASM_KW => true,
697 ATT_SYNTAX_KW => true,
698 AUTO_KW => true,
699 BUILTIN_KW => true,
700 CLOBBER_ABI_KW => true,
701 DEFAULT_KW => true,
702 DYN_KW if edition < Edition::Edition2018 => true,
703 FORMAT_ARGS_KW => true,
704 GLOBAL_ASM_KW => true,
705 INLATEOUT_KW => true,
706 INOUT_KW => true,
707 LABEL_KW => true,
708 LATEOUT_KW => true,
709 MACRO_RULES_KW => true,
710 MAY_UNWIND_KW => true,
711 NAKED_ASM_KW => true,
712 NOMEM_KW => true,
713 NORETURN_KW => true,
714 NOSTACK_KW => true,
715 OFFSET_OF_KW => true,
716 OPTIONS_KW => true,
717 OUT_KW => true,
718 PRESERVES_FLAGS_KW => true,
719 PURE_KW => true,
720 RAW_KW => true,
721 READONLY_KW => true,
722 SAFE_KW => true,
723 SYM_KW => true,
724 UNION_KW => true,
725 YEET_KW => true,
726 _ => false,
727 }
728 }
729 #[doc = r" Checks whether this syntax kind is a strict or weak keyword for the given edition."]
730 pub fn is_keyword(self, edition: Edition) -> bool {
731 matches!(
732 self,
733 SELF_TYPE_KW
734 | ABSTRACT_KW
735 | AS_KW
736 | BECOME_KW
737 | BOX_KW
738 | BREAK_KW
739 | CONST_KW
740 | CONTINUE_KW
741 | CRATE_KW
742 | DO_KW
743 | ELSE_KW
744 | ENUM_KW
745 | EXTERN_KW
746 | FALSE_KW
747 | FINAL_KW
748 | FN_KW
749 | FOR_KW
750 | IF_KW
751 | IMPL_KW
752 | IN_KW
753 | LET_KW
754 | LOOP_KW
755 | MACRO_KW
756 | MATCH_KW
757 | MOD_KW
758 | MOVE_KW
759 | MUT_KW
760 | OVERRIDE_KW
761 | PRIV_KW
762 | PUB_KW
763 | REF_KW
764 | RETURN_KW
765 | SELF_KW
766 | STATIC_KW
767 | STRUCT_KW
768 | SUPER_KW
769 | TRAIT_KW
770 | TRUE_KW
771 | TYPE_KW
772 | TYPEOF_KW
773 | UNSAFE_KW
774 | UNSIZED_KW
775 | USE_KW
776 | VIRTUAL_KW
777 | WHERE_KW
778 | WHILE_KW
779 | YIELD_KW
780 ) || match self {
781 ASYNC_KW if Edition::Edition2018 <= edition => true,
782 AWAIT_KW if Edition::Edition2018 <= edition => true,
783 DYN_KW if Edition::Edition2018 <= edition => true,
784 GEN_KW if Edition::Edition2024 <= edition => true,
785 TRY_KW if Edition::Edition2018 <= edition => true,
786 ASM_KW => true,
787 ATT_SYNTAX_KW => true,
788 AUTO_KW => true,
789 BUILTIN_KW => true,
790 CLOBBER_ABI_KW => true,
791 DEFAULT_KW => true,
792 DYN_KW if edition < Edition::Edition2018 => true,
793 FORMAT_ARGS_KW => true,
794 GLOBAL_ASM_KW => true,
795 INLATEOUT_KW => true,
796 INOUT_KW => true,
797 LABEL_KW => true,
798 LATEOUT_KW => true,
799 MACRO_RULES_KW => true,
800 MAY_UNWIND_KW => true,
801 NAKED_ASM_KW => true,
802 NOMEM_KW => true,
803 NORETURN_KW => true,
804 NOSTACK_KW => true,
805 OFFSET_OF_KW => true,
806 OPTIONS_KW => true,
807 OUT_KW => true,
808 PRESERVES_FLAGS_KW => true,
809 PURE_KW => true,
810 RAW_KW => true,
811 READONLY_KW => true,
812 SAFE_KW => true,
813 SYM_KW => true,
814 UNION_KW => true,
815 YEET_KW => true,
816 _ => false,
817 }
818 }
819 pub fn is_punct(self) -> bool {
820 matches!(
821 self,
822 DOLLAR
823 | SEMICOLON
824 | COMMA
825 | L_PAREN
826 | R_PAREN
827 | L_CURLY
828 | R_CURLY
829 | L_BRACK
830 | R_BRACK
831 | L_ANGLE
832 | R_ANGLE
833 | AT
834 | POUND
835 | TILDE
836 | QUESTION
837 | AMP
838 | PIPE
839 | PLUS
840 | STAR
841 | SLASH
842 | CARET
843 | PERCENT
844 | UNDERSCORE
845 | DOT
846 | DOT2
847 | DOT3
848 | DOT2EQ
849 | COLON
850 | COLON2
851 | EQ
852 | EQ2
853 | FAT_ARROW
854 | BANG
855 | NEQ
856 | MINUS
857 | THIN_ARROW
858 | LTEQ
859 | GTEQ
860 | PLUSEQ
861 | MINUSEQ
862 | PIPEEQ
863 | AMPEQ
864 | CARETEQ
865 | SLASHEQ
866 | STAREQ
867 | PERCENTEQ
868 | AMP2
869 | PIPE2
870 | SHL
871 | SHR
872 | SHLEQ
873 | SHREQ
874 )
875 }
876 pub fn is_literal(self) -> bool {
877 matches!(self, BYTE | BYTE_STRING | CHAR | C_STRING | FLOAT_NUMBER | INT_NUMBER | STRING)
878 }
879 pub fn from_keyword(ident: &str, edition: Edition) -> Option<SyntaxKind> {
880 let kw = match ident {
881 "Self" => SELF_TYPE_KW,
882 "abstract" => ABSTRACT_KW,
883 "as" => AS_KW,
884 "become" => BECOME_KW,
885 "box" => BOX_KW,
886 "break" => BREAK_KW,
887 "const" => CONST_KW,
888 "continue" => CONTINUE_KW,
889 "crate" => CRATE_KW,
890 "do" => DO_KW,
891 "else" => ELSE_KW,
892 "enum" => ENUM_KW,
893 "extern" => EXTERN_KW,
894 "false" => FALSE_KW,
895 "final" => FINAL_KW,
896 "fn" => FN_KW,
897 "for" => FOR_KW,
898 "if" => IF_KW,
899 "impl" => IMPL_KW,
900 "in" => IN_KW,
901 "let" => LET_KW,
902 "loop" => LOOP_KW,
903 "macro" => MACRO_KW,
904 "match" => MATCH_KW,
905 "mod" => MOD_KW,
906 "move" => MOVE_KW,
907 "mut" => MUT_KW,
908 "override" => OVERRIDE_KW,
909 "priv" => PRIV_KW,
910 "pub" => PUB_KW,
911 "ref" => REF_KW,
912 "return" => RETURN_KW,
913 "self" => SELF_KW,
914 "static" => STATIC_KW,
915 "struct" => STRUCT_KW,
916 "super" => SUPER_KW,
917 "trait" => TRAIT_KW,
918 "true" => TRUE_KW,
919 "type" => TYPE_KW,
920 "typeof" => TYPEOF_KW,
921 "unsafe" => UNSAFE_KW,
922 "unsized" => UNSIZED_KW,
923 "use" => USE_KW,
924 "virtual" => VIRTUAL_KW,
925 "where" => WHERE_KW,
926 "while" => WHILE_KW,
927 "yield" => YIELD_KW,
928 "async" if Edition::Edition2018 <= edition => ASYNC_KW,
929 "await" if Edition::Edition2018 <= edition => AWAIT_KW,
930 "dyn" if Edition::Edition2018 <= edition => DYN_KW,
931 "gen" if Edition::Edition2024 <= edition => GEN_KW,
932 "try" if Edition::Edition2018 <= edition => TRY_KW,
933 _ => return None,
934 };
935 Some(kw)
936 }
937 pub fn from_contextual_keyword(ident: &str, edition: Edition) -> Option<SyntaxKind> {
938 let kw = match ident {
939 "asm" => ASM_KW,
940 "att_syntax" => ATT_SYNTAX_KW,
941 "auto" => AUTO_KW,
942 "builtin" => BUILTIN_KW,
943 "clobber_abi" => CLOBBER_ABI_KW,
944 "default" => DEFAULT_KW,
945 "dyn" if edition < Edition::Edition2018 => DYN_KW,
946 "format_args" => FORMAT_ARGS_KW,
947 "global_asm" => GLOBAL_ASM_KW,
948 "inlateout" => INLATEOUT_KW,
949 "inout" => INOUT_KW,
950 "label" => LABEL_KW,
951 "lateout" => LATEOUT_KW,
952 "macro_rules" => MACRO_RULES_KW,
953 "may_unwind" => MAY_UNWIND_KW,
954 "naked_asm" => NAKED_ASM_KW,
955 "nomem" => NOMEM_KW,
956 "noreturn" => NORETURN_KW,
957 "nostack" => NOSTACK_KW,
958 "offset_of" => OFFSET_OF_KW,
959 "options" => OPTIONS_KW,
960 "out" => OUT_KW,
961 "preserves_flags" => PRESERVES_FLAGS_KW,
962 "pure" => PURE_KW,
963 "raw" => RAW_KW,
964 "readonly" => READONLY_KW,
965 "safe" => SAFE_KW,
966 "sym" => SYM_KW,
967 "union" => UNION_KW,
968 "yeet" => YEET_KW,
969 _ => return None,
970 };
971 Some(kw)
972 }
973 pub fn from_char(c: char) -> Option<SyntaxKind> {
974 let tok = match c {
975 '$' => DOLLAR,
976 ';' => SEMICOLON,
977 ',' => COMMA,
978 '(' => L_PAREN,
979 ')' => R_PAREN,
980 '{' => L_CURLY,
981 '}' => R_CURLY,
982 '[' => L_BRACK,
983 ']' => R_BRACK,
984 '<' => L_ANGLE,
985 '>' => R_ANGLE,
986 '@' => AT,
987 '#' => POUND,
988 '~' => TILDE,
989 '?' => QUESTION,
990 '&' => AMP,
991 '|' => PIPE,
992 '+' => PLUS,
993 '*' => STAR,
994 '/' => SLASH,
995 '^' => CARET,
996 '%' => PERCENT,
997 '_' => UNDERSCORE,
998 '.' => DOT,
999 ':' => COLON,
1000 '=' => EQ,
1001 '!' => BANG,
1002 '-' => MINUS,
1003 _ => return None,
1004 };
1005 Some(tok)
1006 }
1007}
1008#[macro_export]
1009macro_rules ! T_ {
1010 [$] => { $ crate :: SyntaxKind :: DOLLAR };
1011 [;] => { $ crate :: SyntaxKind :: SEMICOLON };
1012 [,] => { $ crate :: SyntaxKind :: COMMA };
1013 ['('] => { $ crate :: SyntaxKind :: L_PAREN };
1014 [')'] => { $ crate :: SyntaxKind :: R_PAREN };
1015 ['{'] => { $ crate :: SyntaxKind :: L_CURLY };
1016 ['}'] => { $ crate :: SyntaxKind :: R_CURLY };
1017 ['['] => { $ crate :: SyntaxKind :: L_BRACK };
1018 [']'] => { $ crate :: SyntaxKind :: R_BRACK };
1019 [<] => { $ crate :: SyntaxKind :: L_ANGLE };
1020 [>] => { $ crate :: SyntaxKind :: R_ANGLE };
1021 [@] => { $ crate :: SyntaxKind :: AT };
1022 [#] => { $ crate :: SyntaxKind :: POUND };
1023 [~] => { $ crate :: SyntaxKind :: TILDE };
1024 [?] => { $ crate :: SyntaxKind :: QUESTION };
1025 [&] => { $ crate :: SyntaxKind :: AMP };
1026 [|] => { $ crate :: SyntaxKind :: PIPE };
1027 [+] => { $ crate :: SyntaxKind :: PLUS };
1028 [*] => { $ crate :: SyntaxKind :: STAR };
1029 [/] => { $ crate :: SyntaxKind :: SLASH };
1030 [^] => { $ crate :: SyntaxKind :: CARET };
1031 [%] => { $ crate :: SyntaxKind :: PERCENT };
1032 [_] => { $ crate :: SyntaxKind :: UNDERSCORE };
1033 [.] => { $ crate :: SyntaxKind :: DOT };
1034 [..] => { $ crate :: SyntaxKind :: DOT2 };
1035 [...] => { $ crate :: SyntaxKind :: DOT3 };
1036 [..=] => { $ crate :: SyntaxKind :: DOT2EQ };
1037 [:] => { $ crate :: SyntaxKind :: COLON };
1038 [::] => { $ crate :: SyntaxKind :: COLON2 };
1039 [=] => { $ crate :: SyntaxKind :: EQ };
1040 [==] => { $ crate :: SyntaxKind :: EQ2 };
1041 [=>] => { $ crate :: SyntaxKind :: FAT_ARROW };
1042 [!] => { $ crate :: SyntaxKind :: BANG };
1043 [!=] => { $ crate :: SyntaxKind :: NEQ };
1044 [-] => { $ crate :: SyntaxKind :: MINUS };
1045 [->] => { $ crate :: SyntaxKind :: THIN_ARROW };
1046 [<=] => { $ crate :: SyntaxKind :: LTEQ };
1047 [>=] => { $ crate :: SyntaxKind :: GTEQ };
1048 [+=] => { $ crate :: SyntaxKind :: PLUSEQ };
1049 [-=] => { $ crate :: SyntaxKind :: MINUSEQ };
1050 [|=] => { $ crate :: SyntaxKind :: PIPEEQ };
1051 [&=] => { $ crate :: SyntaxKind :: AMPEQ };
1052 [^=] => { $ crate :: SyntaxKind :: CARETEQ };
1053 [/=] => { $ crate :: SyntaxKind :: SLASHEQ };
1054 [*=] => { $ crate :: SyntaxKind :: STAREQ };
1055 [%=] => { $ crate :: SyntaxKind :: PERCENTEQ };
1056 [&&] => { $ crate :: SyntaxKind :: AMP2 };
1057 [||] => { $ crate :: SyntaxKind :: PIPE2 };
1058 [<<] => { $ crate :: SyntaxKind :: SHL };
1059 [>>] => { $ crate :: SyntaxKind :: SHR };
1060 [<<=] => { $ crate :: SyntaxKind :: SHLEQ };
1061 [>>=] => { $ crate :: SyntaxKind :: SHREQ };
1062 [Self] => { $ crate :: SyntaxKind :: SELF_TYPE_KW };
1063 [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW };
1064 [as] => { $ crate :: SyntaxKind :: AS_KW };
1065 [become] => { $ crate :: SyntaxKind :: BECOME_KW };
1066 [box] => { $ crate :: SyntaxKind :: BOX_KW };
1067 [break] => { $ crate :: SyntaxKind :: BREAK_KW };
1068 [const] => { $ crate :: SyntaxKind :: CONST_KW };
1069 [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW };
1070 [crate] => { $ crate :: SyntaxKind :: CRATE_KW };
1071 [do] => { $ crate :: SyntaxKind :: DO_KW };
1072 [else] => { $ crate :: SyntaxKind :: ELSE_KW };
1073 [enum] => { $ crate :: SyntaxKind :: ENUM_KW };
1074 [extern] => { $ crate :: SyntaxKind :: EXTERN_KW };
1075 [false] => { $ crate :: SyntaxKind :: FALSE_KW };
1076 [final] => { $ crate :: SyntaxKind :: FINAL_KW };
1077 [fn] => { $ crate :: SyntaxKind :: FN_KW };
1078 [for] => { $ crate :: SyntaxKind :: FOR_KW };
1079 [if] => { $ crate :: SyntaxKind :: IF_KW };
1080 [impl] => { $ crate :: SyntaxKind :: IMPL_KW };
1081 [in] => { $ crate :: SyntaxKind :: IN_KW };
1082 [let] => { $ crate :: SyntaxKind :: LET_KW };
1083 [loop] => { $ crate :: SyntaxKind :: LOOP_KW };
1084 [macro] => { $ crate :: SyntaxKind :: MACRO_KW };
1085 [match] => { $ crate :: SyntaxKind :: MATCH_KW };
1086 [mod] => { $ crate :: SyntaxKind :: MOD_KW };
1087 [move] => { $ crate :: SyntaxKind :: MOVE_KW };
1088 [mut] => { $ crate :: SyntaxKind :: MUT_KW };
1089 [override] => { $ crate :: SyntaxKind :: OVERRIDE_KW };
1090 [priv] => { $ crate :: SyntaxKind :: PRIV_KW };
1091 [pub] => { $ crate :: SyntaxKind :: PUB_KW };
1092 [ref] => { $ crate :: SyntaxKind :: REF_KW };
1093 [return] => { $ crate :: SyntaxKind :: RETURN_KW };
1094 [self] => { $ crate :: SyntaxKind :: SELF_KW };
1095 [static] => { $ crate :: SyntaxKind :: STATIC_KW };
1096 [struct] => { $ crate :: SyntaxKind :: STRUCT_KW };
1097 [super] => { $ crate :: SyntaxKind :: SUPER_KW };
1098 [trait] => { $ crate :: SyntaxKind :: TRAIT_KW };
1099 [true] => { $ crate :: SyntaxKind :: TRUE_KW };
1100 [type] => { $ crate :: SyntaxKind :: TYPE_KW };
1101 [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW };
1102 [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW };
1103 [unsized] => { $ crate :: SyntaxKind :: UNSIZED_KW };
1104 [use] => { $ crate :: SyntaxKind :: USE_KW };
1105 [virtual] => { $ crate :: SyntaxKind :: VIRTUAL_KW };
1106 [where] => { $ crate :: SyntaxKind :: WHERE_KW };
1107 [while] => { $ crate :: SyntaxKind :: WHILE_KW };
1108 [yield] => { $ crate :: SyntaxKind :: YIELD_KW };
1109 [asm] => { $ crate :: SyntaxKind :: ASM_KW };
1110 [att_syntax] => { $ crate :: SyntaxKind :: ATT_SYNTAX_KW };
1111 [auto] => { $ crate :: SyntaxKind :: AUTO_KW };
1112 [builtin] => { $ crate :: SyntaxKind :: BUILTIN_KW };
1113 [clobber_abi] => { $ crate :: SyntaxKind :: CLOBBER_ABI_KW };
1114 [default] => { $ crate :: SyntaxKind :: DEFAULT_KW };
1115 [dyn] => { $ crate :: SyntaxKind :: DYN_KW };
1116 [format_args] => { $ crate :: SyntaxKind :: FORMAT_ARGS_KW };
1117 [global_asm] => { $ crate :: SyntaxKind :: GLOBAL_ASM_KW };
1118 [inlateout] => { $ crate :: SyntaxKind :: INLATEOUT_KW };
1119 [inout] => { $ crate :: SyntaxKind :: INOUT_KW };
1120 [label] => { $ crate :: SyntaxKind :: LABEL_KW };
1121 [lateout] => { $ crate :: SyntaxKind :: LATEOUT_KW };
1122 [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW };
1123 [may_unwind] => { $ crate :: SyntaxKind :: MAY_UNWIND_KW };
1124 [naked_asm] => { $ crate :: SyntaxKind :: NAKED_ASM_KW };
1125 [nomem] => { $ crate :: SyntaxKind :: NOMEM_KW };
1126 [noreturn] => { $ crate :: SyntaxKind :: NORETURN_KW };
1127 [nostack] => { $ crate :: SyntaxKind :: NOSTACK_KW };
1128 [offset_of] => { $ crate :: SyntaxKind :: OFFSET_OF_KW };
1129 [options] => { $ crate :: SyntaxKind :: OPTIONS_KW };
1130 [out] => { $ crate :: SyntaxKind :: OUT_KW };
1131 [preserves_flags] => { $ crate :: SyntaxKind :: PRESERVES_FLAGS_KW };
1132 [pure] => { $ crate :: SyntaxKind :: PURE_KW };
1133 [raw] => { $ crate :: SyntaxKind :: RAW_KW };
1134 [readonly] => { $ crate :: SyntaxKind :: READONLY_KW };
1135 [safe] => { $ crate :: SyntaxKind :: SAFE_KW };
1136 [sym] => { $ crate :: SyntaxKind :: SYM_KW };
1137 [union] => { $ crate :: SyntaxKind :: UNION_KW };
1138 [yeet] => { $ crate :: SyntaxKind :: YEET_KW };
1139 [async] => { $ crate :: SyntaxKind :: ASYNC_KW };
1140 [await] => { $ crate :: SyntaxKind :: AWAIT_KW };
1141 [dyn] => { $ crate :: SyntaxKind :: DYN_KW };
1142 [gen] => { $ crate :: SyntaxKind :: GEN_KW };
1143 [try] => { $ crate :: SyntaxKind :: TRY_KW };
1144 [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT };
1145 [int_number] => { $ crate :: SyntaxKind :: INT_NUMBER };
1146 [ident] => { $ crate :: SyntaxKind :: IDENT };
1147 [string] => { $ crate :: SyntaxKind :: STRING };
1148 [shebang] => { $ crate :: SyntaxKind :: SHEBANG };
1149 [frontmatter] => { $ crate :: SyntaxKind :: FRONTMATTER };
1150}
1151
1152impl ::core::marker::Copy for SyntaxKind {}
1153impl ::core::clone::Clone for SyntaxKind {
1154 #[inline]
1155 fn clone(&self) -> Self { *self }
1156}
1157impl ::core::cmp::PartialEq for SyntaxKind {
1158 #[inline]
1159 fn eq(&self, other: &Self) -> bool { (*self as u16) == (*other as u16) }
1160}
1161impl ::core::cmp::Eq for SyntaxKind {}
1162impl ::core::cmp::PartialOrd for SyntaxKind {
1163 #[inline]
1164 fn partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering> {
1165 Some(self.cmp(other))
1166 }
1167}
1168impl ::core::cmp::Ord for SyntaxKind {
1169 #[inline]
1170 fn cmp(&self, other: &Self) -> core::cmp::Ordering { (*self as u16).cmp(&(*other as u16)) }
1171}
1172impl ::core::hash::Hash for SyntaxKind {
1173 fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) {
1174 ::core::mem::discriminant(self).hash(state);
1175 }
1176}