Keywords

Rust divides keywords into three categories:

• strict
• reserved
• weak

Strict keywords

Strict keywords can only be used in their correct contexts. They cannot be used as the names of:

• Items
• Variables and function parameters
• Fields and variants
• Type parameters
• Lifetime parameters or loop labels
• Macros or attributes
• Macro placeholders
• Crates

@root STRICT_KEYWORDS ->
      `_`
    | `as`
    | `async`
    | `await`
    | `break`
    | `const`
    | `continue`
    | `crate`
    | `dyn`
    | `else`
    | `enum`
    | `extern`
    | `false`
    | `fn`
    | `for`
    | `if`
    | `impl`
    | `in`
    | `let`
    | `loop`
    | `match`
    | `mod`
    | `move`
    | `mut`
    | `pub`
    | `ref`
    | `return`
    | `self`
    | `Self`
    | `static`
    | `struct`
    | `super`
    | `trait`
    | `true`
    | `type`
    | `unsafe`
    | `use`
    | `where`
    | `while`

Reserved keywords

Reserved keywords aren't used yet, but they are reserved for future use. They have the same restrictions as strict keywords. The reasoning behind this is to make current programs forward compatible with future versions of Rust by forbidding them to use these keywords.

@root RESERVED_KEYWORDS ->
      `abstract`
    | `become`
    | `box`
    | `do`
    | `final`
    | `gen`
    | `macro`
    | `override`
    | `priv`
    | `try`
    | `typeof`
    | `unsized`
    | `virtual`
    | `yield`

Weak keywords

Weak keywords have special meaning only in certain contexts. For example, it is possible to declare a variable or method with the name union.

@root WEAK_KEYWORDS ->
      `'static`
    | `macro_rules`
    | `raw`
    | `safe`
    | `union`

• macro_rules is used to create custom macros.

• union is used to declare a union and is only a keyword when used in a union declaration.

• 'static is used for the static lifetime and cannot be used as a generic lifetime parameter or loop label

  // error[E0262]: invalid lifetime parameter name: `'static`
  fn invalid_lifetime_parameter<'static>(s: &'static str) -> &'static str { s }
  

• safe is used for functions and statics, which has meaning in external blocks.

• raw is used for raw borrow operators, and is only a keyword when matching a raw borrow operator form (such as &raw const expr or &raw mut expr).