Grammar summary

The following is a summary of the grammar production rules. For details on the syntax of this grammar, see notation.grammar.syntax.

Expressions summary

^Syntax
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

PathExpression →
PathInExpression
| QualifiedPathInExpression

MethodCallExpression → Expression . PathExprSegment ( CallParams^? )

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

CallExpression → Expression ( CallParams^? )

CallParams → Expression ( , Expression )^* ,^?

ReturnExpression → return Expression^?

GroupedExpression → ( Expression )

UnderscoreExpression → _

AwaitExpression → Expression . await

FieldExpression → Expression . IDENTIFIER

LoopExpression →
    LoopLabel^? (
        InfiniteLoopExpression
      | PredicateLoopExpression
      | IteratorLoopExpression
      | LabelBlockExpression
    )

InfiniteLoopExpression → loop BlockExpression

PredicateLoopExpression → while Conditions BlockExpression

IteratorLoopExpression →
for Pattern in Expression_{except StructExpression} BlockExpression

LoopLabel → LIFETIME_OR_LABEL :

BreakExpression → break LIFETIME_OR_LABEL^? Expression^?

LabelBlockExpression → BlockExpression

ContinueExpression → continue LIFETIME_OR_LABEL^?

StructExpression →
PathInExpression { ( StructExprFields | StructBase )^? }

StructExprFields →
StructExprField ( , StructExprField )^* ( , StructBase | ,^? )

StructExprField →
    OuterAttribute^*
    (
        IDENTIFIER
      | ( IDENTIFIER | TUPLE_INDEX ) : Expression
    )

StructBase → .. Expression

ClosureExpression →
    async^?
    move^?
    ( || | | ClosureParameters^? | )
    ( Expression | -> TypeNoBounds BlockExpression )

ClosureParameters → ClosureParam ( , ClosureParam )^* ,^?

ClosureParam → OuterAttribute^* PatternNoTopAlt ( : Type )^?

BlockExpression →
    {
        InnerAttribute^*
        Statements^?
    }

Statements →
      Statement⁺
    | Statement⁺ ExpressionWithoutBlock
    | ExpressionWithoutBlock

AsyncBlockExpression → async move^? BlockExpression

ConstBlockExpression → const BlockExpression

UnsafeBlockExpression → unsafe BlockExpression

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

MatchExpression →
    match Scrutinee {
        InnerAttribute^*
        MatchArms^?
    }

Scrutinee → Expression_{except StructExpression}

MatchArms →
( MatchArm => ( ExpressionWithoutBlock , | ExpressionWithBlock ,^? ) )^*
MatchArm => Expression ,^?

MatchArm → OuterAttribute^* Pattern MatchArmGuard^?

MatchArmGuard → if MatchConditions

MatchConditions →
MatchGuardChain
| Expression

MatchGuardChain → MatchGuardCondition ( && MatchGuardCondition )^*

MatchGuardCondition →
Expression_{except ExcludedMatchConditions}
| OuterAttribute^* let Pattern = MatchGuardScrutinee

MatchGuardScrutinee → Expression_{except ExcludedMatchConditions}

ExcludedMatchConditions →
      LazyBooleanExpression
    | RangeExpr
    | RangeFromExpr
    | RangeInclusiveExpr
    | AssignmentExpression
    | CompoundAssignmentExpression

IfExpression →
if Conditions BlockExpression
( else ( BlockExpression | IfExpression ) )^?

Conditions →
Expression_{except StructExpression}
| LetChain

LetChain → LetChainCondition ( && LetChainCondition )^*

LetChainCondition →
Expression_{except ExcludedConditions}
| OuterAttribute^* let Pattern = Scrutinee_{except ExcludedConditions}

ExcludedConditions →
      StructExpression
    | LazyBooleanExpression
    | RangeExpr
    | RangeFromExpr
    | RangeInclusiveExpr
    | AssignmentExpression
    | CompoundAssignmentExpression

ArrayExpression → [ ArrayElements^? ]

ArrayElements →
Expression ( , Expression )^* ,^?
| Expression ; Expression

IndexExpression → Expression [ Expression ]

TupleExpression → ( TupleElements^? )

TupleElements → ( Expression , )⁺ Expression^?

TupleIndexingExpression → Expression . TUPLE_INDEX

RangeExpression →
      RangeExpr
    | RangeFromExpr
    | RangeToExpr
    | RangeFullExpr
    | RangeInclusiveExpr
    | RangeToInclusiveExpr

RangeExpr → Expression .. Expression

RangeFromExpr → Expression ..

RangeToExpr → .. Expression

RangeFullExpr → ..

