词法单元

词法单元是由正则（非递归）语言定义的语法中的基本产生式。Rust 源代码输入可以分解为以下几种词法单元：

• 关键字
• 标识符
• 字面量
• 生命周期
• 标点符号
• 分隔符

在本文档的语法中，“简单”词法单元以字符串表产生式形式给出，并以monospace字体显示。

字面量

字面量是在字面量表达式中使用的词法单元。

示例

字符和字符串

注意：字符和字符串字面量词法单元永远不会包含紧跟在 U+000D (CR) 之后的 U+000A (LF) 序列：这对序列先前会被转换为单个 U+000A (LF)。

ASCII 转义

字节转义

Unicode 转义

引号转义

数字

后缀

后缀是字面量主要部分之后（没有中间空格）的字符序列，其形式与非原始标识符或关键字相同。

^{词法分析器}
SUFFIX : IDENTIFIER_OR_KEYWORD
SUFFIX_NO_E : SUFFIX _{不以 e 或 E 开头}

任何带有任何后缀的字面量（字符串、整数等）都是有效的词法单元。

带有任何后缀的字面量词法单元都可以传递给宏，而不会产生错误。宏本身将决定如何解释这样的词法单元以及是否产生错误。特别是，用于按示例宏的 literal 片段说明符匹配带有任意后缀的字面量词法单元。

#![allow(unused)]
fn main() {
macro_rules! blackhole { ($tt:tt) => () }
macro_rules! blackhole_lit { ($l:literal) => () }

blackhole!("string"suffix); // OK
blackhole_lit!(1suffix); // OK
}

但是，解释为字面量表达式或模式的字面量词法单元的后缀受到限制。非数字字面量词法单元的任何后缀都会被拒绝，而数字字面量词法单元仅接受下面列表中的后缀。

字符和字符串字面量

字符字面量

^{词法分析器}
CHAR_LITERAL
   ' ( ~[' \ \n \r \t] | QUOTE_ESCAPE | ASCII_ESCAPE | UNICODE_ESCAPE ) ' SUFFIX^?

QUOTE_ESCAPE
   \' | \"

\' | \"
      ASCII_ESCAPE
\x OCT_DIGIT HEX_DIGIT

   | \n | \r | \t | \\ | \0
   UNICODE_ESCAPE

[lex.token.literal.char.intro]

字符字面量是由两个 U+0027（单引号）字符括起来的单个 Unicode 字符，但 U+0027 本身除外，它必须由前面的 U+005C 字符（\）进行转义。

^{词法分析器}
[lex.token.literal.str.syntax]
   " (
STRING_LITERAL
      ~[" \ IsolatedCR]
      | QUOTE_ESCAPE
      | ASCII_ESCAPE
      | UNICODE_ESCAPE
      | STRING_CONTINUE

   )^* " SUFFIX^?
   STRING_CONTINUE

[lex.token.literal.str.intro]

[lex.token.literal.str.linefeed]

字符串字面量中允许使用由字符 U+000A (LF) 表示的换行符。当未转义的 U+005C 字符 (\) 紧邻换行符之前出现时，换行符不会出现在词法单元表示的字符串中。有关详细信息，请参阅字符串延续转义。字符 U+000D (CR) 不得出现在字符串字面量中，除非作为此类字符串延续转义的一部分。

[lex.token.literal.char-escape.intro]

• [lex.token.literal.char-escape.ascii]

• [lex.token.literal.char-escape.unicode]

• [lex.token.literal.char-escape.whitespace]

• [lex.token.literal.char-escape.null]

• [lex.token.literal.char-escape.slash]

反斜杠转义是必须转义才能表示自身的字符 U+005C (\)。

^{词法分析器}
[lex.token.literal.str-raw.syntax]
   RAW_STRING_LITERAL

r RAW_STRING_CONTENT SUFFIX^?
      RAW_STRING_CONTENT
" ( ~ IsolatedCR )^{* (非贪婪)} "

