crates/parser/src/syntax_kind/generated.rs

   1 //! Generated by `sourcegen_ast`, do not edit by hand.
   2
   3 #![allow(bad_style, missing_docs, unreachable_pub)]
   4 #[doc = r" The kind of syntax node, e.g. `IDENT`, `USE_KW`, or `STRUCT`."]
   5 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
   6 #[repr(u16)]
   7 pub enum SyntaxKind {
   8     #[doc(hidden)]
   9     TOMBSTONE,
  10     #[doc(hidden)]
  11     EOF,
  12     SEMICOLON,
  13     COMMA,
  14     L_PAREN,
  15     R_PAREN,
  16     L_CURLY,
  17     R_CURLY,
  18     L_BRACK,
  19     R_BRACK,
  20     L_ANGLE,
  21     R_ANGLE,
  22     AT,
  23     POUND,
  24     TILDE,
  25     QUESTION,
  26     DOLLAR,
  27     AMP,
  28     PIPE,
  29     PLUS,
  30     STAR,
  31     SLASH,
  32     CARET,
  33     PERCENT,
  34     UNDERSCORE,
  35     DOT,
  36     DOT2,
  37     DOT3,
  38     DOT2EQ,
  39     COLON,
  40     COLON2,
  41     EQ,
  42     EQ2,
  43     FAT_ARROW,
  44     BANG,
  45     NEQ,
  46     MINUS,
  47     THIN_ARROW,
  48     LTEQ,
  49     GTEQ,
  50     PLUSEQ,
  51     MINUSEQ,
  52     PIPEEQ,
  53     AMPEQ,
  54     CARETEQ,
  55     SLASHEQ,
  56     STAREQ,
  57     PERCENTEQ,
  58     AMP2,
  59     PIPE2,
  60     SHL,
  61     SHR,
  62     SHLEQ,
  63     SHREQ,
  64     AS_KW,
  65     ASYNC_KW,
  66     AWAIT_KW,
  67     BOX_KW,
  68     BREAK_KW,
  69     CONST_KW,
  70     CONTINUE_KW,
  71     CRATE_KW,
  72     DYN_KW,
  73     ELSE_KW,
  74     ENUM_KW,
  75     EXTERN_KW,
  76     FALSE_KW,
  77     FN_KW,
  78     FOR_KW,
  79     IF_KW,
  80     IMPL_KW,
  81     IN_KW,
  82     LET_KW,
  83     LOOP_KW,
  84     MACRO_KW,
  85     MATCH_KW,
  86     MOD_KW,
  87     MOVE_KW,
  88     MUT_KW,
  89     PUB_KW,
  90     REF_KW,
  91     RETURN_KW,
  92     SELF_KW,
  93     STATIC_KW,
  94     STRUCT_KW,
  95     SUPER_KW,
  96     TRAIT_KW,
  97     TRUE_KW,
  98     TRY_KW,
  99     TYPE_KW,
 100     UNSAFE_KW,
 101     USE_KW,
 102     WHERE_KW,
 103     WHILE_KW,
 104     YIELD_KW,
 105     AUTO_KW,
 106     DEFAULT_KW,
 107     EXISTENTIAL_KW,
 108     UNION_KW,
 109     RAW_KW,
 110     MACRO_RULES_KW,
 111     INT_NUMBER,
 112     FLOAT_NUMBER,
 113     CHAR,
 114     BYTE,
 115     STRING,
 116     BYTE_STRING,
 117     ERROR,
 118     IDENT,
 119     WHITESPACE,
 120     LIFETIME_IDENT,
 121     COMMENT,
 122     SHEBANG,
 123     L_DOLLAR,
 124     R_DOLLAR,
 125     SOURCE_FILE,
 126     STRUCT,
 127     UNION,
 128     ENUM,
 129     FN,
 130     RET_TYPE,
 131     EXTERN_CRATE,
 132     MODULE,
 133     USE,
 134     STATIC,
 135     CONST,
 136     TRAIT,
 137     IMPL,
 138     TYPE_ALIAS,
 139     MACRO_CALL,
 140     MACRO_RULES,
 141     MACRO_ARM,
 142     TOKEN_TREE,
 143     MACRO_DEF,
 144     PAREN_TYPE,
 145     TUPLE_TYPE,
 146     MACRO_TYPE,
 147     NEVER_TYPE,
 148     PATH_TYPE,
 149     PTR_TYPE,
 150     ARRAY_TYPE,
 151     SLICE_TYPE,
 152     REF_TYPE,
 153     INFER_TYPE,
 154     FN_PTR_TYPE,
 155     FOR_TYPE,
 156     IMPL_TRAIT_TYPE,
 157     DYN_TRAIT_TYPE,
 158     OR_PAT,
 159     PAREN_PAT,
 160     REF_PAT,
 161     BOX_PAT,
 162     IDENT_PAT,
 163     WILDCARD_PAT,
 164     REST_PAT,
 165     PATH_PAT,
 166     RECORD_PAT,
 167     RECORD_PAT_FIELD_LIST,
 168     RECORD_PAT_FIELD,
 169     TUPLE_STRUCT_PAT,
 170     TUPLE_PAT,
 171     SLICE_PAT,
 172     RANGE_PAT,
 173     LITERAL_PAT,
 174     MACRO_PAT,
 175     CONST_BLOCK_PAT,
 176     TUPLE_EXPR,
 177     ARRAY_EXPR,
 178     PAREN_EXPR,
 179     PATH_EXPR,
 180     CLOSURE_EXPR,
 181     IF_EXPR,
 182     WHILE_EXPR,
 183     CONDITION,
 184     LOOP_EXPR,
 185     FOR_EXPR,
 186     CONTINUE_EXPR,
 187     BREAK_EXPR,
 188     LABEL,
 189     BLOCK_EXPR,
 190     RETURN_EXPR,
 191     YIELD_EXPR,
 192     MATCH_EXPR,
 193     MATCH_ARM_LIST,
 194     MATCH_ARM,
 195     MATCH_GUARD,
 196     RECORD_EXPR,
 197     RECORD_EXPR_FIELD_LIST,
 198     RECORD_EXPR_FIELD,
 199     EFFECT_EXPR,
 200     BOX_EXPR,
 201     CALL_EXPR,
 202     INDEX_EXPR,
 203     METHOD_CALL_EXPR,
 204     FIELD_EXPR,
 205     AWAIT_EXPR,
 206     TRY_EXPR,
 207     CAST_EXPR,
 208     REF_EXPR,
 209     PREFIX_EXPR,
 210     RANGE_EXPR,
 211     BIN_EXPR,
 212     EXTERN_BLOCK,
 213     EXTERN_ITEM_LIST,
 214     VARIANT,
 215     RECORD_FIELD_LIST,
 216     RECORD_FIELD,
 217     TUPLE_FIELD_LIST,
 218     TUPLE_FIELD,
 219     VARIANT_LIST,
 220     ITEM_LIST,
 221     ASSOC_ITEM_LIST,
 222     ATTR,
 223     META,
 224     USE_TREE,
 225     USE_TREE_LIST,
 226     PATH,
 227     PATH_SEGMENT,
 228     LITERAL,
 229     RENAME,
 230     VISIBILITY,
 231     WHERE_CLAUSE,
 232     WHERE_PRED,
 233     ABI,
 234     NAME,
 235     NAME_REF,
 236     LET_STMT,
 237     EXPR_STMT,
 238     GENERIC_PARAM_LIST,
 239     GENERIC_PARAM,
 240     LIFETIME_PARAM,
 241     TYPE_PARAM,
 242     CONST_PARAM,
 243     GENERIC_ARG_LIST,
 244     LIFETIME,
 245     LIFETIME_ARG,
 246     TYPE_ARG,
 247     ASSOC_TYPE_ARG,
 248     CONST_ARG,
 249     PARAM_LIST,
 250     PARAM,
 251     SELF_PARAM,
 252     ARG_LIST,
 253     TYPE_BOUND,
 254     TYPE_BOUND_LIST,
 255     MACRO_ITEMS,
 256     MACRO_STMTS,
 257     #[doc(hidden)]
 258     __LAST,
 259 }
 260 use self::SyntaxKind::*;
 261 impl SyntaxKind {
 262     pub fn is_keyword(self) -> bool {
 263         match self {
 264             AS_KW | ASYNC_KW | AWAIT_KW | BOX_KW | BREAK_KW | CONST_KW | CONTINUE_KW | CRATE_KW
 265             | DYN_KW | ELSE_KW | ENUM_KW | EXTERN_KW | FALSE_KW | FN_KW | FOR_KW | IF_KW
 266             | IMPL_KW | IN_KW | LET_KW | LOOP_KW | MACRO_KW | MATCH_KW | MOD_KW | MOVE_KW
 267             | MUT_KW | PUB_KW | REF_KW | RETURN_KW | SELF_KW | STATIC_KW | STRUCT_KW | SUPER_KW
 268             | TRAIT_KW | TRUE_KW | TRY_KW | TYPE_KW | UNSAFE_KW | USE_KW | WHERE_KW | WHILE_KW
 269             | YIELD_KW | AUTO_KW | DEFAULT_KW | EXISTENTIAL_KW | UNION_KW | RAW_KW
 270             | MACRO_RULES_KW => true,
 271             _ => false,
 272         }
 273     }
 274     pub fn is_punct(self) -> bool {
 275         match self {
 276             SEMICOLON | COMMA | L_PAREN | R_PAREN | L_CURLY | R_CURLY | L_BRACK | R_BRACK
 277             | L_ANGLE | R_ANGLE | AT | POUND | TILDE | QUESTION | DOLLAR | AMP | PIPE | PLUS
 278             | STAR | SLASH | CARET | PERCENT | UNDERSCORE | DOT | DOT2 | DOT3 | DOT2EQ | COLON
 279             | COLON2 | EQ | EQ2 | FAT_ARROW | BANG | NEQ | MINUS | THIN_ARROW | LTEQ | GTEQ
 280             | PLUSEQ | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ | SLASHEQ | STAREQ | PERCENTEQ | AMP2
 281             | PIPE2 | SHL | SHR | SHLEQ | SHREQ => true,
 282             _ => false,
 283         }
 284     }
 285     pub fn is_literal(self) -> bool {
 286         match self {
 287             INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE | STRING | BYTE_STRING => true,
 288             _ => false,
 289         }
 290     }
 291     pub fn from_keyword(ident: &str) -> Option<SyntaxKind> {
 292         let kw = match ident {
 293             "as" => AS_KW,
 294             "async" => ASYNC_KW,
 295             "await" => AWAIT_KW,
 296             "box" => BOX_KW,
 297             "break" => BREAK_KW,
 298             "const" => CONST_KW,
 299             "continue" => CONTINUE_KW,
 300             "crate" => CRATE_KW,
 301             "dyn" => DYN_KW,
 302             "else" => ELSE_KW,
 303             "enum" => ENUM_KW,
 304             "extern" => EXTERN_KW,
 305             "false" => FALSE_KW,
 306             "fn" => FN_KW,
 307             "for" => FOR_KW,
 308             "if" => IF_KW,
 309             "impl" => IMPL_KW,
 310             "in" => IN_KW,
 311             "let" => LET_KW,
 312             "loop" => LOOP_KW,
 313             "macro" => MACRO_KW,
 314             "match" => MATCH_KW,
 315             "mod" => MOD_KW,
 316             "move" => MOVE_KW,
 317             "mut" => MUT_KW,
 318             "pub" => PUB_KW,
 319             "ref" => REF_KW,
 320             "return" => RETURN_KW,
 321             "self" => SELF_KW,
 322             "static" => STATIC_KW,
 323             "struct" => STRUCT_KW,
 324             "super" => SUPER_KW,
 325             "trait" => TRAIT_KW,
 326             "true" => TRUE_KW,
 327             "try" => TRY_KW,
 328             "type" => TYPE_KW,
 329             "unsafe" => UNSAFE_KW,
 330             "use" => USE_KW,
 331             "where" => WHERE_KW,
 332             "while" => WHILE_KW,
 333             "yield" => YIELD_KW,
 334             _ => return None,
 335         };
 336         Some(kw)
 337     }
 338     pub fn from_char(c: char) -> Option<SyntaxKind> {
 339         let tok = match c {
 340             ';' => SEMICOLON,
 341             ',' => COMMA,
 342             '(' => L_PAREN,
 343             ')' => R_PAREN,
 344             '{' => L_CURLY,
 345             '}' => R_CURLY,
 346             '[' => L_BRACK,
 347             ']' => R_BRACK,
 348             '<' => L_ANGLE,
 349             '>' => R_ANGLE,
 350             '@' => AT,
 351             '#' => POUND,
 352             '~' => TILDE,
 353             '?' => QUESTION,
 354             '$' => DOLLAR,
 355             '&' => AMP,
 356             '|' => PIPE,
 357             '+' => PLUS,
 358             '*' => STAR,
 359             '/' => SLASH,
 360             '^' => CARET,
 361             '%' => PERCENT,
 362             '_' => UNDERSCORE,
 363             '.' => DOT,
 364             ':' => COLON,
 365             '=' => EQ,
 366             '!' => BANG,
 367             '-' => MINUS,
 368             _ => return None,
 369         };
 370         Some(tok)
 371     }
 372 }
 373 #[macro_export]
 374 macro_rules ! T { [;] => { $ 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 :: DOLLAR } ; [&] => { $ 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 } ; [as] => { $ crate :: SyntaxKind :: AS_KW } ; [async] => { $ crate :: SyntaxKind :: ASYNC_KW } ; [await] => { $ crate :: SyntaxKind :: AWAIT_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 } ; [dyn] => { $ crate :: SyntaxKind :: DYN_KW } ; [else] => { $ crate :: SyntaxKind :: ELSE_KW } ; [enum] => { $ crate :: SyntaxKind :: ENUM_KW } ; [extern] => { $ crate :: SyntaxKind :: EXTERN_KW } ; [false] => { $ crate :: SyntaxKind :: FALSE_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 } ; [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 } ; [try] => { $ crate :: SyntaxKind :: TRY_KW } ; [type] => { $ crate :: SyntaxKind :: TYPE_KW } ; [unsafe] => { $ crate :: SyntaxKind :: UNSAFE_KW } ; [use] => { $ crate :: SyntaxKind :: USE_KW } ; [where] => { $ crate :: SyntaxKind :: WHERE_KW } ; [while] => { $ crate :: SyntaxKind :: WHILE_KW } ; [yield] => { $ crate :: SyntaxKind :: YIELD_KW } ; [auto] => { $ crate :: SyntaxKind :: AUTO_KW } ; [default] => { $ crate :: SyntaxKind :: DEFAULT_KW } ; [existential] => { $ crate :: SyntaxKind :: EXISTENTIAL_KW } ; [union] => { $ crate :: SyntaxKind :: UNION_KW } ; [raw] => { $ crate :: SyntaxKind :: RAW_KW } ; [macro_rules] => { $ crate :: SyntaxKind :: MACRO_RULES_KW } ; [lifetime_ident] => { $ crate :: SyntaxKind :: LIFETIME_IDENT } ; [ident] => { $ crate :: SyntaxKind :: IDENT } ; [shebang] => { $ crate :: SyntaxKind :: SHEBANG } ; }
 375 pub use T;