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