RangeInclusiveExpr → Expression ..= Expression

RangeToInclusiveExpr → ..= Expression

Macros summary

^Syntax
MacroInvocation →
SimplePath ! DelimTokenTree

DelimTokenTree →
      ( TokenTree^* )
    | [ TokenTree^* ]
    | { TokenTree^* }

TokenTree →
Token_{except 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 →
      Token_{except $ and delimiters}
    | MacroMatcher
    | $ ( IDENTIFIER_OR_KEYWORD_{except crate} | RAW_IDENTIFIER ) : MacroFragSpec
    | $ ( MacroMatch⁺ ) MacroRepSep^? MacroRepOp

MacroFragSpec →
block | expr | expr_2021 | ident | item | lifetime | literal
| meta | pat | pat_param | path | stmt | tt | ty | vis

MacroRepSep → Token_{except delimiters and MacroRepOp}

MacroRepOp → * | + | ?

MacroTranscriber → DelimTokenTree

Lexer summary

^Lexer
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

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

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..=6_{valid 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 " #ⁿ SUFFIX^?

RAW_STRING_CONTENT → ( !" ~CR )^*

RAW_STRING_CONTENT_HASHED → ( !( " #ⁿ ) ~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 " #ⁿ SUFFIX^?

RAW_BYTE_STRING_CONTENT → ( !" ASCII_FOR_RAW )^*

RAW_BYTE_STRING_CONTENT_HASHED → ( !( " #ⁿ ) ASCII_FOR_RAW )^*

ASCII_FOR_RAW → !CR ASCII

C_STRING_LITERAL →
    c" ^ (
        ~[" \ CR NUL]
      | BYTE_ESCAPE_{except \0 or \x00}
      | UNICODE_ESCAPE_{except \u{0}, \u{00}, …, \u{000000}}
      | STRING_CONTINUE
    )^* " SUFFIX^?

RAW_C_STRING_LITERAL →
cr " ^ RAW_C_STRING_CONTENT " SUFFIX^?
| cr #^n:1..=255 ^ " RAW_C_STRING_CONTENT_HASHED " #ⁿ SUFFIX^?

RAW_C_STRING_CONTENT → ( !" ~[CR NUL] )^*

RAW_C_STRING_CONTENT_HASHED → ( !( " #ⁿ ) ~[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_KEYWORD_{except b or c or r or br or cr} "

RESERVED_TOKEN_SINGLE_QUOTE →
IDENTIFIER_OR_KEYWORD_{except b} '

RESERVED_TOKEN_POUND →
IDENTIFIER_OR_KEYWORD_{except r or br or cr} #

RESERVED_TOKEN_LIFETIME →
' IDENTIFIER_OR_KEYWORD_{except r} #

RESERVED_GUARDED_STRING_LITERAL → #⁺ STRING_LITERAL

RESERVED_POUNDS → #^2..

IDENTIFIER_OR_KEYWORD → ( XID_Start | _ ) XID_Continue^*

XID_Start → <XID_Start defined by Unicode>

XID_Continue → <XID_Continue defined by Unicode>

RAW_IDENTIFIER → r# IDENTIFIER_OR_KEYWORD

NON_KEYWORD_IDENTIFIER → IDENTIFIER_OR_KEYWORD_{except a strict or reserved keyword}

IDENTIFIER → NON_KEYWORD_IDENTIFIER | RAW_IDENTIFIER

RESERVED_RAW_IDENTIFIER →
r# ( _ | crate | self | Self | super ) !XID_Continue

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

SHEBANG →
#! !( ( WHITESPACE | LINE_COMMENT | BLOCK_COMMENT )^* [ )
~LF^* ( LF | EOF )

Attributes summary

^Syntax
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 )^* ,^? )^? )

ProcMacroDeriveAttribute →
proc_macro_derive ( DeriveMacroName ( , DeriveMacroAttributes )^? ,^? )

DeriveMacroName → IDENTIFIER

DeriveMacroAttributes →
attributes ( ( IDENTIFIER ( , IDENTIFIER )^* ,^? )^? )

InlineAttribute →
      inline ( always )
    | inline ( never )
    | inline

CollapseDebuginfoAttribute → collapse_debuginfo ( CollapseDebuginfoOption )

CollapseDebuginfoOption →
      yes
    | no
    | external

Items summary

^Syntax
Item →
OuterAttribute^* ( VisItem | MacroItem )

VisItem →
    Visibility^?
    (
        Module
      | ExternCrate
      | UseDeclaration
      | Function
      | TypeAlias
      | Struct
      | Enumeration
      | Union
      | ConstantItem
      | StaticItem
      | Trait
      | Implementation
      | ExternBlock
    )

MacroItem →
MacroInvocationSemi
| MacroRulesDefinition

Crate →
InnerAttribute^*
Item^*

AssociatedItem →
    OuterAttribute^* (
        MacroInvocationSemi
      | ( Visibility^? ( TypeAlias | ConstantItem | Function ) )
    )

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

ConstantItem →
const ( IDENTIFIER | _ ) : Type ( = Expression )^? ;

GenericParams → < ( GenericParam ( , GenericParam )^* ,^? )^? >

GenericParam → OuterAttribute^* ( LifetimeParam | TypeParam | ConstParam )

LifetimeParam → Lifetime ( : LifetimeBounds )^?

TypeParam → IDENTIFIER ( : Bounds^? )^? ( = Type )^?

ConstParam →
const IDENTIFIER : Type
( = ( BlockExpression | IDENTIFIER | -^? LiteralExpression ) )^?

WhereClause → where ( WhereClauseItem , )^* WhereClauseItem^?

WhereClauseItem →
LifetimeWhereClauseItem
| TypeBoundWhereClauseItem

LifetimeWhereClauseItem → Lifetime : LifetimeBounds

TypeBoundWhereClauseItem → ForLifetimes^? Type : Bounds^?

Union →
union IDENTIFIER GenericParams^? WhereClause^? { StructFields^? }

Enumeration →
enum IDENTIFIER GenericParams^? WhereClause^? { EnumVariants^? }

EnumVariants → EnumVariant ( , EnumVariant )^* ,^?

EnumVariant →
OuterAttribute^* Visibility^?
IDENTIFIER ( EnumVariantTuple | EnumVariantStruct )^? EnumVariantDiscriminant^?

EnumVariantTuple → ( TupleFields^? )

EnumVariantStruct → { StructFields^? }

EnumVariantDiscriminant → = Expression

ExternCrate → extern crate CrateRef AsClause^? ;

CrateRef → IDENTIFIER | self

AsClause → as ( IDENTIFIER | _ )

Module →
      unsafe^? mod IDENTIFIER ;
    | unsafe^? mod IDENTIFIER {
        InnerAttribute^*
        Item^*
      }

UseDeclaration → use UseTree ;

UseTree →
      ( SimplePath^? :: )^? *
    | ( SimplePath^? :: )^? { ( UseTree ( , UseTree )^* ,^? )^? }
    | SimplePath ( as ( IDENTIFIER | _ ) )^?

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

Trait →
    unsafe^? trait IDENTIFIER GenericParams^? ( : Bounds^? )^? WhereClause^?
    {
        InnerAttribute^*
        AssociatedItem^*
    }

Implementation → InherentImpl | TraitImpl

InherentImpl →
    impl GenericParams^? Type WhereClause^? {
        InnerAttribute^*
        AssociatedItem^*
    }

TraitImpl →
    unsafe^? impl GenericParams^? !^? TypePath for Type
    WhereClause^?
    {
        InnerAttribute^*
        AssociatedItem^*
    }

TypeAlias →
    type IDENTIFIER GenericParams^? ( : Bounds )^?
        WhereClause^?
        ( = Type WhereClause^? )^? ;

StaticItem →
ItemSafety^? static mut^? IDENTIFIER : Type ( = Expression )^? ;

ExternBlock →
    unsafe^? extern Abi^? {
        InnerAttribute^*
        ExternalItem^*
    }

ExternalItem →
    OuterAttribute^* (
        MacroInvocationSemi
      | Visibility^? StaticItem
      | Visibility^? Function
    )

Visibility →
      pub
    | pub ( crate )
    | pub ( self )
    | pub ( super )
    | pub ( in SimplePath )

Patterns summary

^Syntax
Pattern → |^? PatternNoTopAlt ( | PatternNoTopAlt )^*

PatternNoTopAlt →
PatternWithoutRange
| RangePattern

PatternWithoutRange →
      LiteralPattern
    | IdentifierPattern
    | WildcardPattern
    | RestPattern
    | ReferencePattern
    | StructPattern
    | TupleStructPattern
    | TuplePattern
    | GroupedPattern
    | SlicePattern
    | PathPattern
    | MacroInvocation

LiteralPattern → -^? LiteralExpression

IdentifierPattern → ref^? mut^? IDENTIFIER ( @ PatternNoTopAlt )^?

WildcardPattern → _

RestPattern → ..

RangePattern →
      RangeExclusivePattern
    | RangeInclusivePattern
    | RangeFromPattern
    | RangeToExclusivePattern
    | RangeToInclusivePattern
    | ObsoleteRangePattern

RangeExclusivePattern →
RangePatternBound .. RangePatternBound

RangeInclusivePattern →
RangePatternBound ..= RangePatternBound

RangeFromPattern →
RangePatternBound ..

RangeToExclusivePattern →
.. RangePatternBound

RangeToInclusivePattern →
..= RangePatternBound

ObsoleteRangePattern →
RangePatternBound ... RangePatternBound

RangePatternBound →
LiteralPattern
| PathExpression

ReferencePattern → ( & | && ) mut^? PatternWithoutRange

StructPattern →
    PathInExpression {
        StructPatternElements^?
    }

StructPatternElements →
StructPatternFields ( , | , StructPatternEtCetera )^?
| StructPatternEtCetera

StructPatternFields →
StructPatternField ( , StructPatternField )^*

StructPatternField →
    OuterAttribute^*
    (
        TUPLE_INDEX : Pattern
      | IDENTIFIER : Pattern
      | ref^? mut^? IDENTIFIER
    )

StructPatternEtCetera → ..

TupleStructPattern → PathInExpression ( TupleStructItems^? )

TupleStructItems → Pattern ( , Pattern )^* ,^?

TuplePattern → ( TuplePatternItems^? )

TuplePatternItems →
      Pattern ,
    | RestPattern
    | Pattern ( , Pattern )⁺ ,^?

GroupedPattern → ( Pattern )

SlicePattern → [ SlicePatternItems^? ]

SlicePatternItems → Pattern ( , Pattern )^* ,^?

PathPattern → PathExpression

Assembly summary

^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

Types summary

^Syntax
ReferenceType → & Lifetime^? mut^? TypeNoBounds

RawPointerType → * ( mut | const ) TypeNoBounds

ArrayType → [ Type ; Expression ]

TraitObjectType → dyn^? Bounds

TraitObjectTypeOneBound → dyn^? TraitBound

TupleType →
( )
| ( ( Type , )⁺ Type^? )

SliceType → [ Type ]

NeverType → !

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^* ...

ImplTraitType → impl Bounds

ImplTraitTypeOneBound → impl TraitBound

InferredType → _

Type →
      TypeNoBounds
    | ImplTraitType
    | TraitObjectType

TypeNoBounds →
      ParenthesizedType
    | ImplTraitTypeOneBound
    | TraitObjectTypeOneBound
    | TypePath
    | TupleType
    | NeverType
    | RawPointerType
    | ReferenceType
    | ArrayType
    | SliceType
    | InferredType
    | QualifiedPathInType
    | BareFunctionType
    | MacroInvocation

ParenthesizedType → ( Type )

Paths summary

^Syntax
SimplePath →
::^? SimplePathSegment ( :: SimplePathSegment )^*

SimplePathSegment →
IDENTIFIER | super | self | crate | $crate

PathInExpression →
::^? PathExprSegment ( :: PathExprSegment )^*

PathExprSegment →
PathIdentSegment ( :: GenericArgs )^?

PathIdentSegment →
IDENTIFIER | super | self | Self | crate | $crate

GenericArgs →
< GenericArgList^? >
| ( TypeList^? ) ( -> TypeNoBounds )^?

GenericArgList →
( GenericArg , )^* GenericArg ,^?

TypeList →
( Type , )^* Type ,^?

GenericArg →
Lifetime | Type | GenericArgsConst | GenericArgsBinding | GenericArgsBounds

GenericArgsConst →
      BlockExpression
    | LiteralExpression
    | - LiteralExpression
    | SimplePathSegment

GenericArgsBinding →
TypePathSegment = Type

GenericArgsBounds →
TypePathSegment : Bounds

QualifiedPathInExpression → QualifiedPathType ( :: PathExprSegment )⁺

QualifiedPathType → < Type ( as TypePath )^? >

QualifiedPathInType → QualifiedPathType ( :: TypePathSegment )⁺

TypePath → ::^? TypePathSegment ( :: TypePathSegment )^*

TypePathSegment → PathIdentSegment ( ::^? GenericArgs )^?

Configuration summary

^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 | _

Statements summary

^Syntax
Statement →
      ;
    | Item
    | LetStatement
    | ExpressionStatement
    | OuterAttribute^* MacroInvocationSemi

LetStatement →
    OuterAttribute^* let PatternNoTopAlt ( : Type )^?
    (
          = Expression
        | = Expression_{except LazyBooleanExpression or end with a }} else BlockExpression
    )^? ;

ExpressionStatement →
ExpressionWithoutBlock ;
| ExpressionWithBlock ;^?

Miscellaneous summary

^Syntax
Bounds → Bound ( + Bound )^* +^?

Bound → 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