Annex A (informative) Grammar summary [gram]

primary-expression:
literal
this
( expression )
id-expression
lambda-expression
fold-expression
requires-expression

id-expression:
unqualified-id
qualified-id
pack-index-expression

unqualified-id:
identifier
operator-function-id
conversion-function-id
literal-operator-id
~ type-name
~ computed-type-specifier
template-id

qualified-id:
nested-name-specifier template${}_{opt}$ unqualified-id

nested-name-specifier:
::
type-name ::
namespace-name ::
computed-type-specifier ::
nested-name-specifier identifier ::
nested-name-specifier template${}_{opt}$ simple-template-id ::

pack-index-expression:
id-expression ... [ constant-expression ]

lambda-expression:
lambda-introducer attribute-specifier-seq${}_{opt}$ lambda-declarator compound-statement
lambda-introducer < template-parameter-list > requires-clause${}_{opt}$ attribute-specifier-seq${}_{opt}$
   lambda-declarator compound-statement

lambda-introducer:
[ lambda-capture${}_{opt}$ ]

lambda-declarator:
lambda-specifier-seq noexcept-specifier${}_{opt}$ attribute-specifier-seq${}_{opt}$ trailing-return-type${}_{opt}$
noexcept-specifier attribute-specifier-seq${}_{opt}$ trailing-return-type${}_{opt}$
trailing-return-type${}_{opt}$
( parameter-declaration-clause ) lambda-specifier-seq${}_{opt}$ noexcept-specifier${}_{opt}$ attribute-specifier-seq${}_{opt}$
   trailing-return-type${}_{opt}$ requires-clause${}_{opt}$

lambda-specifier:
consteval
constexpr
mutable
static

lambda-specifier-seq:
lambda-specifier
lambda-specifier lambda-specifier-seq

lambda-capture:
capture-default
capture-list
capture-default , capture-list

capture-default:
&
=

capture-list:
capture
capture-list , capture

capture:
simple-capture
init-capture

simple-capture:
identifier ...${}_{opt}$
& identifier ...${}_{opt}$
this
* this

init-capture:
...${}_{opt}$ identifier initializer
& ...${}_{opt}$ identifier initializer

fold-expression:
( cast-expression fold-operator ... )
( ... fold-operator cast-expression )
( cast-expression fold-operator ... fold-operator cast-expression )

fold-operator: one of
+   -   *   /   %   ^   &   |   <<   >>
+=  -=  *=  /=  %=  ^=  &=  |=  <<=  >>=  =
==  !=  <   >   <=  >=  &&  ||  ,   .*   ->*

requires-expression:
requires requirement-parameter-list${}_{opt}$ requirement-body

requirement-parameter-list:
( parameter-declaration-clause )

requirement-body:
{ requirement-seq }

requirement-seq:
requirement
requirement requirement-seq

requirement:
simple-requirement
type-requirement
compound-requirement
nested-requirement

simple-requirement:
expression ;

type-requirement:
typename nested-name-specifier${}_{opt}$ type-name ;

compound-requirement:
{ expression } noexcept${}_{opt}$ return-type-requirement${}_{opt}$ ;

return-type-requirement:
-> type-constraint

nested-requirement:
requires constraint-expression ;

postfix-expression:
primary-expression
postfix-expression [ expression-list${}_{opt}$ ]
postfix-expression ( expression-list${}_{opt}$ )
simple-type-specifier ( expression-list${}_{opt}$ )
typename-specifier ( expression-list${}_{opt}$ )
simple-type-specifier braced-init-list
typename-specifier braced-init-list
postfix-expression . template${}_{opt}$ id-expression
postfix-expression -> template${}_{opt}$ id-expression
postfix-expression ++
postfix-expression --
dynamic_cast < type-id > ( expression )
static_cast < type-id > ( expression )
reinterpret_cast < type-id > ( expression )
const_cast < type-id > ( expression )
typeid ( expression )
typeid ( type-id )

expression-list:
initializer-list

unary-expression:
postfix-expression
unary-operator cast-expression
++ cast-expression
-- cast-expression
await-expression
sizeof unary-expression
sizeof ( type-id )
sizeof ... ( identifier )
alignof ( type-id )
noexcept-expression
new-expression
delete-expression

unary-operator: one of
* & + - ! ~

await-expression:
co_await cast-expression

noexcept-expression:
noexcept ( expression )

new-expression:
::${}_{opt}$ new new-placement${}_{opt}$ new-type-id new-initializer${}_{opt}$
::${}_{opt}$ new new-placement${}_{opt}$ ( type-id ) new-initializer${}_{opt}$

new-placement:
( expression-list )

new-type-id:
type-specifier-seq new-declarator${}_{opt}$

new-declarator:
ptr-operator new-declarator${}_{opt}$
noptr-new-declarator

noptr-new-declarator:
[ expression${}_{opt}$ ] attribute-specifier-seq${}_{opt}$
noptr-new-declarator [ constant-expression ] attribute-specifier-seq${}_{opt}$

new-initializer:
( expression-list${}_{opt}$ )
braced-init-list

delete-expression:
::${}_{opt}$ delete cast-expression
::${}_{opt}$ delete [ ] cast-expression

cast-expression:
unary-expression
( type-id ) cast-expression

pm-expression:
cast-expression
pm-expression .* cast-expression
pm-expression ->* cast-expression

multiplicative-expression:
pm-expression
multiplicative-expression * pm-expression
multiplicative-expression / pm-expression
multiplicative-expression % pm-expression

additive-expression:
multiplicative-expression
additive-expression + multiplicative-expression
additive-expression - multiplicative-expression

shift-expression:
additive-expression
shift-expression << additive-expression
shift-expression >> additive-expression

compare-expression:
shift-expression
compare-expression <=> shift-expression

relational-expression:
compare-expression
relational-expression < compare-expression
relational-expression > compare-expression
relational-expression <= compare-expression
relational-expression >= compare-expression

equality-expression:
relational-expression
equality-expression == relational-expression
equality-expression != relational-expression

and-expression:
equality-expression
and-expression & equality-expression

exclusive-or-expression:
and-expression
exclusive-or-expression ^ and-expression

inclusive-or-expression:
exclusive-or-expression
inclusive-or-expression | exclusive-or-expression

logical-and-expression:
inclusive-or-expression
logical-and-expression && inclusive-or-expression

logical-or-expression:
logical-and-expression
logical-or-expression || logical-and-expression

conditional-expression:
logical-or-expression
logical-or-expression ? expression : assignment-expression

yield-expression:
co_yield assignment-expression
co_yield braced-init-list

throw-expression:
throw assignment-expression${}_{opt}$

assignment-expression:
conditional-expression
yield-expression
throw-expression
logical-or-expression assignment-operator initializer-clause

assignment-operator: one of
= *= /= %= += -= >>= <<= &= ^= |=

expression:
assignment-expression
expression , assignment-expression

constant-expression:
conditional-expression