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_BINDER,
189 CLOSURE_EXPR,
190 CONST,
191 CONST_ARG,
192 CONST_BLOCK_PAT,
193 CONST_PARAM,
194 CONTINUE_EXPR,
195 DYN_TRAIT_TYPE,
196 ENUM,
197 EXPR_STMT,
198 EXTERN_BLOCK,
199 EXTERN_CRATE,
200 EXTERN_ITEM_LIST,
201 FIELD_EXPR,
202 FN,
203 FN_PTR_TYPE,
204 FORMAT_ARGS_ARG,
205 FORMAT_ARGS_EXPR,
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 TRAIT_ALIAS,
288 TRY_EXPR,
289 TUPLE_EXPR,
290 TUPLE_FIELD,
291 TUPLE_FIELD_LIST,
292 TUPLE_PAT,
293 TUPLE_STRUCT_PAT,
294 TUPLE_TYPE,
295 TYPE_ALIAS,
296 TYPE_ANCHOR,
297 TYPE_ARG,
298 TYPE_BOUND,
299 TYPE_BOUND_LIST,
300 TYPE_PARAM,
301 UNDERSCORE_EXPR,
302 UNION,
303 USE,
304 USE_BOUND_GENERIC_ARGS,
305 USE_TREE,
306 USE_TREE_LIST,
307 VARIANT,
308 VARIANT_LIST,
309 VISIBILITY,
310 WHERE_CLAUSE,
311 WHERE_PRED,
312 WHILE_EXPR,
313 WILDCARD_PAT,
314 YEET_EXPR,
315 YIELD_EXPR,
316 #[doc(hidden)]
317 __LAST,
318}
319use self::SyntaxKind::*;
320impl SyntaxKind {
321 #[allow(unreachable_patterns)]
322 pub const fn text(self) -> &'static str {
323 match self {
324 TOMBSTONE
325 | EOF
326 | __LAST
327 | BYTE
328 | BYTE_STRING
329 | CHAR
330 | C_STRING
331 | FLOAT_NUMBER
332 | INT_NUMBER
333 | STRING
334 | ABI
335 | ARG_LIST
336 | ARRAY_EXPR
337 | ARRAY_TYPE
338 | ASM_CLOBBER_ABI
339 | ASM_CONST
340 | ASM_DIR_SPEC
341 | ASM_EXPR
342 | ASM_LABEL
343 | ASM_OPERAND_EXPR
344 | ASM_OPERAND_NAMED
345 | ASM_OPTION
346 | ASM_OPTIONS
347 | ASM_REG_OPERAND
348 | ASM_REG_SPEC
349 | ASM_SYM
350 | ASSOC_ITEM_LIST
351 | ASSOC_TYPE_ARG
352 | ATTR
353 | AWAIT_EXPR
354 | BECOME_EXPR
355 | BIN_EXPR
356 | BLOCK_EXPR
357 | BOX_PAT
358 | BREAK_EXPR
359 | CALL_EXPR
360 | CAST_EXPR
361 | CLOSURE_BINDER
362 | CLOSURE_EXPR
363 | CONST
364 | CONST_ARG
365 | CONST_BLOCK_PAT
366 | CONST_PARAM
367 | CONTINUE_EXPR
368 | DYN_TRAIT_TYPE
369 | ENUM
370 | EXPR_STMT
371 | EXTERN_BLOCK
372 | EXTERN_CRATE
373 | EXTERN_ITEM_LIST
374 | FIELD_EXPR
375 | FN
376 | FN_PTR_TYPE
377 | FORMAT_ARGS_ARG
378 | FORMAT_ARGS_EXPR
379 | FOR_EXPR
380 | FOR_TYPE
381 | GENERIC_ARG_LIST
382 | GENERIC_PARAM_LIST
383 | IDENT_PAT
384 | IF_EXPR
385 | IMPL
386 | IMPL_TRAIT_TYPE
387 | INDEX_EXPR
388 | INFER_TYPE
389 | ITEM_LIST
390 | LABEL
391 | LET_ELSE
392 | LET_EXPR
393 | LET_STMT
394 | LIFETIME
395 | LIFETIME_ARG
396 | LIFETIME_PARAM
397 | LITERAL
398 | LITERAL_PAT
399 | LOOP_EXPR
400 | MACRO_CALL
401 | MACRO_DEF
402 | MACRO_EXPR
403 | MACRO_ITEMS
404 | MACRO_PAT
405 | MACRO_RULES
406 | MACRO_STMTS
407 | MACRO_TYPE
408 | MATCH_ARM
409 | MATCH_ARM_LIST
410 | MATCH_EXPR
411 | MATCH_GUARD
412 | META
413 | METHOD_CALL_EXPR
414 | MODULE
415 | NAME
416 | NAME_REF
417 | NEVER_TYPE
418 | OFFSET_OF_EXPR
419 | OR_PAT
420 | PARAM
421 | PARAM_LIST
422 | PARENTHESIZED_ARG_LIST
423 | PAREN_EXPR
424 | PAREN_PAT
425 | PAREN_TYPE
426 | PATH
427 | PATH_EXPR
428 | PATH_PAT
429 | PATH_SEGMENT
430 | PATH_TYPE
431 | PREFIX_EXPR
432 | PTR_TYPE
433 | RANGE_EXPR
434 | RANGE_PAT
435 | RECORD_EXPR
436 | RECORD_EXPR_FIELD
437 | RECORD_EXPR_FIELD_LIST
438 | RECORD_FIELD
439 | RECORD_FIELD_LIST
440 | RECORD_PAT
441 | RECORD_PAT_FIELD
442 | RECORD_PAT_FIELD_LIST
443 | REF_EXPR
444 | REF_PAT
445 | REF_TYPE
446 | RENAME
447 | REST_PAT
448 | RETURN_EXPR
449 | RETURN_TYPE_SYNTAX
450 | RET_TYPE
451 | SELF_PARAM
452 | SLICE_PAT
453 | SLICE_TYPE
454 | SOURCE_FILE
455 | STATIC
456 | STMT_LIST
457 | STRUCT
458 | TOKEN_TREE
459 | TRAIT
460 | TRAIT_ALIAS
461 | TRY_EXPR
462 | TUPLE_EXPR
463 | TUPLE_FIELD
464 | TUPLE_FIELD_LIST
465 | TUPLE_PAT
466 | TUPLE_STRUCT_PAT
467 | TUPLE_TYPE
468 | TYPE_ALIAS
469 | TYPE_ANCHOR
470 | TYPE_ARG
471 | TYPE_BOUND
472 | TYPE_BOUND_LIST
473 | TYPE_PARAM
474 | UNDERSCORE_EXPR
475 | UNION
476 | USE
477 | USE_BOUND_GENERIC_ARGS
478 | USE_TREE
479 | USE_TREE_LIST
480 | VARIANT
481 | VARIANT_LIST
482 | VISIBILITY
483 | WHERE_CLAUSE
484 | WHERE_PRED
485 | WHILE_EXPR
486 | WILDCARD_PAT
487 | YEET_EXPR
488 | YIELD_EXPR
489 | COMMENT
490 | ERROR
491 | FRONTMATTER
492 | IDENT
493 | LIFETIME_IDENT
494 | NEWLINE
495 | SHEBANG
496 | WHITESPACE => panic!("no text for these `SyntaxKind`s"),
497 DOLLAR => "$",
498 SEMICOLON => ";",
499 COMMA => ",",
500 L_PAREN => "(",
501 R_PAREN => ")",
502 L_CURLY => "{",
503 R_CURLY => "}",
504 L_BRACK => "[",
505 R_BRACK => "]",
506 L_ANGLE => "<",
507 R_ANGLE => ">",
508 AT => "@",
509 POUND => "#",
510 TILDE => "~",
511 QUESTION => "?",
512 AMP => "&",
513 PIPE => "|",
514 PLUS => "+",
515 STAR => "*",
516 SLASH => "/",
517 CARET => "^",
518 PERCENT => "%",
519 UNDERSCORE => "_",
520 DOT => ".",
521 DOT2 => "..",
522 DOT3 => "...",
523 DOT2EQ => "..=",
524 COLON => ":",
525 COLON2 => "::",
526 EQ => "=",
527 EQ2 => "==",
528 FAT_ARROW => "=>",
529 BANG => "!",
530 NEQ => "!=",
531 MINUS => "-",
532 THIN_ARROW => "->",
533 LTEQ => "<=",
534 GTEQ => ">=",
535 PLUSEQ => "+=",
536 MINUSEQ => "-=",
537 PIPEEQ => "|=",
538 AMPEQ => "&=",
539 CARETEQ => "^=",
540 SLASHEQ => "/=",
541 STAREQ => "*=",
542 PERCENTEQ => "%=",
543 AMP2 => "&&",
544 PIPE2 => "||",
545 SHL => "<<",
546 SHR => ">>",
547 SHLEQ => "<<=",
548 SHREQ => ">>=",
549 SELF_TYPE_KW => "Self",
550 ABSTRACT_KW => "abstract",
551 AS_KW => "as",
552 BECOME_KW => "become",
553 BOX_KW => "box",
554 BREAK_KW => "break",
555 CONST_KW => "const",
556 CONTINUE_KW => "continue",
557 CRATE_KW => "crate",
558 DO_KW => "do",
559 ELSE_KW => "else",
560 ENUM_KW => "enum",
561 EXTERN_KW => "extern",
562 FALSE_KW => "false",
563 FINAL_KW => "final",
564 FN_KW => "fn",
565 FOR_KW => "for",
566 IF_KW => "if",
567 IMPL_KW => "impl",
568 IN_KW => "in",
569 LET_KW => "let",
570 LOOP_KW => "loop",
571 MACRO_KW => "macro",
572 MATCH_KW => "match",
573 MOD_KW => "mod",
574 MOVE_KW => "move",
575 MUT_KW => "mut",
576 OVERRIDE_KW => "override",
577 PRIV_KW => "priv",
578 PUB_KW => "pub",
579 REF_KW => "ref",
580 RETURN_KW => "return",
581 SELF_KW => "self",
582 STATIC_KW => "static",
583 STRUCT_KW => "struct",
584 SUPER_KW => "super",
585 TRAIT_KW => "trait",
586 TRUE_KW => "true",
587 TYPE_KW => "type",
588 TYPEOF_KW => "typeof",
589 UNSAFE_KW => "unsafe",
590 UNSIZED_KW => "unsized",
591 USE_KW => "use",
592 VIRTUAL_KW => "virtual",
593 WHERE_KW => "where",
594 WHILE_KW => "while",
595 YIELD_KW => "yield",
596 ASM_KW => "asm",
597 ATT_SYNTAX_KW => "att_syntax",
598 AUTO_KW => "auto",
599 BUILTIN_KW => "builtin",
600 CLOBBER_ABI_KW => "clobber_abi",
601 DEFAULT_KW => "default",
602 DYN_KW => "dyn",
603 FORMAT_ARGS_KW => "format_args",
604 GLOBAL_ASM_KW => "global_asm",
605 INLATEOUT_KW => "inlateout",
606 INOUT_KW => "inout",
607 LABEL_KW => "label",
608 LATEOUT_KW => "lateout",
609 MACRO_RULES_KW => "macro_rules",
610 MAY_UNWIND_KW => "may_unwind",
611 NAKED_ASM_KW => "naked_asm",
612 NOMEM_KW => "nomem",
613 NORETURN_KW => "noreturn",
614 NOSTACK_KW => "nostack",
615 OFFSET_OF_KW => "offset_of",
616 OPTIONS_KW => "options",
617 OUT_KW => "out",
618 PRESERVES_FLAGS_KW => "preserves_flags",
619 PURE_KW => "pure",
620 RAW_KW => "raw",
621 READONLY_KW => "readonly",
622 SAFE_KW => "safe",
623 SYM_KW => "sym",
624 UNION_KW => "union",
625 YEET_KW => "yeet",
626 ASYNC_KW => "async",
627 AWAIT_KW => "await",
628 DYN_KW => "dyn",
629 GEN_KW => "gen",
630 TRY_KW => "try",
631 }
632 }
633 #[doc = r" Checks whether this syntax kind is a strict keyword for the given edition."]
634 #[doc = r" Strict keywords are identifiers that are always considered keywords."]
635 pub fn is_strict_keyword(self, edition: Edition) -> bool {
636 matches!(
637 self,
638 SELF_TYPE_KW
639 | ABSTRACT_KW
640 | AS_KW
641 | BECOME_KW
642 | BOX_KW
643 | BREAK_KW
644 | CONST_KW
645 | CONTINUE_KW
646 | CRATE_KW
647 | DO_KW
648 | ELSE_KW
649 | ENUM_KW
650 | EXTERN_KW
651 | FALSE_KW
652 | FINAL_KW
653 | FN_KW
654 | FOR_KW
655 | IF_KW
656 | IMPL_KW
657 | IN_KW
658 | LET_KW
659 | LOOP_KW
660 | MACRO_KW
661 | MATCH_KW
662 | MOD_KW
663 | MOVE_KW
664 | MUT_KW
665 | OVERRIDE_KW
666 | PRIV_KW
667 | PUB_KW
668 | REF_KW
669 | RETURN_KW
670 | SELF_KW
671 | STATIC_KW
672 | STRUCT_KW
673 | SUPER_KW
674 | TRAIT_KW
675 | TRUE_KW
676 | TYPE_KW
677 | TYPEOF_KW
678 | UNSAFE_KW
679 | UNSIZED_KW
680 | USE_KW
681 | VIRTUAL_KW
682 | WHERE_KW
683 | WHILE_KW
684 | YIELD_KW
685 ) || match self {
686 ASYNC_KW if Edition::Edition2018 <= edition => true,
687 AWAIT_KW if Edition::Edition2018 <= edition => true,
688 DYN_KW if Edition::Edition2018 <= edition => true,
689 GEN_KW if Edition::Edition2024 <= edition => true,
690 TRY_KW if Edition::Edition2018 <= edition => true,
691 _ => false,
692 }
693 }
694 #[doc = r" Checks whether this syntax kind is a weak keyword for the given edition."]
695 #[doc = r" Weak keywords are identifiers that are considered keywords only in certain contexts."]
696 pub fn is_contextual_keyword(self, edition: Edition) -> bool {
697 match self {
698 ASM_KW => true,
699 ATT_SYNTAX_KW => true,
700 AUTO_KW => true,
701 BUILTIN_KW => true,
702 CLOBBER_ABI_KW => true,
703 DEFAULT_KW => true,
704 DYN_KW if edition < Edition::Edition2018 => true,
705 FORMAT_ARGS_KW => true,
706 GLOBAL_ASM_KW => true,
707 INLATEOUT_KW => true,
708 INOUT_KW => true,
709 LABEL_KW => true,
710 LATEOUT_KW => true,
711 MACRO_RULES_KW => true,
712 MAY_UNWIND_KW => true,
713 NAKED_ASM_KW => true,
714 NOMEM_KW => true,
715 NORETURN_KW => true,
716 NOSTACK_KW => true,
717 OFFSET_OF_KW => true,
718 OPTIONS_KW => true,
719 OUT_KW => true,
720 PRESERVES_FLAGS_KW => true,
721 PURE_KW => true,
722 RAW_KW => true,
723 READONLY_KW => true,
724 SAFE_KW => true,
725 SYM_KW => true,
726 UNION_KW => true,
727 YEET_KW => true,
728 _ => false,
729 }
730 }
731 #[doc = r" Checks whether this syntax kind is a strict or weak keyword for the given edition."]
732 pub fn is_keyword(self, edition: Edition) -> bool {
733 matches!(
734 self,
735 SELF_TYPE_KW
736 | ABSTRACT_KW
737 | AS_KW
738 | BECOME_KW
739 | BOX_KW
740 | BREAK_KW
741 | CONST_KW
742 | CONTINUE_KW
743 | CRATE_KW
744 | DO_KW
745 | ELSE_KW
746 | ENUM_KW
747 | EXTERN_KW
748 | FALSE_KW
749 | FINAL_KW
750 | FN_KW
751 | FOR_KW
752 | IF_KW
753 | IMPL_KW
754 | IN_KW
755 | LET_KW
756 | LOOP_KW
757 | MACRO_KW
758 | MATCH_KW
759 | MOD_KW
760 | MOVE_KW
761 | MUT_KW
762 | OVERRIDE_KW
763 | PRIV_KW
764 | PUB_KW
765 | REF_KW
766 | RETURN_KW
767 | SELF_KW
768 | STATIC_KW
769 | STRUCT_KW
770 | SUPER_KW
771 | TRAIT_KW
772 | TRUE_KW
773 | TYPE_KW
774 | TYPEOF_KW
775 | UNSAFE_KW
776 | UNSIZED_KW
777 | USE_KW
778 | VIRTUAL_KW
779 | WHERE_KW
780 | WHILE_KW
781 | YIELD_KW
782 ) || match self {
783 ASYNC_KW if Edition::Edition2018 <= edition => true,
784 AWAIT_KW if Edition::Edition2018 <= edition => true,
785 DYN_KW if Edition::Edition2018 <= edition => true,
786 GEN_KW if Edition::Edition2024 <= edition => true,
787 TRY_KW if Edition::Edition2018 <= edition => true,
788 ASM_KW => true,
789 ATT_SYNTAX_KW => true,
790 AUTO_KW => true,
791 BUILTIN_KW => true,
792 CLOBBER_ABI_KW => true,
793 DEFAULT_KW => true,
794 DYN_KW if edition < Edition::Edition2018 => true,
795 FORMAT_ARGS_KW => true,
796 GLOBAL_ASM_KW => true,
797 INLATEOUT_KW => true,
798 INOUT_KW => true,
799 LABEL_KW => true,
800 LATEOUT_KW => true,
801 MACRO_RULES_KW => true,
802 MAY_UNWIND_KW => true,
803 NAKED_ASM_KW => true,
804 NOMEM_KW => true,
805 NORETURN_KW => true,
806 NOSTACK_KW => true,
807 OFFSET_OF_KW => true,
808 OPTIONS_KW => true,
809 OUT_KW => true,
810 PRESERVES_FLAGS_KW => true,
811 PURE_KW => true,
812 RAW_KW => true,
813 READONLY_KW => true,
814 SAFE_KW => true,
815 SYM_KW => true,
816 UNION_KW => true,
817 YEET_KW => true,
818 _ => false,
819 }
820 }
821 pub fn is_punct(self) -> bool {
822 matches!(
823 self,
824 DOLLAR
825 | SEMICOLON
826 | COMMA
827 | L_PAREN
828 | R_PAREN
829 | L_CURLY
830 | R_CURLY
831 | L_BRACK
832 | R_BRACK
833 | L_ANGLE
834 | R_ANGLE
835 | AT
836 | POUND
837 | TILDE
838 | QUESTION
839 | AMP
840 | PIPE
841 | PLUS
842 | STAR
843 | SLASH
844 | CARET
845 | PERCENT
846 | UNDERSCORE
847 | DOT
848 | DOT2
849 | DOT3
850 | DOT2EQ
851 | COLON
852 | COLON2
853 | EQ
854 | EQ2
855 | FAT_ARROW
856 | BANG
857 | NEQ
858 | MINUS
859 | THIN_ARROW
860 | LTEQ
861 | GTEQ
862 | PLUSEQ
863 | MINUSEQ
864 | PIPEEQ
865 | AMPEQ
866 | CARETEQ
867 | SLASHEQ
868 | STAREQ
869 | PERCENTEQ
870 | AMP2
871 | PIPE2
872 | SHL
873 | SHR
874 | SHLEQ
875 | SHREQ
876 )
877 }
878 pub fn is_literal(self) -> bool {
879 matches!(self, BYTE | BYTE_STRING | CHAR | C_STRING | FLOAT_NUMBER | INT_NUMBER | STRING)
880 }
881 pub fn from_keyword(ident: &str, edition: Edition) -> Option<SyntaxKind> {
882 let kw = match ident {
883 "Self" => SELF_TYPE_KW,
884 "abstract" => ABSTRACT_KW,
885 "as" => AS_KW,
886 "become" => BECOME_KW,
887 "box" => BOX_KW,
888 "break" => BREAK_KW,
889 "const" => CONST_KW,
890 "continue" => CONTINUE_KW,
891 "crate" => CRATE_KW,
892 "do" => DO_KW,
893 "else" => ELSE_KW,
894 "enum" => ENUM_KW,
895 "extern" => EXTERN_KW,
896 "false" => FALSE_KW,
897 "final" => FINAL_KW,
898 "fn" => FN_KW,
899 "for" => FOR_KW,
900 "if" => IF_KW,
901 "impl" => IMPL_KW,
902 "in" => IN_KW,
903 "let" => LET_KW,
904 "loop" => LOOP_KW,
905 "macro" => MACRO_KW,
906 "match" => MATCH_KW,
907 "mod" => MOD_KW,
908 "move" => MOVE_KW,
909 "mut" => MUT_KW,
910 "override" => OVERRIDE_KW,
911 "priv" => PRIV_KW,
912 "pub" => PUB_KW,
913 "ref" => REF_KW,
914 "return" => RETURN_KW,
915 "self" => SELF_KW,
916 "static" => STATIC_KW,
917 "struct" => STRUCT_KW,
918 "super" => SUPER_KW,
919 "trait" => TRAIT_KW,
920 "true" => TRUE_KW,
921 "type" => TYPE_KW,
922 "typeof" => TYPEOF_KW,
923 "unsafe" => UNSAFE_KW,
924 "unsized" => UNSIZED_KW,
925 "use" => USE_KW,
926 "virtual" => VIRTUAL_KW,
927 "where" => WHERE_KW,
928 "while" => WHILE_KW,
929 "yield" => YIELD_KW,
930 "async" if Edition::Edition2018 <= edition => ASYNC_KW,
931 "await" if Edition::Edition2018 <= edition => AWAIT_KW,
932 "dyn" if Edition::Edition2018 <= edition => DYN_KW,
933 "gen" if Edition::Edition2024 <= edition => GEN_KW,
934 "try" if Edition::Edition2018 <= edition => TRY_KW,
935 _ => return None,
936 };
937 Some(kw)
938 }
939 pub fn from_contextual_keyword(ident: &str, edition: Edition) -> Option<SyntaxKind> {
940 let kw = match ident {
941 "asm" => ASM_KW,
942 "att_syntax" => ATT_SYNTAX_KW,
943 "auto" => AUTO_KW,
944 "builtin" => BUILTIN_KW,
945 "clobber_abi" => CLOBBER_ABI_KW,
946 "default" => DEFAULT_KW,
947 "dyn" if edition < Edition::Edition2018 => DYN_KW,
948 "format_args" => FORMAT_ARGS_KW,
949 "global_asm" => GLOBAL_ASM_KW,
950 "inlateout" => INLATEOUT_KW,
951 "inout" => INOUT_KW,
952 "label" => LABEL_KW,
953 "lateout" => LATEOUT_KW,
954 "macro_rules" => MACRO_RULES_KW,
955 "may_unwind" => MAY_UNWIND_KW,
956 "naked_asm" => NAKED_ASM_KW,
957 "nomem" => NOMEM_KW,
958 "noreturn" => NORETURN_KW,
959 "nostack" => NOSTACK_KW,
960 "offset_of" => OFFSET_OF_KW,
961 "options" => OPTIONS_KW,
962 "out" => OUT_KW,
963 "preserves_flags" => PRESERVES_FLAGS_KW,
964 "pure" => PURE_KW,
965 "raw" => RAW_KW,
966 "readonly" => READONLY_KW,
967 "safe" => SAFE_KW,
968 "sym" => SYM_KW,
969 "union" => UNION_KW,
970 "yeet" => YEET_KW,
971 _ => return None,
972 };
973 Some(kw)
974 }
975 pub fn from_char(c: char) -> Option<SyntaxKind> {
976 let tok = match c {
977 '$' => DOLLAR,
978 ';' => SEMICOLON,
979 ',' => COMMA,
980 '(' => L_PAREN,
981 ')' => R_PAREN,
982 '{' => L_CURLY,
983 '}' => R_CURLY,
984 '[' => L_BRACK,
985 ']' => R_BRACK,
986 '<' => L_ANGLE,
987 '>' => R_ANGLE,
988 '@' => AT,
989 '#' => POUND,
990 '~' => TILDE,
991 '?' => QUESTION,
992 '&' => AMP,
993 '|' => PIPE,
994 '+' => PLUS,
995 '*' => STAR,
996 '/' => SLASH,
997 '^' => CARET,
998 '%' => PERCENT,
999 '_' => UNDERSCORE,
1000 '.' => DOT,
1001 ':' => COLON,
1002 '=' => EQ,
1003 '!' => BANG,
1004 '-' => MINUS,
1005 _ => return None,
1006 };
1007 Some(tok)
1008 }
1009}
1010#[macro_export]
1011macro_rules ! T_ { [$] => { $ crate :: SyntaxKind :: DOLLAR } ; [;] => { $ crate :: SyntaxKind :: SEMICOLON } ; [,] => { $ crate :: SyntaxKind :: COMMA } ; ['('] => { $ crate :: SyntaxKind :: L_PAREN } ; [')'] => { $ crate :: SyntaxKind :: R_PAREN } ; ['{'] => { $ crate :: SyntaxKind :: L_CURLY } ; ['}'] => { $ crate :: SyntaxKind :: R_CURLY } ; ['['] => { $ crate :: SyntaxKind :: L_BRACK } ; [']'] => { $ crate :: SyntaxKind :: R_BRACK } ; [<] => { $ crate :: SyntaxKind :: L_ANGLE } ; [>] => { $ crate :: SyntaxKind :: R_ANGLE } ; [@] => { $ crate :: SyntaxKind :: AT } ; [#] => { $ crate :: SyntaxKind :: POUND } ; [~] => { $ crate :: SyntaxKind :: TILDE } ; [?] => { $ crate :: SyntaxKind :: QUESTION } ; [&] => { $ crate :: SyntaxKind :: AMP } ; [|] => { $ crate :: SyntaxKind :: PIPE } ; [+] => { $ crate :: SyntaxKind :: PLUS } ; [*] => { $ crate :: SyntaxKind :: STAR } ; [/] => { $ crate :: SyntaxKind :: SLASH } ; [^] => { $ crate :: SyntaxKind :: CARET } ; [%] => { $ crate :: SyntaxKind :: PERCENT } ; [_] => { $ crate :: SyntaxKind :: UNDERSCORE } ; [.] => { $ crate :: SyntaxKind :: DOT } ; [..] => { $ crate :: SyntaxKind :: DOT2 } ; [...] => { $ crate :: SyntaxKind :: DOT3 } ; [..=] => { $ crate :: SyntaxKind :: DOT2EQ } ; [:] => { $ crate :: SyntaxKind :: COLON } ; [::] => { $ crate :: SyntaxKind :: COLON2 } ; [=] => { $ crate :: SyntaxKind :: EQ } ; [==] => { $ crate :: SyntaxKind :: EQ2 } ; [=>] => { $ crate :: SyntaxKind :: FAT_ARROW } ; [!] => { $ crate :: SyntaxKind :: BANG } ; [!=] => { $ crate :: SyntaxKind :: NEQ } ; [-] => { $ crate :: SyntaxKind :: MINUS } ; [->] => { $ crate :: SyntaxKind :: THIN_ARROW } ; [<=] => { $ crate :: SyntaxKind :: LTEQ } ; [>=] => { $ crate :: SyntaxKind :: GTEQ } ; [+=] => { $ crate :: SyntaxKind :: PLUSEQ } ; [-=] => { $ crate :: SyntaxKind :: MINUSEQ } ; [|=] => { $ crate :: SyntaxKind :: PIPEEQ } ; [&=] => { $ crate :: SyntaxKind :: AMPEQ } ; [^=] => { $ crate :: SyntaxKind :: CARETEQ } ; [/=] => { $ crate :: SyntaxKind :: SLASHEQ } ; [*=] => { $ crate :: SyntaxKind :: STAREQ } ; [%=] => { $ crate :: SyntaxKind :: PERCENTEQ } ; [&&] => { $ crate :: SyntaxKind :: AMP2 } ; [||] => { $ crate :: SyntaxKind :: PIPE2 } ; [<<] => { $ crate :: SyntaxKind :: SHL } ; [>>] => { $ crate :: SyntaxKind :: SHR } ; [<<=] => { $ crate :: SyntaxKind :: SHLEQ } ; [>>=] => { $ crate :: SyntaxKind :: SHREQ } ; [Self] => { $ crate :: SyntaxKind :: SELF_TYPE_KW } ; [abstract] => { $ crate :: SyntaxKind :: ABSTRACT_KW } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [become] => { $ crate :: SyntaxKind :: BECOME_KW } ; [box] => { $ crate :: SyntaxKind :: BOX_KW } ; [break] => { $ crate :: SyntaxKind :: BREAK_KW } ; [const] => { $ crate :: SyntaxKind :: CONST_KW } ; [continue] => { $ crate :: SyntaxKind :: CONTINUE_KW } ; [crate] => { $ crate :: SyntaxKind :: CRATE_KW } ; [do] => { $ crate :: SyntaxKind :: DO_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_KW } ; [final] => { $ crate :: SyntaxKind :: FINAL_KW } ; [fn] => { $ crate :: SyntaxKind :: FN_KW } ; [for] => { $ crate :: SyntaxKind :: FOR_KW } ; [if] => { $ crate :: SyntaxKind :: IF_KW } ; [impl] => { $ crate :: SyntaxKind :: IMPL_KW } ; [in] => { $ crate :: SyntaxKind :: IN_KW } ; [let] => { $ crate :: SyntaxKind :: LET_KW } ; [loop] => { $ crate :: SyntaxKind :: LOOP_KW } ; [macro] => { $ crate :: SyntaxKind :: MACRO_KW } ; [match] => { $ crate :: SyntaxKind :: MATCH_KW } ; [mod] => { $ crate :: SyntaxKind :: MOD_KW } ; [move] => { $ crate :: SyntaxKind :: MOVE_KW } ; [mut] => { $ crate :: SyntaxKind :: MUT_KW } ; [override] => { $ crate :: SyntaxKind :: OVERRIDE_KW } ; [priv] => { $ crate :: SyntaxKind :: PRIV_KW } ; [pub] => { $ crate :: SyntaxKind :: PUB_KW } ; [ref] => { $ crate :: SyntaxKind :: REF_KW } ; [return] => { $ crate :: SyntaxKind :: RETURN_KW } ; [self] => { $ crate :: SyntaxKind :: SELF_KW } ; [static] => { $ crate :: SyntaxKind :: STATIC_KW } ; [struct] => { $ crate :: SyntaxKind :: STRUCT_KW } ; [super] => { $ crate :: SyntaxKind :: SUPER_KW } ; [trait] => { $ crate :: SyntaxKind :: TRAIT_KW } ; [true] => { $ crate :: SyntaxKind :: TRUE_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [typeof] => { $ crate :: SyntaxKind :: TYPEOF_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [unsized] => { $ crate :: SyntaxKind :: UNSIZED_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [virtual] => { $ crate :: SyntaxKind :: VIRTUAL_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [asm] => { $ crate :: SyntaxKind :: ASM_KW } ; [att_syntax] => { $ crate :: SyntaxKind :: ATT_SYNTAX_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [builtin] => { $ crate :: SyntaxKind :: BUILTIN_KW } ; [clobber_abi] => { $ crate :: SyntaxKind :: CLOBBER_ABI_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [format_args] => { $ crate :: SyntaxKind :: FORMAT_ARGS_KW } ; [global_asm] => { $ crate :: SyntaxKind :: GLOBAL_ASM_KW } ; [inlateout] => { $ crate :: SyntaxKind :: INLATEOUT_KW } ; [inout] => { $ crate :: SyntaxKind :: INOUT_KW } ; [label] => { $ crate :: SyntaxKind :: LABEL_KW } ; [lateout] => { $ crate :: SyntaxKind :: LATEOUT_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [may_unwind] => { $ crate :: SyntaxKind :: MAY_UNWIND_KW } ; [naked_asm] => { $ crate :: SyntaxKind :: NAKED_ASM_KW } ; [nomem] => { $ crate :: SyntaxKind :: NOMEM_KW } ; [noreturn] => { $ crate :: SyntaxKind :: NORETURN_KW } ; [nostack] => { $ crate :: SyntaxKind :: NOSTACK_KW } ; [offset_of] => { $ crate :: SyntaxKind :: OFFSET_OF_KW } ; [options] => { $ crate :: SyntaxKind :: OPTIONS_KW } ; [out] => { $ crate :: SyntaxKind :: OUT_KW } ; [preserves_flags] => { $ crate :: SyntaxKind :: PRESERVES_FLAGS_KW } ; [pure] => { $ crate :: SyntaxKind :: PURE_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [readonly] => { $ crate :: SyntaxKind :: READONLY_KW } ; [safe] => { $ crate :: SyntaxKind :: SAFE_KW } ; [sym] => { $ crate :: SyntaxKind :: SYM_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [yeet] => { $ crate :: SyntaxKind :: YEET_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_KW } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [gen] => { $ crate :: SyntaxKind :: GEN_KW } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT } ; [int_number] => { $ crate :: SyntaxKind :: INT_NUMBER } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [string] => { $ crate :: SyntaxKind :: STRING } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; [frontmatter] => { $ crate :: SyntaxKind :: FRONTMATTER } ; }
1012impl ::core::marker::Copy for SyntaxKind {}
1013impl ::core::clone::Clone for SyntaxKind {
1014 #[inline]
1015 fn clone(&self) -> Self { *self }
1016}
1017impl ::core::cmp::PartialEq for SyntaxKind {
1018 #[inline]
1019 fn eq(&self, other: &Self) -> bool { (*self as u16) == (*other as u16) }
1020}
1021impl ::core::cmp::Eq for SyntaxKind {}
1022impl ::core::cmp::PartialOrd for SyntaxKind {
1023 #[inline]
1024 fn partial_cmp(&self, other: &Self) -> core::option::Option<core::cmp::Ordering> {
1025 Some(self.cmp(other))
1026 }
1027}
1028impl ::core::cmp::Ord for SyntaxKind {
1029 #[inline]
1030 fn cmp(&self, other: &Self) -> core::cmp::Ordering { (*self as u16).cmp(&(*other as u16)) }
1031}
1032impl ::core::hash::Hash for SyntaxKind {
1033 fn hash<H: ::core::hash::Hasher>(&self, state: &mut H) {
1034 ::core::mem::discriminant(self).hash(state);
1035 }
1036}