--- /srv/rebuilderd/tmp/rebuilderd2TZjLz/inputs/rust-doc_1.96.1+dfsg1-2_all.deb +++ /srv/rebuilderd/tmp/rebuilderd2TZjLz/out/rust-doc_1.96.1+dfsg1-2_all.deb ├── file list │ @@ -1,3 +1,3 @@ │ -rw-r--r-- 0 0 0 4 2026-10-04 17:37:30.000000 debian-binary │ --rw-r--r-- 0 0 0 1095924 2026-10-04 17:37:30.000000 control.tar.xz │ --rw-r--r-- 0 0 0 25033536 2026-10-04 17:37:30.000000 data.tar.xz │ +-rw-r--r-- 0 0 0 1095916 2026-10-04 17:37:30.000000 control.tar.xz │ +-rw-r--r-- 0 0 0 25033552 2026-10-04 17:37:30.000000 data.tar.xz ├── control.tar.xz │ ├── control.tar │ │ ├── ./md5sums │ │ │ ├── ./md5sums │ │ │ │┄ Files differ ├── data.tar.xz │ ├── data.tar │ │ ├── ./usr/share/doc/rust-doc/html/reference/grammar.html │ │ │ @@ -179,3314 +179,6311 @@ │ │ │ }); │ │ │ │ │ │ │ │ │
The following is a summary of the grammar production rules. For details on the syntax of this grammar, see notation.grammar.syntax.
Syntax │ │ │ │ │ │ -ProcMacroDeriveAttribute → proc_macro_derive ( DeriveMacroName ( , DeriveMacroAttributes )? ,? )
DeriveMacroName → IDENTIFIER
DeriveMacroAttributes → attributes ( ( IDENTIFIER ( , IDENTIFIER )* ,? )? )
InnerAttribute → # ! [ Attr ]
OuterAttribute → # [ Attr ]
Attr → SimplePath AttrInput? | unsafe ( SimplePath AttrInput? )
AttrInput → DelimTokenTree | = Expression
MetaItem → SimplePath | SimplePath = Expression | SimplePath ( MetaSeq? )
MetaSeq → MetaItemInner ( , MetaItemInner )* ,?
MetaItemInner → MetaItem | Expression
MetaWord → IDENTIFIER
MetaNameValueStr → IDENTIFIER = ( STRING_LITERAL | RAW_STRING_LITERAL )
MetaListPaths → IDENTIFIER ( ( SimplePath ( , SimplePath )* ,? )? )
MetaListIdents → IDENTIFIER ( ( IDENTIFIER ( , IDENTIFIER )* ,? )? )
MetaListNameValueStr → IDENTIFIER ( ( MetaNameValueStr ( , MetaNameValueStr )* ,? )? )
CollapseDebuginfoAttribute → collapse_debuginfo ( CollapseDebuginfoOption )
CollapseDebuginfoOption → yes | no | external
InlineAttribute → inline ( always ) | inline ( never ) | inline
VisItem → Visibility? ( Module | ExternCrate | UseDeclaration | Function | TypeAlias | Struct | Enumeration | Union | ConstantItem | StaticItem | Trait | Implementation | ExternBlock )
MacroItem → MacroInvocationSemi | MacroRulesDefinition
Crate → InnerAttribute* Item*
Visibility → pub | pub ( crate ) | pub ( self ) | pub ( super ) | pub ( in SimplePath )
Trait → unsafe? trait IDENTIFIER GenericParams? ( : TypeParamBounds? )? WhereClause? { InnerAttribute* AssociatedItem* }
TypeAlias → type IDENTIFIER GenericParams? ( : TypeParamBounds )? WhereClause? ( = Type WhereClause? )? ;
ConstantItem → const ( IDENTIFIER | _ ) : Type ( = Expression )? ;
Struct → StructStruct | TupleStruct
StructStruct → struct IDENTIFIER GenericParams? WhereClause? ( { StructFields? } | ; )
TupleStruct → struct IDENTIFIER GenericParams? ( TupleFields? ) WhereClause? ;
StructFields → StructField ( , StructField )* ,?
StructField → OuterAttribute* Visibility? IDENTIFIER : Type
TupleFields → TupleField ( , TupleField )* ,?
TupleField → OuterAttribute* Visibility? Type
Implementation → InherentImpl | TraitImpl
InherentImpl → impl GenericParams? Type WhereClause? { InnerAttribute* AssociatedItem* }
TraitImpl → unsafe? impl GenericParams? !? TypePath for Type WhereClause? { InnerAttribute* AssociatedItem* }
Function → FunctionQualifiers fn IDENTIFIER GenericParams? ( FunctionParameters? ) FunctionReturnType? WhereClause? ( BlockExpression | ; )
FunctionQualifiers → const? async? ItemSafety? ( extern Abi? )?
ItemSafety → safe | unsafe
Abi → STRING_LITERAL | RAW_STRING_LITERAL
FunctionParameters → SelfParam ,? | ( SelfParam , )? FunctionParam ( , FunctionParam )* ,?
SelfParam → OuterAttribute* ( ShorthandSelf | TypedSelf )
ShorthandSelf → ( & | & Lifetime )? mut? self
TypedSelf → mut? self : Type
FunctionParam → OuterAttribute* ( FunctionParamPattern | ... | Type )
FunctionParamPattern → PatternNoTopAlt : ( Type | ... )
FunctionReturnType → -> Type
GenericParams → < ( GenericParam ( , GenericParam )* ,? )? >
GenericParam → OuterAttribute* ( LifetimeParam | TypeParam | ConstParam )
LifetimeParam → Lifetime ( : LifetimeBounds )?
TypeParam → IDENTIFIER ( : TypeParamBounds? )? ( = Type )?
ConstParam → const IDENTIFIER : Type ( = ( BlockExpression | IDENTIFIER | -? LiteralExpression ) )?
WhereClause → where ( WhereClauseItem , )* WhereClauseItem?
WhereClauseItem → LifetimeWhereClauseItem | TypeBoundWhereClauseItem
LifetimeWhereClauseItem → Lifetime : LifetimeBounds
TypeBoundWhereClauseItem → ForLifetimes? Type : TypeParamBounds?
StaticItem → ItemSafety? static mut? IDENTIFIER : Type ( = Expression )? ;
ExternCrate → extern crate CrateRef AsClause? ;
CrateRef → IDENTIFIER | self
AsClause → as ( IDENTIFIER | _ )
AssociatedItem → OuterAttribute* ( MacroInvocationSemi | ( Visibility? ( TypeAlias | ConstantItem | Function ) ) )
ExternBlock → unsafe? extern Abi? { InnerAttribute* ExternalItem* }
ExternalItem → OuterAttribute* ( MacroInvocationSemi | Visibility? StaticItem | Visibility? Function )
Union → union IDENTIFIER GenericParams? WhereClause? { StructFields? }
UseDeclaration → use UseTree ;
UseTree → ( SimplePath? :: )? * | ( SimplePath? :: )? { ( UseTree ( , UseTree )* ,? )? } | SimplePath ( as ( IDENTIFIER | _ ) )?
Module → unsafe? mod IDENTIFIER ; | unsafe? mod IDENTIFIER { InnerAttribute* Item* }
Enumeration → enum IDENTIFIER GenericParams? WhereClause? { EnumVariants? }
EnumVariants → EnumVariant ( , EnumVariant )* ,?
EnumVariant → OuterAttribute* Visibility? IDENTIFIER ( EnumVariantTuple | EnumVariantStruct )? EnumVariantDiscriminant?
EnumVariantTuple → ( TupleFields? )
EnumVariantStruct → { StructFields? }
EnumVariantDiscriminant → = Expression
Show Railroad
Syntax │ │ │ - │ │ │ -ConfigurationPredicate → ConfigurationOption | ConfigurationAll | ConfigurationAny | ConfigurationNot | true | false
ConfigurationOption → IDENTIFIER ( = ( STRING_LITERAL | RAW_STRING_LITERAL ) )?
ConfigurationAll → all ( ConfigurationPredicateList? )
ConfigurationAny → any ( ConfigurationPredicateList? )
ConfigurationNot → not ( ConfigurationPredicate )
ConfigurationPredicateList → ConfigurationPredicate ( , ConfigurationPredicate )* ,?
CfgAttribute → cfg ( ConfigurationPredicate )
CfgAttrAttribute → cfg_attr ( ConfigurationPredicate , CfgAttrs? )
CfgAttrs → Attr ( , Attr )* ,?
CfgSelect → CfgSelectArms?
CfgSelectArms → CfgSelectConfigurationPredicate => ( { ^ TokenTree } ,? CfgSelectArms? | ExpressionWithBlockNoAttrs ,? CfgSelectArms? | ExpressionWithoutBlockNoAttrs ( , CfgSelectArms? )? )
CfgSelectConfigurationPredicate → ConfigurationPredicate | _
Lexer │ │ │ - │ │ │ -WHITESPACE → U+0009 // Horizontal tab, '\t' | U+000A // Line feed, '\n' | U+000B // Vertical tab | U+000C // Form feed | U+000D // Carriage return, '\r' | U+0020 // Space, ' ' | U+0085 // Next line | U+200E // Left-to-right mark | U+200F // Right-to-left mark | U+2028 // Line separator | U+2029 // Paragraph separator
'\t'
'\n'
'\r'
' '
TAB → U+0009 // Horizontal tab, '\t'
LF → U+000A // Line feed, '\n'
CR → U+000D // Carriage return, '\r'
Token → RESERVED_TOKEN | RAW_IDENTIFIER | CHAR_LITERAL | STRING_LITERAL | RAW_STRING_LITERAL | BYTE_LITERAL | BYTE_STRING_LITERAL | RAW_BYTE_STRING_LITERAL | C_STRING_LITERAL | RAW_C_STRING_LITERAL | FLOAT_LITERAL | INTEGER_LITERAL | LIFETIME_TOKEN | PUNCTUATION | IDENTIFIER_OR_KEYWORD
SUFFIX → _ ^ XID_Continue+ | XID_Start XID_Continue*
CHAR_LITERAL → ' ( ~[' \ LF CR TAB] | 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..=6valid hex char value }
STRING_LITERAL → " ( ~[" \ CR] | QUOTE_ESCAPE | ASCII_ESCAPE | UNICODE_ESCAPE | STRING_CONTINUE )* " SUFFIX?
STRING_CONTINUE → \ LF
RAW_STRING_LITERAL → r " ^ RAW_STRING_CONTENT " SUFFIX? | r #n:1..=255 ^ " RAW_STRING_CONTENT_HASHED " #n SUFFIX?
RAW_STRING_CONTENT → ( !" ~CR )*
RAW_STRING_CONTENT_HASHED → ( !( " #n ) ~CR )*
BYTE_LITERAL → b' ^ ( ASCII_FOR_CHAR | BYTE_ESCAPE ) ' SUFFIX?
ASCII_FOR_CHAR → ![' \ LF CR TAB] ASCII
BYTE_ESCAPE → \x HEX_DIGIT HEX_DIGIT | \n | \r | \t | \\ | \0 | \' | \"
BYTE_STRING_LITERAL → b" ^ ( ASCII_FOR_STRING | BYTE_ESCAPE | STRING_CONTINUE )* " SUFFIX?
ASCII_FOR_STRING → ![" \ CR] ASCII
RAW_BYTE_STRING_LITERAL → br " ^ RAW_BYTE_STRING_CONTENT " SUFFIX? | br #n:1..=255 ^ " RAW_BYTE_STRING_CONTENT_HASHED " #n SUFFIX?
RAW_BYTE_STRING_CONTENT → ( !" ASCII_FOR_RAW )*
RAW_BYTE_STRING_CONTENT_HASHED → ( !( " #n ) ASCII_FOR_RAW )*
ASCII_FOR_RAW → !CR ASCII
C_STRING_LITERAL → c" ^ ( ~[" \ CR NUL] | BYTE_ESCAPEexcept \0 or \x00 | UNICODE_ESCAPEexcept \u{0}, \u{00}, …, \u{000000} | STRING_CONTINUE )* " SUFFIX?
\0
\x00
\u{0}
\u{00}
\u{000000}
RAW_C_STRING_LITERAL → cr " ^ RAW_C_STRING_CONTENT " SUFFIX? | cr #n:1..=255 ^ " RAW_C_STRING_CONTENT_HASHED " #n SUFFIX?
RAW_C_STRING_CONTENT → ( !" ~[CR NUL] )*
RAW_C_STRING_CONTENT_HASHED → ( !( " #n ) ~[CR NUL] )*
INTEGER_LITERAL → ( BIN_LITERAL | OCT_LITERAL | HEX_LITERAL | DEC_LITERAL ) ^ !RESERVED_FLOAT SUFFIX?
DEC_LITERAL → DEC_DIGIT ( DEC_DIGIT | _ )*
BIN_LITERAL → 0b ^ _* BIN_DIGIT ( BIN_DIGIT | _ )* ![e E 2-9]
OCT_LITERAL → 0o ^ _* OCT_DIGIT ( OCT_DIGIT | _ )* ![e E 8-9]
HEX_LITERAL → 0x ^ _* HEX_DIGIT ( HEX_DIGIT | _ )*
BIN_DIGIT → [0-1]
OCT_DIGIT → [0-7]
DEC_DIGIT → [0-9]
HEX_DIGIT → [0-9 a-f A-F]
RESERVED_FLOAT → . !( . | _ | XID_Start )
TUPLE_INDEX → DEC_LITERAL | BIN_LITERAL | OCT_LITERAL | HEX_LITERAL
FLOAT_LITERAL → DEC_LITERAL ( . DEC_LITERAL )? FLOAT_EXPONENT SUFFIX? | DEC_LITERAL . DEC_LITERAL SUFFIX? | DEC_LITERAL . !( . | _ | XID_Start )
FLOAT_EXPONENT → ( e | E ) ^ ( + | - )? _* DEC_DIGIT ( DEC_DIGIT | _ )*
LIFETIME_TOKEN → RAW_LIFETIME | ' IDENTIFIER_OR_KEYWORD !'
LIFETIME_OR_LABEL → RAW_LIFETIME | ' NON_KEYWORD_IDENTIFIER !'
RAW_LIFETIME → 'r# ^ IDENTIFIER_OR_KEYWORD !'
RESERVED_RAW_LIFETIME → 'r# ( _ | crate | self | Self | super ) !( ' | XID_Continue )
PUNCTUATION → ... | ..= | <<= | >>= | != | %= | && | &= | *= | += | -= | -> | .. | /= | :: | <- | << | <= | == | => | >= | >> | ^= | |= | || | ! | # | $ | % | & | ( | ) | * | + | , | - | . | / | : | ; | < | = | > | ? | @ | [ | ] | ^ | { | | | } | ~
RESERVED_TOKEN → RESERVED_GUARDED_STRING_LITERAL | RESERVED_POUNDS | RESERVED_RAW_IDENTIFIER | RESERVED_RAW_LIFETIME | RESERVED_TOKEN_DOUBLE_QUOTE | RESERVED_TOKEN_LIFETIME | RESERVED_TOKEN_POUND | RESERVED_TOKEN_SINGLE_QUOTE
RESERVED_TOKEN_DOUBLE_QUOTE → IDENTIFIER_OR_KEYWORDexcept b or c or r or br or cr "
b
c
r
br
cr
RESERVED_TOKEN_SINGLE_QUOTE → IDENTIFIER_OR_KEYWORDexcept b '
RESERVED_TOKEN_POUND → IDENTIFIER_OR_KEYWORDexcept r or br or cr #
RESERVED_TOKEN_LIFETIME → ' IDENTIFIER_OR_KEYWORDexcept r #
RESERVED_GUARDED_STRING_LITERAL → #+ STRING_LITERAL
RESERVED_POUNDS → #2..
SHEBANG → #! !( ( WHITESPACE | LINE_COMMENT | BLOCK_COMMENT )* [ ) ~LF* ( LF | EOF )
CHAR → [U+0000-U+D7FF U+E000-U+10FFFF] // a Unicode scalar value
ASCII → [U+0000-U+007F]
NUL → U+0000
EOF → !CHAR // End of file or input
IDENTIFIER_OR_KEYWORD → ( XID_Start | _ ) XID_Continue*
XID_Start → <XID_Start defined by Unicode>
XID_Start
XID_Continue → <XID_Continue defined by Unicode>
XID_Continue
RAW_IDENTIFIER → r# IDENTIFIER_OR_KEYWORD
NON_KEYWORD_IDENTIFIER → IDENTIFIER_OR_KEYWORDexcept a strict or reserved keyword
IDENTIFIER → NON_KEYWORD_IDENTIFIER | RAW_IDENTIFIER
RESERVED_RAW_IDENTIFIER → r# ( _ | crate | self | Self | super ) !XID_Continue
COMMENT → LINE_COMMENT | INNER_LINE_DOC | OUTER_LINE_DOC | INNER_BLOCK_DOC | OUTER_BLOCK_DOC | BLOCK_COMMENT
LINE_COMMENT → // ( ~[/ ! LF] | // ) ~LF* | // EOF | //immediately followed by LF
BLOCK_COMMENT → /* ^ ( BLOCK_COMMENT_OR_DOC | ( !*/ CHAR ) )* */
INNER_LINE_DOC → //! ^ LINE_DOC_COMMENT_CONTENT ( LF | EOF )
LINE_DOC_COMMENT_CONTENT → ( !CR ~LF )*
INNER_BLOCK_DOC → /*! ^ ( BLOCK_COMMENT_OR_DOC | BLOCK_CHAR )* */
OUTER_LINE_DOC → /// ^ LINE_DOC_COMMENT_CONTENT ( LF | EOF )
OUTER_BLOCK_DOC → /** ![* /] ^ ( ~* | BLOCK_COMMENT_OR_DOC ) ( BLOCK_COMMENT_OR_DOC | BLOCK_CHAR )* */
BLOCK_CHAR → ( !( */ | CR ) CHAR )
BLOCK_COMMENT_OR_DOC → INNER_BLOCK_DOC | OUTER_BLOCK_DOC | BLOCK_COMMENT
Lexer │ │ │ + │ │ │ +CHAR → [U+0000-U+D7FF U+E000-U+10FFFF] // a Unicode scalar value
WHITESPACE → U+0009 // Horizontal tab, '\t' | U+000A // Line feed, '\n' | U+000B // Vertical tab | U+000C // Form feed | U+000D // Carriage return, '\r' | U+0020 // Space, ' ' | U+0085 // Next line | U+200E // Left-to-right mark | U+200F // Right-to-left mark | U+2028 // Line separator | U+2029 // Paragraph separator
Syntax │ │ │ - │ │ │ -Visibility → pub | pub ( crate ) | pub ( self ) | pub ( super ) | pub ( in SimplePath )
Item → OuterAttribute* ( VisItem | MacroItem )
Syntax │ │ │ - │ │ │ -Type → TypeNoBounds | ImplTraitType | TraitObjectType
TypeNoBounds → ParenthesizedType | ImplTraitTypeOneBound | TraitObjectTypeOneBound | TypePath | TupleType | NeverType | RawPointerType | ReferenceType | ArrayType | SliceType | InferredType | QualifiedPathInType | BareFunctionType | MacroInvocation
ParenthesizedType → ( Type )
TupleType → ( ) | ( ( Type , )+ Type? )
TraitObjectType → dyn? TypeParamBounds
TraitObjectTypeOneBound → dyn? TraitBound
SliceType → [ Type ]
ReferenceType → & Lifetime? mut? TypeNoBounds
RawPointerType → * ( mut | const ) TypeNoBounds
NeverType → !
InferredType → _
ImplTraitType → impl TypeParamBounds
ImplTraitTypeOneBound → impl TraitBound
BareFunctionType → ForLifetimes? FunctionTypeQualifiers fn ( FunctionParametersMaybeNamedVariadic? ) BareFunctionReturnType?
FunctionTypeQualifiers → unsafe? ( extern Abi? )?
BareFunctionReturnType → -> TypeNoBounds
FunctionParametersMaybeNamedVariadic → MaybeNamedFunctionParameters | MaybeNamedFunctionParametersVariadic
MaybeNamedFunctionParameters → MaybeNamedParam ( , MaybeNamedParam )* ,?
MaybeNamedParam → OuterAttribute* ( ( IDENTIFIER | _ ) : )? Type
MaybeNamedFunctionParametersVariadic → ( MaybeNamedParam , )* MaybeNamedParam , OuterAttribute* ...
ArrayType → [ Type ; Expression ]
Syntax │ │ │ + │ │ │ +ArrayType → [ Type ; Expression ]
Type → TypeNoBounds | ImplTraitType | TraitObjectType
Syntax │ │ │ - │ │ │ -TypeParamBounds → TypeParamBound ( + TypeParamBound )* +?
TypeParamBound → Lifetime | TraitBound | UseBound
TraitBound → ( ? | ForLifetimes )? TypePath | ( ( ? | ForLifetimes )? TypePath )
LifetimeBounds → ( Lifetime + )* Lifetime?
Lifetime → LIFETIME_OR_LABEL | 'static | '_
UseBound → use UseBoundGenericArgs
UseBoundGenericArgs → < > | < ( UseBoundGenericArg , )* UseBoundGenericArg ,? >
UseBoundGenericArg → Lifetime | IDENTIFIER | Self
ForLifetimes → for GenericParams
Syntax │ │ │ - │ │ │ -Statement → ; | Item | LetStatement | ExpressionStatement | OuterAttribute* MacroInvocationSemi
LetStatement → OuterAttribute* let PatternNoTopAlt ( : Type )? ( = Expression | = Expressionexcept LazyBooleanExpression or end with a } else BlockExpression )? ;
}
ExpressionStatement → ExpressionWithoutBlock ; | ExpressionWithBlock ;?
Syntax │ │ │ │ │ │ -SimplePath → ::? SimplePathSegment ( :: SimplePathSegment )*
SimplePathSegment → IDENTIFIER | super | self | crate | $crate
PathInExpression → ::? PathExprSegment ( :: PathExprSegment )*
PathExprSegment → PathIdentSegment ( :: GenericArgs )?
PathIdentSegment → IDENTIFIER | super | self | Self | crate | $crate
GenericArgs → < > | < ( GenericArg , )* GenericArg ,? >
GenericArg → Lifetime | Type | GenericArgsConst | GenericArgsBinding | GenericArgsBounds
GenericArgsConst → BlockExpression | LiteralExpression | - LiteralExpression | SimplePathSegment
GenericArgsBinding → IDENTIFIER GenericArgs? = Type
GenericArgsBounds → IDENTIFIER GenericArgs? : TypeParamBounds
QualifiedPathInExpression → QualifiedPathType ( :: PathExprSegment )+
QualifiedPathType → < Type ( as TypePath )? >
QualifiedPathInType → QualifiedPathType ( :: TypePathSegment )+
TypePath → ::? TypePathSegment ( :: TypePathSegment )*
TypePathSegment → PathIdentSegment ( ::? ( GenericArgs | TypePathFn ) )?
TypePathFn → ( TypePathFnInputs? ) ( -> TypeNoBounds )?
TypePathFnInputs → Type ( , Type )* ,?
ProcMacroDeriveAttribute → proc_macro_derive ( DeriveMacroName ( , DeriveMacroAttributes )? ,? )
Syntax │ │ │ - │ │ │ -MacroInvocation → SimplePath ! DelimTokenTree
DelimTokenTree → ( TokenTree* ) | [ TokenTree* ] | { TokenTree* }
TokenTree → Tokenexcept delimiters | DelimTokenTree
MacroInvocationSemi → SimplePath ! ( TokenTree* ) ; | SimplePath ! [ TokenTree* ] ; | SimplePath ! { TokenTree* }
MacroRulesDefinition → macro_rules ! IDENTIFIER MacroRulesDef
MacroRulesDef → ( MacroRules ) ; | [ MacroRules ] ; | { MacroRules }
MacroRules → MacroRule ( ; MacroRule )* ;?
MacroRule → MacroMatcher => MacroTranscriber
MacroMatcher → ( MacroMatch* ) | [ MacroMatch* ] | { MacroMatch* }
MacroMatch → Tokenexcept $ and delimiters | MacroMatcher | $ ( IDENTIFIER_OR_KEYWORDexcept crate | RAW_IDENTIFIER ) : MacroFragSpec | $ ( MacroMatch+ ) MacroRepSep? MacroRepOp
$
crate
MacroFragSpec → block | expr | expr_2021 | ident | item | lifetime | literal | meta | pat | pat_param | path | stmt | tt | ty | vis
MacroRepSep → Tokenexcept delimiters and MacroRepOp
MacroRepOp → * | + | ?
MacroTranscriber → DelimTokenTree
Syntax │ │ │ + │ │ │ +MacroRulesDefinition → macro_rules ! IDENTIFIER MacroRulesDef
MacroInvocation → SimplePath ! DelimTokenTree
Syntax │ │ │ - │ │ │ -AsmArgs → AsmAttrFormatString ( , AsmAttrFormatString )* ( , AsmAttrOperand )* ,?
FormatString → STRING_LITERAL | RAW_STRING_LITERAL | MacroInvocation
AsmAttrFormatString → ( OuterAttribute )* FormatString
AsmOperand → ClobberAbi | AsmOptions | RegOperand
AsmAttrOperand → ( OuterAttribute )* AsmOperand
ClobberAbi → clobber_abi ( Abi ( , Abi )* ,? )
AsmOptions → options ( ( AsmOption ( , AsmOption )* ,? )? )
AsmOption → pure | nomem | readonly | preserves_flags | noreturn | nostack | att_syntax | raw
RegOperand → ( ParamName = )? ( DirSpec ( RegSpec ) Expression | DualDirSpec ( RegSpec ) DualDirSpecExpression | sym PathExpression | const Expression | label { Statements? } )
ParamName → IDENTIFIER_OR_KEYWORD | RAW_IDENTIFIER
DualDirSpecExpression → Expression | Expression => Expression
RegSpec → RegisterClass | ExplicitRegister
RegisterClass → IDENTIFIER_OR_KEYWORD
ExplicitRegister → STRING_LITERAL
DirSpec → in | out | lateout
DualDirSpec → inout | inlateout
Syntax │ │ │ + │ │ │ +LiteralExpression → CHAR_LITERAL | STRING_LITERAL | RAW_STRING_LITERAL | BYTE_LITERAL | BYTE_STRING_LITERAL | RAW_BYTE_STRING_LITERAL | C_STRING_LITERAL | RAW_C_STRING_LITERAL | INTEGER_LITERAL | FLOAT_LITERAL | true | false
AwaitExpression → Expression . await
MethodCallExpression → Expression . PathExprSegment ( CallParams? )
ReturnExpression → return Expression?
ClosureExpression → async? move? ( || | | ClosureParameters? | ) ( Expression | -> TypeNoBounds BlockExpression )
ClosureParameters → ClosureParam ( , ClosureParam )* ,?
ClosureParam → OuterAttribute* PatternNoTopAlt ( : Type )?
FieldExpression → Expression . IDENTIFIER
IfExpression → if Conditions BlockExpression ( else ( BlockExpression | IfExpression ) )?
Conditions → Expressionexcept StructExpression | LetChain
LetChain → LetChainCondition ( && LetChainCondition )*
LetChainCondition → Expressionexcept ExcludedConditions | OuterAttribute* let Pattern = Scrutineeexcept ExcludedConditions
ExcludedConditions → StructExpression | LazyBooleanExpression | RangeExpr | RangeFromExpr | RangeInclusiveExpr | AssignmentExpression | CompoundAssignmentExpression
UnderscoreExpression → _
TupleExpression → ( TupleElements? )
TupleElements → ( Expression , )+ Expression?
TupleIndexingExpression → Expression . TUPLE_INDEX
ArrayExpression → [ ArrayElements? ]
ArrayElements → Expression ( , Expression )* ,? | Expression ; Expression
IndexExpression → Expression [ Expression ]
StructExpression → PathInExpression { ( StructExprFields | StructBase )? }
StructExprFields → StructExprField ( , StructExprField )* ( , StructBase | ,? )
StructExprField → OuterAttribute* ( IDENTIFIER | ( IDENTIFIER | TUPLE_INDEX ) : Expression )
StructBase → .. Expression
PathExpression → PathInExpression | QualifiedPathInExpression
RangeExpression → RangeExpr | RangeFromExpr | RangeToExpr | RangeFullExpr | RangeInclusiveExpr | RangeToInclusiveExpr
RangeExpr → Expression .. Expression
RangeFromExpr → Expression ..
RangeToExpr → .. Expression
RangeFullExpr → ..
RangeInclusiveExpr → Expression ..= Expression
RangeToInclusiveExpr → ..= Expression
MatchExpression → match Scrutinee { InnerAttribute* MatchArms? }
Scrutinee → Expressionexcept StructExpression
MatchArms → ( MatchArm => ( ExpressionWithoutBlock , | ExpressionWithBlock ,? ) )* MatchArm => Expression ,?
MatchArm → OuterAttribute* Pattern MatchArmGuard?
MatchArmGuard → if MatchConditions
MatchConditions → MatchGuardChain | Expression
MatchGuardChain → MatchGuardCondition ( && MatchGuardCondition )*
MatchGuardCondition → Expressionexcept ExcludedMatchConditions | OuterAttribute* let Pattern = MatchGuardScrutinee
MatchGuardScrutinee → Expressionexcept ExcludedMatchConditions
ExcludedMatchConditions → LazyBooleanExpression | RangeExpr | RangeFromExpr | RangeInclusiveExpr | AssignmentExpression | CompoundAssignmentExpression
LoopExpression → LoopLabel? ( InfiniteLoopExpression | PredicateLoopExpression | IteratorLoopExpression | LabelBlockExpression )
InfiniteLoopExpression → loop BlockExpression
PredicateLoopExpression → while Conditions BlockExpression
IteratorLoopExpression → for Pattern in Expressionexcept StructExpression BlockExpression
LoopLabel → LIFETIME_OR_LABEL :
BreakExpression → break LIFETIME_OR_LABEL? Expression?
LabelBlockExpression → BlockExpression
ContinueExpression → continue LIFETIME_OR_LABEL?
CallExpression → Expression ( CallParams? )
CallParams → Expression ( , Expression )* ,?
OperatorExpression → BorrowExpression | DereferenceExpression | TryPropagationExpression | NegationExpression | ArithmeticOrLogicalExpression | ComparisonExpression | LazyBooleanExpression | TypeCastExpression | AssignmentExpression | CompoundAssignmentExpression
BorrowExpression → ( & | && ) Expression | ( & | && ) mut Expression | ( & | && ) raw const Expression | ( & | && ) raw mut Expression
DereferenceExpression → * Expression
TryPropagationExpression → Expression ?
NegationExpression → - Expression | ! Expression
ArithmeticOrLogicalExpression → Expression + Expression | Expression - Expression | Expression * Expression | Expression / Expression | Expression % Expression | Expression & Expression | Expression | Expression | Expression ^ Expression | Expression << Expression | Expression >> Expression
ComparisonExpression → Expression == Expression | Expression != Expression | Expression > Expression | Expression < Expression | Expression >= Expression | Expression <= Expression
LazyBooleanExpression → Expression || Expression | Expression && Expression
TypeCastExpression → Expression as TypeNoBounds
AssignmentExpression → Expression = Expression
CompoundAssignmentExpression → Expression += Expression | Expression -= Expression | Expression *= Expression | Expression /= Expression | Expression %= Expression | Expression &= Expression | Expression |= Expression | Expression ^= Expression | Expression <<= Expression | Expression >>= Expression
GroupedExpression → ( Expression )
BlockExpression → { InnerAttribute* Statements? }
Statements → Statement+ | Statement+ ExpressionWithoutBlock | ExpressionWithoutBlock
AsyncBlockExpression → async move? BlockExpression
ConstBlockExpression → const BlockExpression
UnsafeBlockExpression → unsafe BlockExpression
Expression → ExpressionWithoutBlock | ExpressionWithBlock
ExpressionWithoutBlock → OuterAttribute* ExpressionWithoutBlockNoAttrs
ExpressionWithoutBlockNoAttrs → LiteralExpression | PathExpression | OperatorExpression | GroupedExpression | ArrayExpression | AwaitExpression | IndexExpression | TupleExpression | TupleIndexingExpression | StructExpression | CallExpression | MethodCallExpression | FieldExpression | ClosureExpression | AsyncBlockExpression | ContinueExpression | BreakExpression | RangeExpression | ReturnExpression | UnderscoreExpression | MacroInvocation
ExpressionWithBlock → OuterAttribute* ExpressionWithBlockNoAttrs
ExpressionWithBlockNoAttrs → BlockExpression | ConstBlockExpression | UnsafeBlockExpression | LoopExpression | IfExpression | MatchExpression
Syntax │ │ │ - │ │ │ -Expression → ExpressionWithoutBlock | ExpressionWithBlock
LiteralExpression → CHAR_LITERAL | STRING_LITERAL | RAW_STRING_LITERAL | BYTE_LITERAL | BYTE_STRING_LITERAL | RAW_BYTE_STRING_LITERAL | C_STRING_LITERAL | RAW_C_STRING_LITERAL | INTEGER_LITERAL | FLOAT_LITERAL | true | false
Syntax │ │ │ + │ │ │ +Statement → ; | Item | LetStatement | ExpressionStatement | OuterAttribute* MacroInvocationSemi
Syntax │ │ │ + │ │ │ +ConfigurationPredicate → ConfigurationOption | ConfigurationAll | ConfigurationAny | ConfigurationNot | true | false
Syntax │ │ │ + │ │ │ +AsmArgs → AsmAttrFormatString ( , AsmAttrFormatString )* ( , AsmAttrOperand )* ,?
Syntax │ │ │ + │ │ │ +TypeParamBounds → TypeParamBound ( + TypeParamBound )* +?
Syntax │ │ │ + │ │ │ +SimplePath → ::? SimplePathSegment ( :: SimplePathSegment )*