标记

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

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

在本文档的语法中，“简单”标记以 字符串表生成式 形式给出，并以 等宽 字体显示。

字面量

字面量是在 字面量表达式 中使用的标记。

示例

字符和字符串

**注意**：字符和字符串字面量标记永远不会包含紧跟在 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

   \u{ ( HEX_DIGIT _^* )^1..6 }

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

字符串字面量

^{词法分析器}

STRING_LITERAL

   " (

      ~[" \ IsolatedCR]

      | QUOTE_ESCAPE

      | ASCII_ESCAPE

      | UNICODE_ESCAPE

      | STRING_CONTINUE

   )^* " SUFFIX^?

STRING_CONTINUE

   \ 后跟 \n

字符串字面量是用两个 U+0022（双引号）字符括起来的任意 Unicode 字符序列，但 U+0022 本身除外，它必须在其前面加上 U+005C 字符（\）进行转义。

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

字符转义符

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

• 7 位代码点转义符以 U+0078 (x) 开头，后跟正好两个十六进制数字，其值最大为 0x7F。它表示 ASCII 字符，其值等于提供的十六进制值。不允许使用更高的值，因为它们表示 Unicode 代码点还是字节值不明确。
• 24 位代码点转义符以 U+0075 (u) 开头，后跟最多六个十六进制数字，并用大括号 U+007B ({) 和 U+007D (}) 括起来。它表示等于提供的十六进制值的 Unicode 代码点。
• 空白转义符是字符 U+006E (n)、U+0072 (r) 或 U+0074 (t) 之一，分别表示 Unicode 值 U+000A (LF)、U+000D (CR) 或 U+0009 (HT)。
• 空转义符是字符 U+0030 (0)，表示 Unicode 值 U+0000 (NUL)。
• 反斜杠转义符是字符 U+005C (\)，必须对其进行转义才能表示自身。

原始字符串字面量

^{词法分析器}

RAW_STRING_LITERAL

   r RAW_STRING_CONTENT SUFFIX^?

RAW_STRING_CONTENT

      " ( ~ IsolatedCR )^{* (非贪婪)} "

   | # RAW_STRING_CONTENT #

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

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

原始字符串主体中包含的所有 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
}

字节和字节字符串字面量

字节字面量

^{词法分析器}

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

   | \n | \r | \t | \\ | \0 | \' | \"

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

字节字符串字面量

^{词法分析器}

BYTE_STRING_LITERAL

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

ASCII_FOR_STRING

   任何 ASCII 字符（即 0x00 到 0x7F），但 "、\ 和 IsolatedCR 除外

非原始字节字符串字面量是由字符 U+0062 (b) 和 U+0022（双引号）开头、后跟字符 U+0022 的 ASCII 字符和转义符序列。如果字符 U+0022 出现在字面量中，则必须在其前面加上 U+005C (\) 字符进行转义。或者，字节字符串字面量可以是原始字节字符串字面量，如下所述。

字节字符串字面量中允许使用由字符 U+000A (LF) 表示的换行符。当未转义的 U+005C 字符 (\) 出现在换行符之前时，换行符不会出现在由标记表示的字符串中。有关详细信息，请参阅字符串续行转义符。字符 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} 除外

      | STRING_CONTINUE

   )^* " SUFFIX^?

C 字符串字面量是由字符 U+0063 (c) 和 U+0022（双引号）开头、后跟字符 U+0022 的 Unicode 字符和转义符序列。如果字符 U+0022 出现在字面量中，则必须在其前面加上 U+005C (\) 字符进行转义。或者，C 字符串字面量可以是原始 C 字符串字面量，如下所述。

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

C 字符串字面量中允许使用由字符 U+000A (LF) 表示的换行符。当未转义的 U+005C 字符 (\) 出现在换行符之前时，换行符不会出现在由标记表示的字符串中。有关详细信息，请参阅字符串续行转义符。字符 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";
}

版本差异：2021 版或更高版本接受 C 字符串字面量。在早期版本中，标记 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 (\) 没有任何特殊含义。

版本差异：2021 版或更高版本接受原始 C 字符串字面量。在早期版本中，标记 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 被分析为两个标记：- 后跟 1i8。

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

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

元组索引

^{词法分析器}

TUPLE_INDEX

   INTEGER_LITERAL

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

元组索引直接与字面量标记进行比较。元组索引从 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"..." {}}
}