Grammar summary - The Rust Reference

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Grammar summary

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

## Lexer summary

Lexer
CHAR → <a Unicode scalar value>

NUL → U+0000

LINE_COMMENT →
// ( ~[/ ! LF] | // ) ~LF*
| //

BLOCK_COMMENT →
/*
( ~[* !] | ** | BLOCK_COMMENT_OR_DOC )
( BLOCK_COMMENT_OR_DOC | ~*/ )*
*/
| /**/
| /***/

INNER_LINE_DOC →
//! ~[LF CR]*

INNER_BLOCK_DOC →
/*! ( BLOCK_COMMENT_OR_DOC | ~[*/ CR] )* */

OUTER_LINE_DOC →
/// ( ~/ ~[LF CR]* )?

OUTER_BLOCK_DOC →
/**
( ~* | BLOCK_COMMENT_OR_DOC )
( BLOCK_COMMENT_OR_DOC | ~[*/ CR] )*
*/

BLOCK_COMMENT_OR_DOC →
BLOCK_COMMENT
| OUTER_BLOCK_DOC
| INNER_BLOCK_DOC

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 → IDENTIFIER_OR_KEYWORDexcept `_`

SUFFIX_NO_E → SUFFIXnot beginning with `e` or `E`

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?

RAW_STRING_CONTENT →
" ( ~CR )* (non-greedy) "
| # RAW_STRING_CONTENT #

BYTE_LITERAL →
b' ( ASCII_FOR_CHAR | BYTE_ESCAPE ) ' SUFFIX?

ASCII_FOR_CHAR →
<any ASCII (i.e. 0x00 to 0x7F) except `'`, `\`, LF, CR, or TAB>

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 →
<any ASCII (i.e 0x00 to 0x7F) except `"`, `\`, or CR>

RAW_BYTE_STRING_LITERAL →
br RAW_BYTE_STRING_CONTENT SUFFIX?

RAW_BYTE_STRING_CONTENT →
" ASCII_FOR_RAW* (non-greedy) "
| # RAW_BYTE_STRING_CONTENT #

ASCII_FOR_RAW →
<any ASCII (i.e. 0x00 to 0x7F) except CR>

C_STRING_LITERAL →
c" (
~[" \ CR NUL]
| BYTE_ESCAPEexcept `\0` or `\x00`
| UNICODE_ESCAPEexcept `\u{0}`, `\u{00}`, …, `\u{000000}`
| STRING_CONTINUE
)* " SUFFIX?

RAW_C_STRING_LITERAL →
cr RAW_C_STRING_CONTENT SUFFIX?

RAW_C_STRING_CONTENT →
" ( ~[CR NUL] )* (non-greedy) "
| # RAW_C_STRING_CONTENT #

INTEGER_LITERAL →
( BIN_LITERAL | OCT_LITERAL | HEX_LITERAL | DEC_LITERAL ) SUFFIX_NO_E?

DEC_LITERAL → DEC_DIGIT ( DEC_DIGIT | _ )*

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

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

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]

TUPLE_INDEX → DEC_LITERAL | BIN_LITERAL | OCT_LITERAL | HEX_LITERAL

FLOAT_LITERAL →
DEC_LITERAL ( . DEC_LITERAL )? FLOAT_EXPONENT SUFFIX?
| DEC_LITERAL . DEC_LITERAL SUFFIX_NO_E?
| DEC_LITERAL .not immediately followed by `.`, `_` or an XID_Start character

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

RESERVED_NUMBER →
BIN_LITERAL [2-9]
| OCT_LITERAL [8-9]
| ( BIN_LITERAL | OCT_LITERAL | HEX_LITERAL ) .not immediately followed by `.`, `_` or an XID_Start character
| ( BIN_LITERAL | OCT_LITERAL ) ( e | E )
| 0b _* <end of input or not BIN_DIGIT>
| 0o _* <end of input or not OCT_DIGIT>
| 0x _* <end of input or not HEX_DIGIT>
| DEC_LITERAL ( . DEC_LITERAL )? ( e | E ) ( + | - )? <end of input or not DEC_DIGIT>

LIFETIME_TOKEN →
RAW_LIFETIME
| ' IDENTIFIER_OR_KEYWORDnot immediately followed by `'`

LIFETIME_OR_LABEL →
RAW_LIFETIME
| ' NON_KEYWORD_IDENTIFIERnot immediately followed by `'`

RAW_LIFETIME →
'r# IDENTIFIER_OR_KEYWORDnot immediately followed by `'`

RESERVED_RAW_LIFETIME → 'r# ( _ | crate | self | Self | super )not immediately followed by `'`

PUNCTUATION →
...
| ..=
| <<=
| >>=
| !=
| %=
| &&
| &=
| *=
| +=
| -=
| ->
| ..
| /=
| ::
| <-
| <<
| <=
| ==
| =>
| >=
| >>
| >
| ^=
| |=
| ||
| !
| #
| $
| %
| &
| (
| )
| *
| +
| ,
| -
| .
| /
| :
| ;
| <
| =
| ?
| @
| [
| ]
| ^
| {
| |
| }
| ~