[lex.token.literal.str-raw.intro]

[lex.token.literal.str-raw.body]

[lex.token.literal.str-raw.content]

原始字符串主体中包含的所有 Unicode 字符都表示它们自身，字符 U+0022（双引号）（除非后跟至少与用于开始原始字符串字面量一样多的 U+0023 (#) 字符）或 U+005C (\) 没有特殊含义。

#![allow(unused)]
fn main() {
"foo"; r"foo";                     // foo
"\"foo\""; r#""foo""#;             // "foo"

"foo #\"# bar";
r##"foo #"# bar"##;                // foo #"# bar

"\x52"; "R"; r"R";                 // R
"\\x52"; r"\x52";                  // \x52
}

字符串字面量的示例

字节和字节字符串字面量

^{词法分析器}
[lex.token.byte.syntax]
   BYTE_LITERAL

b' ( ASCII_FOR_CHAR | BYTE_ESCAPE ) ' SUFFIX^?
   ASCII_FOR_CHAR

任何 ASCII（即 0x00 到 0x7F），除了 '、\、\n、\r 或 \t
      BYTE_ESCAPE
\x HEX_DIGIT HEX_DIGIT

[lex.token.byte.intro]

字节字面量是单个 ASCII 字符（在 U+0000 到 U+007F 范围内）或以字符 U+0062 (b) 和 U+0027（单引号）开头，并以字符 U+0027 结尾的单个转义。如果 U+0027 字符出现在字面量中，则必须由前面的 U+005C (\) 字符进行转义。它等效于一个 u8 无符号 8 位整数数字字面量。

^{词法分析器}
[lex.token.str-byte.syntax]
   BYTE_STRING_LITERAL

b" ( ASCII_FOR_STRING | BYTE_ESCAPE | STRING_CONTINUE )^* " SUFFIX^?
   ASCII_FOR_STRING

[lex.token.str-byte.intro]

字节字符串字面量中允许使用换行符，换行符由字符 U+000A (LF) 表示。当未转义的 U+005C 字符 (\) 紧跟在换行符之前时，换行符不会出现在由 token 表示的字符串中。详细信息请参见字符串延续转义。字符 U+000D (CR) 不能出现在字节字符串字面量中，除非它是字符串延续转义的一部分。

一些额外的转义可用于字节或非原始字节字符串字面量。转义以 U+005C (\) 开头，并以下列形式之一继续

• 一个字节转义以 U+0078 (x) 开头，后跟两个十六进制数字。它表示等于提供的十六进制值的字节。

• 一个空白转义是字符 U+006E (n)，U+0072 (r) 或 U+0074 (t) 之一，分别表示字节值 0x0A (ASCII LF)、0x0D (ASCII CR) 或 0x09 (ASCII HT)。

• 空转义是字符 U+0030 (0)，表示字节值 0x00 (ASCII NUL)。

• 反斜杠转义是字符 U+005C (\)，必须对其进行转义以表示其 ASCII 编码 0x5C。

原始字节字符串字面量

^{词法分析器}
RAW_BYTE_STRING_LITERAL
   br RAW_BYTE_STRING_CONTENT SUFFIX^?

RAW_BYTE_STRING_CONTENT
      " ASCII_FOR_RAW^{* (非贪婪)} "
   | # RAW_BYTE_STRING_CONTENT #

ASCII_FOR_RAW
   任何 ASCII (即 0x00 到 0x7F) ，除了 IsolatedCR

原始字节字符串字面量不处理任何转义。它们以字符 U+0062 (b) 开头，后跟 U+0072 (r)，后跟少于 256 个字符 U+0023 (#) 和一个 U+0022 (双引号) 字符。

原始字符串主体可以包含除 U+000D (CR) 之外的任何 ASCII 字符序列。它仅由另一个 U+0022 (双引号) 字符终止，后跟与开头的 U+0022 (双引号) 字符之前的 U+0023 (#) 字符相同数量的字符。原始字节字符串字面量不能包含任何非 ASCII 字节。

原始字符串主体中包含的所有字符都表示其 ASCII 编码，字符 U+0022 (双引号) （除非后跟至少与用于开始原始字符串字面量的 U+0023 (#) 字符一样多的字符）或 U+005C (\) 不具有任何特殊含义。

字节字符串字面量示例

#![allow(unused)]
fn main() {
b"foo"; br"foo";                     // foo
b"\"foo\""; br#""foo""#;             // "foo"

b"foo #\"# bar";
br##"foo #"# bar"##;                 // foo #"# bar

b"\x52"; b"R"; br"R";                // R
b"\\x52"; br"\x52";                  // \x52
}

C 字符串和原始 C 字符串字面量

C 字符串字面量

^{词法分析器}
C_STRING_LITERAL
   c" (
      ~[" \ IsolatedCR NUL]
      | BYTE_ESCAPE 除了 \0 或 \x00
      | UNICODE_ESCAPE 除了 \u{0}, \u{00}, …, \u{000000}
      | UNICODE_ESCAPE
      | STRING_CONTINUE

C 字符串字面量是一系列 Unicode 字符和转义，前面是字符 U+0063 (c) 和 U+0022 (双引号)，后面是字符 U+0022。如果字符 U+0022 出现在字面量中，则必须使用前面的 U+005C (\) 字符对其进行转义。或者，C 字符串字面量可以是原始 C 字符串字面量，定义如下。

C 字符串隐式地以字节 0x00 终止，因此 C 字符串字面量 c"" 等效于从字节字符串字面量 b"\x00" 手动构造 &CStr。除了隐式终止符外，C 字符串内不允许使用字节 0x00。

C 字符串字面量中允许使用换行符，换行符由字符 U+000A (LF) 表示。当未转义的 U+005C 字符 (\) 紧跟在换行符之前时，换行符不会出现在由 token 表示的字符串中。详细信息请参见 字符串延续转义。字符 U+000D (CR) 不能出现在 C 字符串字面量中，除非它是字符串延续转义的一部分。

一些额外的转义可用于非原始 C 字符串字面量。转义以 U+005C (\) 开头，并以下列形式之一继续

• 一个字节转义以 U+0078 (x) 开头，后跟两个十六进制数字。它表示等于提供的十六进制值的字节。

• 一个24 位代码点转义以 U+0075 (u) 开头，后跟最多六个由大括号 U+007B ({) 和 U+007D (}) 包围的十六进制数字。它表示等于提供的十六进制值的 Unicode 代码点，编码为 UTF-8。

• 一个空白转义是字符 U+006E (n)，U+0072 (r) 或 U+0074 (t) 之一，分别表示字节值 0x0A (ASCII LF)、0x0D (ASCII CR) 或 0x09 (ASCII HT)。

• 反斜杠转义是字符 U+005C (\)，必须对其进行转义以表示其 ASCII 编码 0x5C。

C 字符串表示没有定义编码的字节，但 C 字符串字面量可能包含高于 U+007F 的 Unicode 字符。这些字符将被替换为该字符的 UTF-8 表示形式的字节。

以下 C 字符串字面量是等效的

#![allow(unused)]
fn main() {
c"æ";        // LATIN SMALL LETTER AE (U+00E6)
c"\u{00E6}";
c"\xC3\xA6";
}

版本差异：C 字符串字面量在 2021 或更高版本中被接受。在早期版本中，token c"" 被解析为 c ""。

原始 C 字符串字面量

^{词法分析器}
RAW_C_STRING_LITERAL
   cr RAW_C_STRING_CONTENT SUFFIX^?

RAW_C_STRING_CONTENT
      " ( ~ IsolatedCR NUL )^{* (非贪婪)} "
   | # RAW_C_STRING_CONTENT #

原始 C 字符串字面量不处理任何转义。它们以字符 U+0063 (c) 开头，后跟 U+0072 (r)，后跟少于 256 个字符 U+0023 (#) 和一个 U+0022 (双引号) 字符。

原始 C 字符串主体可以包含除 U+0000 (NUL) 和 U+000D (CR) 之外的任何 Unicode 字符序列。它仅由另一个 U+0022 (双引号) 字符终止，后跟与开头的 U+0022 (双引号) 字符之前的 U+0023 (#) 字符相同数量的字符。

原始 C 字符串主体中包含的所有字符都以 UTF-8 编码形式表示它们自己。字符 U+0022 (双引号) （除非后跟至少与用于开始原始 C 字符串字面量的 U+0023 (#) 字符一样多的字符）或 U+005C (\) 不具有任何特殊含义。

版本差异：原始 C 字符串字面量在 2021 或更高版本中被接受。在早期版本中，token cr"" 被解析为 cr ""，而 cr#""# 被解析为 cr #""# (这是不合语法的)。

C 字符串和原始 C 字符串字面量示例

#![allow(unused)]
fn main() {
c"foo"; cr"foo";                     // foo
c"\"foo\""; cr#""foo""#;             // "foo"

c"foo #\"# bar";
cr##"foo #"# bar"##;                 // foo #"# bar

c"\x52"; c"R"; cr"R";                // R
c"\\x52"; cr"\x52";                  // \x52
}

数字字面量

数字字面量是整数字面量或浮点字面量。用于识别两种字面量的语法是混合的。

整数字面量

^{词法分析器}
INTEGER_LITERAL
   ( DEC_LITERAL | BIN_LITERAL | OCT_LITERAL | HEX_LITERAL ) SUFFIX_NO_E^?

DEC_LITERAL
   DEC_DIGIT (DEC_DIGIT|_)^*

BIN_LITERAL
   0b (BIN_DIGIT|_)^* BIN_DIGIT (BIN_DIGIT|_)^*

OCT_LITERAL
   0o (OCT_DIGIT|_)^* OCT_DIGIT (OCT_DIGIT|_)^*

HEX_LITERAL
   0x (HEX_DIGIT|_)^* HEX_DIGIT (HEX_DIGIT|_)^*

BIN_DIGIT : [0-1]

OCT_DIGIT : [0-7]

DEC_DIGIT : [0-9]

HEX_DIGIT : [0-9 a-f A-F]

整数字面量有四种形式

• 十进制字面量以十进制数字开头，并以任何十进制数字和下划线的组合继续。

• 十六进制字面量以字符序列 U+0030 U+0078 (0x) 开头，并以十六进制数字和下划线的任何组合（至少一个数字）继续。

• 八进制字面量以字符序列 U+0030 U+006F (0o) 开头，并以八进制数字和下划线的任何组合（至少一个数字）继续。

• 二进制字面量以字符序列 U+0030 U+0062 (0b) 开头，并以二进制数字和下划线的任何组合（至少一个数字）继续。

像任何字面量一样，整数字面量后面可以跟一个后缀（紧接着，没有任何空格），如上所述。后缀不能以 e 或 E 开头，因为这将被解释为浮点字面量的指数。有关这些后缀的影响，请参见整数字面量表达式。

被接受为字面量表达式的整数字面量示例

#![allow(unused)]
fn main() {
#![allow(overflowing_literals)]
123;
123i32;
123u32;
123_u32;

0xff;
0xff_u8;
0x01_f32; // integer 7986, not floating-point 1.0
0x01_e3;  // integer 483, not floating-point 1000.0

0o70;
0o70_i16;

0b1111_1111_1001_0000;
0b1111_1111_1001_0000i64;
0b________1;

0usize;

// These are too big for their type, but are accepted as literal expressions.
128_i8;
256_u8;

// This is an integer literal, accepted as a floating-point literal expression.
5f32;
}

请注意，例如，-1i8 被分析为两个 token：- 后跟 1i8。

不被接受为字面量表达式的整数字面量示例

#![allow(unused)]
fn main() {
#[cfg(FALSE)] {
0invalidSuffix;
123AFB43;
0b010a;
0xAB_CD_EF_GH;
0b1111_f32;
}
}

元组索引

^{词法分析器}
TUPLE_INDEX
   INTEGER_LITERAL

元组索引用于引用元组、元组结构体和元组变体的字段。

元组索引直接与字面量 token 进行比较。元组索引从 0 开始，并且每个连续的索引都以十进制值将值递增 1。因此，只有十进制值才会匹配，并且该值不能有任何额外的 0 前缀字符。

#![allow(unused)]
fn main() {
let example = ("dog", "cat", "horse");
let dog = example.0;
let cat = example.1;
// The following examples are invalid.
let cat = example.01;  // ERROR no field named `01`
let horse = example.0b10;  // ERROR no field named `0b10`
}

注意：元组索引可能包含某些后缀，但这并非有意有效，并且可能会在将来的版本中删除。有关更多信息，请参见 https://github.com/rust-lang/rust/issues/60210。

浮点字面量

^{词法分析器}
FLOAT_LITERAL
      DEC_LITERAL . (不立即跟在 .、_ 或 XID_Start 字符之后)
   | DEC_LITERAL . DEC_LITERAL SUFFIX_NO_E^?
   | DEC_LITERAL (. DEC_LITERAL)^? FLOAT_EXPONENT SUFFIX^?

FLOAT_EXPONENT
   (e|E) (+|-)^? (DEC_DIGIT|_)^* DEC_DIGIT (DEC_DIGIT|_)^*

一个浮点数字面量有两种形式

• 一个十进制字面量 后跟一个句点字符 U+002E (.)。 后面可选择跟随另一个十进制字面量，以及一个可选的指数。
• 一个单独的十进制字面量 后跟一个指数。

与整数字面量类似，浮点数字面量后面可以跟一个后缀，只要后缀前的部分不以 U+002E (.) 结尾。 如果字面量不包含指数，则后缀不能以 e 或 E 开头。 有关这些后缀的影响，请参阅 浮点数字面量表达式。

以下是一些浮点数字面量的示例，它们可被接受为字面量表达式

#![allow(unused)]
fn main() {
123.0f64;
0.1f64;
0.1f32;
12E+99_f64;
let x: f64 = 2.;
}

最后一个示例有所不同，因为无法在以句点结尾的浮点数字面量末尾使用后缀语法。 2.f64 会尝试在 2 上调用名为 f64 的方法。

请注意，例如 -1.0 会被解析为两个标记：- 后跟 1.0。

以下是一些不被接受为字面量表达式的浮点数字面量的示例

#![allow(unused)]
fn main() {
#[cfg(FALSE)] {
2.0f80;
2e5f80;
2e5e6;
2.0e5e6;
1.3e10u64;
}
}

类似于数字字面量的保留形式

^{词法分析器}
RESERVED_NUMBER
      BIN_LITERAL [2-9​]
   | OCT_LITERAL [8-9​]
   | ( BIN_LITERAL | OCT_LITERAL | HEX_LITERAL ) .
         (后面不紧跟 .、_ 或 XID_Start 字符)
   | ( BIN_LITERAL | OCT_LITERAL ) (e|E)
   | 0b _^* 输入结束或不是 BIN_DIGIT
   | 0o _^* 输入结束或不是 OCT_DIGIT
   | 0x _^* 输入结束或不是 HEX_DIGIT
   | DEC_LITERAL ( . DEC_LITERAL)^? (e|E) (+|-)^? 输入结束或不是 DEC_DIGIT

以下类似于数字字面量的词法形式是保留形式。 由于它们可能引起的歧义，它们会被词法分析器拒绝，而不是被解释为单独的标记。

• 一个没有后缀的二进制或八进制字面量，后面没有空格地跟随一个超出其基数的范围的十进制数字。

• 一个没有后缀的二进制、八进制或十六进制字面量，后面没有空格地跟随一个句点字符（与浮点数字面量一样，对句点后的内容有相同的限制）。

• 一个没有后缀的二进制或八进制字面量，后面没有空格地跟随字符 e 或 E。

• 以基数前缀之一开头，但不是有效的二进制、八进制或十六进制字面量（因为它不包含任何数字）的输入。

• 具有浮点数字面量形式，但在指数中没有数字的输入。

保留形式的示例

#![allow(unused)]
fn main() {
0b0102;  // this is not `0b010` followed by `2`
0o1279;  // this is not `0o127` followed by `9`
0x80.0;  // this is not `0x80` followed by `.` and `0`
0b101e;  // this is not a suffixed literal, or `0b101` followed by `e`
0b;      // this is not an integer literal, or `0` followed by `b`
0b_;     // this is not an integer literal, or `0` followed by `b_`
2e;      // this is not a floating-point literal, or `2` followed by `e`
2.0e;    // this is not a floating-point literal, or `2.0` followed by `e`
2em;     // this is not a suffixed literal, or `2` followed by `em`
2.0em;   // this is not a suffixed literal, or `2.0` followed by `em`
}

生命周期和循环标签

^{词法分析器}
LIFETIME_TOKEN
      ' IDENTIFIER_OR_KEYWORD (后面不紧跟 ')
   | '_ (后面不紧跟 ')

LIFETIME_OR_LABEL
      ' NON_KEYWORD_IDENTIFIER (后面不紧跟 ')

生命周期参数和循环标签使用 LIFETIME_OR_LABEL 标记。 词法分析器将接受任何 LIFETIME_TOKEN，例如，可以在宏中使用。

标点符号

这里列出了标点符号标记，以保证完整性。 它们的个别用法和含义在链接的页面中定义。

分隔符

括号标点符号用于语法的各个部分。 开括号必须始终与闭括号配对。 括号和其中的标记在 宏中被称为“标记树”。 括号有三种类型：

保留前缀

^{词法分析器 2021+}
RESERVED_TOKEN_DOUBLE_QUOTE : ( IDENTIFIER_OR_KEYWORD _{除了 b 或 c 或 r 或 br 或 cr} | _ ) "
RESERVED_TOKEN_SINGLE_QUOTE : ( IDENTIFIER_OR_KEYWORD _{除了 b} | _ ) '
RESERVED_TOKEN_POUND : ( IDENTIFIER_OR_KEYWORD _{除了 r 或 br 或 cr} | _ ) #

一些称为保留前缀的词法形式被保留以供将来使用。

源输入，否则会被词法解释为非原始标识符（或关键字或 _），紧跟一个 #、' 或 " 字符（没有中间空格），被标识为保留前缀。

请注意，原始标识符、原始字符串字面量和原始字节字符串字面量可能包含 # 字符，但不会被解释为包含保留前缀。

类似地，原始字符串字面量、字节字面量、字节字符串字面量、原始字节字符串字面量、C 字符串字面量和原始 C 字符串字面量中使用的 r、b、br、c 和 cr 前缀不会被解释为保留前缀。

版本差异：从 2021 版本开始，词法分析器会将保留前缀报告为错误（特别是，它们不能传递给宏）。

在 2021 版本之前，词法分析器接受保留前缀，并将其解释为多个标记（例如，一个标记用于标识符或关键字，后跟一个 # 标记）。

所有版本都接受的示例

#![allow(unused)]
fn main() {
macro_rules! lexes {($($_:tt)*) => {}}
lexes!{a #foo}
lexes!{continue 'foo}
lexes!{match "..." {}}
lexes!{r#let#foo}         // three tokens: r#let # foo
}

在 2021 版本之前接受但在之后版本中拒绝的示例

#![allow(unused)]
fn main() {
macro_rules! lexes {($($_:tt)*) => {}}
lexes!{a#foo}
lexes!{continue'foo}
lexes!{match"..." {}}
}