RESERVED_TOKEN →
RESERVED_GUARDED_STRING_LITERAL
| RESERVED_NUMBER
| 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` "

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

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_KEYWORDexcept a strict or reserved keyword

IDENTIFIER → NON_KEYWORD_IDENTIFIER | RAW_IDENTIFIER

RESERVED_RAW_IDENTIFIER →
r# ( _ | crate | self | Self | super )not immediately followed by XID_Continue

## Macros summary

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

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

## 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

## Items summary

Syntax
Crate →
InnerAttribute*
Item*

Item →
OuterAttribute* ( VisItem | MacroItem )

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

MacroItem →
MacroInvocationSemi
| MacroRulesDefinition

StaticItem →
ItemSafety? static mut? 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

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

Implementation → InherentImpl | TraitImpl

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

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

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

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

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

ExternCrate → extern crate CrateRef AsClause? ;

CrateRef → IDENTIFIER | self

AsClause → as ( IDENTIFIER | _ )

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

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?

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

UseDeclaration → use UseTree ;

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

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

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

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

EnumVariants → EnumVariant ( , EnumVariant )* ,?

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

EnumVariantTuple → ( TupleFields? )

EnumVariantStruct → { StructFields? }

EnumVariantDiscriminant → = Expression

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

## Miscellaneous summary

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

## 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 →
< >
| < ( 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 )* ,?

## Statements summary

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

LetStatement →
OuterAttribute* let PatternNoTopAlt ( : Type )?
(
= Expression
| = Expressionexcept LazyBooleanExpression or end with a `}` else BlockExpression
)? ;

ExpressionStatement →
ExpressionWithoutBlock ;
| ExpressionWithBlock ;?

## Attributes summary

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

DeriveMacroName → IDENTIFIER

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

CollapseDebuginfoAttribute → collapse_debuginfo ( CollapseDebuginfoOption )

CollapseDebuginfoOption →
yes
| no
| external

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

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

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

## 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
TupleType →
( )
| ( ( Type , )+ Type? )

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 ]

NeverType → !

InferredType → _

TraitObjectType → dyn? TypeParamBounds

TraitObjectTypeOneBound → dyn? TraitBound

SliceType → [ Type ]

ReferenceType → & Lifetime? mut? TypeNoBounds

RawPointerType → * ( mut | const ) TypeNoBounds

ImplTraitType → impl TypeParamBounds

ImplTraitTypeOneBound → impl TraitBound

Type →
TypeNoBounds
| ImplTraitType
| TraitObjectType

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

ParenthesizedType → ( Type )

## Expressions summary

Syntax
ReturnExpression → return Expression?

FieldExpression → Expression . IDENTIFIER

StructExpression →
PathInExpression { ( StructExprFields | StructBase )? }

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

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

StructBase → .. Expression

ArrayExpression → [ ArrayElements? ]

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

IndexExpression → Expression [ Expression ]

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

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

ClosureParameters → ClosureParam ( , ClosureParam )* ,?

ClosureParam → OuterAttribute* PatternNoTopAlt ( : Type )?

MatchExpression →
match Scrutinee {
InnerAttribute*
MatchArms?
}

Scrutinee → Expressionexcept StructExpression

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

MatchArm → OuterAttribute* Pattern MatchArmGuard?

MatchArmGuard → if Expression

AwaitExpression → Expression . await

UnderscoreExpression → _

MethodCallExpression → Expression . PathExprSegment ( CallParams? )

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

PathExpression →
PathInExpression
| QualifiedPathInExpression

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

BlockExpression →
{
InnerAttribute*
Statements?
}

Statements →
Statement+
| Statement+ ExpressionWithoutBlock
| ExpressionWithoutBlock

AsyncBlockExpression → async move? BlockExpression

ConstBlockExpression → const BlockExpression

UnsafeBlockExpression → unsafe BlockExpression

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

RangeExpr → Expression .. Expression

RangeFromExpr → Expression ..

RangeToExpr → .. Expression

RangeFullExpr → ..

RangeInclusiveExpr → Expression ..= Expression

RangeToInclusiveExpr → ..= Expression

TupleExpression → ( TupleElements? )

TupleElements → ( Expression , )+ Expression?

TupleIndexingExpression → Expression . TUPLE_INDEX

GroupedExpression → ( Expression )

CallExpression → Expression ( CallParams? )

CallParams → Expression ( , Expression )* ,?

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?

Expression →
ExpressionWithoutBlock
| ExpressionWithBlock

ExpressionWithoutBlock →
OuterAttribute*
(
LiteralExpression
| PathExpression
| OperatorExpression
| GroupedExpression
| ArrayExpression
| AwaitExpression
| IndexExpression
| TupleExpression
| TupleIndexingExpression
| StructExpression
| CallExpression
| MethodCallExpression
| FieldExpression
| ClosureExpression
| AsyncBlockExpression
| ContinueExpression
| BreakExpression
| RangeExpression
| ReturnExpression
| UnderscoreExpression
| MacroInvocation
)

ExpressionWithBlock →
OuterAttribute*
(
BlockExpression
| ConstBlockExpression
| UnsafeBlockExpression
| LoopExpression
| IfExpression
| MatchExpression
)