Annex A (informative) Grammar summary [gram]

A.6 Declarations [gram.dcl]

declaration-seq:
	declaration
	declaration-seq declaration

declaration:
	block-declaration
	nodeclspec-function-declaration
	function-definition
	template-declaration
	deduction-guide
	explicit-instantiation
	explicit-specialization
	linkage-specification
	namespace-definition
	empty-declaration
	attribute-declaration

block-declaration:
	simple-declaration
	asm-definition
	namespace-alias-definition
	using-declaration
	using-directive
	static_assert-declaration
	alias-declaration
	opaque-enum-declaration

nodeclspec-function-declaration:
	attribute-specifier-seq $_{o p t}$  declarator ;

alias-declaration:
	using identifier attribute-specifier-seq $_{o p t}$  = defining-type-id ;

simple-declaration:
	decl-specifier-seq init-declarator-list $_{o p t}$  ;
	attribute-specifier-seq decl-specifier-seq init-declarator-list ;
	attribute-specifier-seq $_{o p t}$  decl-specifier-seq ref-qualifier $_{o p t}$  [ identifier-list ] initializer ;

static_assert-declaration:
	static_assert ( constant-expression ) ;
	static_assert ( constant-expression , string-literal ) ;

empty-declaration:
	;

attribute-declaration:
	attribute-specifier-seq ;

decl-specifier:
	storage-class-specifier
	defining-type-specifier
	function-specifier
	friend
	typedef
	constexpr
	inline

decl-specifier-seq:
	decl-specifier attribute-specifier-seq $_{o p t}$ 
	decl-specifier decl-specifier-seq

storage-class-specifier:
	static
	thread_local
	extern
	mutable

function-specifier:
	virtual
	explicit

typedef-name:
	identifier

type-specifier:
	simple-type-specifier
	elaborated-type-specifier
	typename-specifier
	cv-qualifier

type-specifier-seq:
	type-specifier attribute-specifier-seq $_{o p t}$ 
	type-specifier type-specifier-seq

defining-type-specifier:
	type-specifier
	class-specifier
	enum-specifier

defining-type-specifier-seq:
	defining-type-specifier attribute-specifier-seq $_{o p t}$ 
	defining-type-specifier defining-type-specifier-seq

simple-type-specifier:
	nested-name-specifier $_{o p t}$  type-name
	nested-name-specifier template simple-template-id
	nested-name-specifier $_{o p t}$  template-name
	char
	char16_t
	char32_t
	wchar_t
	bool
	short
	int
	long
	signed
	unsigned
	float
	double
	void
	auto
	decltype-specifier

type-name:
	class-name
	enum-name
	typedef-name
	simple-template-id

decltype-specifier:
	decltype ( expression )
	decltype ( auto )

elaborated-type-specifier:
	class-key attribute-specifier-seq $_{o p t}$  nested-name-specifier $_{o p t}$  identifier
	class-key simple-template-id
	class-key nested-name-specifier template $_{o p t}$  simple-template-id
	enum nested-name-specifier $_{o p t}$  identifier

enum-name:
	identifier

enum-specifier:
	enum-head { enumerator-list $_{o p t}$  }
	enum-head { enumerator-list , }

enum-head:
	enum-key attribute-specifier-seq $_{o p t}$  enum-head-name $_{o p t}$  enum-base $_{o p t}$

enum-head-name:
	nested-name-specifier $_{o p t}$  identifier

opaque-enum-declaration:
	enum-key attribute-specifier-seq $_{o p t}$  nested-name-specifier $_{o p t}$  identifier enum-base $_{o p t}$  ;

enum-key:
	enum
	enum class
	enum struct

enum-base:
	: type-specifier-seq

enumerator-list:
	enumerator-definition
	enumerator-list , enumerator-definition

enumerator-definition:
	enumerator
	enumerator = constant-expression

enumerator:
	identifier attribute-specifier-seq $_{o p t}$

namespace-name:
	identifier
	namespace-alias

namespace-definition:
	named-namespace-definition
	unnamed-namespace-definition
	nested-namespace-definition

named-namespace-definition:
	inline $_{o p t}$  namespace attribute-specifier-seq $_{o p t}$  identifier { namespace-body }

unnamed-namespace-definition:
	inline $_{o p t}$  namespace attribute-specifier-seq $_{o p t}$  { namespace-body }

nested-namespace-definition:
	namespace enclosing-namespace-specifier :: identifier { namespace-body }

enclosing-namespace-specifier:
	identifier
	enclosing-namespace-specifier :: identifier

namespace-body:
	declaration-seq $_{o p t}$

namespace-alias:
	identifier

namespace-alias-definition:
	namespace identifier = qualified-namespace-specifier ;

qualified-namespace-specifier:
	nested-name-specifier $_{o p t}$  namespace-name

using-declaration:
	using using-declarator-list ;

using-declarator-list:
	using-declarator ... $_{o p t}$ 
	using-declarator-list , using-declarator ... $_{o p t}$

using-declarator:
	typename $_{o p t}$  nested-name-specifier unqualified-id

using-directive:
	attribute-specifier-seq $_{o p t}$  using  namespace nested-name-specifier $_{o p t}$  namespace-name ;

asm-definition:
	attribute-specifier-seq $_{o p t}$  asm ( string-literal ) ;

linkage-specification:
	extern string-literal { declaration-seq $_{o p t}$  }
	extern string-literal declaration

attribute-specifier-seq:
	attribute-specifier-seq $_{o p t}$  attribute-specifier

attribute-specifier:
	[ [ attribute-using-prefix $_{o p t}$  attribute-list ] ]
	alignment-specifier

alignment-specifier:
	alignas ( type-id ... $_{o p t}$  )
	alignas ( constant-expression ... $_{o p t}$  )

attribute-using-prefix:
	using attribute-namespace :

attribute-list:
	attribute $_{o p t}$ 
	attribute-list , attribute $_{o p t}$ 
	attribute ...
	attribute-list , attribute ...

attribute:
	attribute-token attribute-argument-clause $_{o p t}$

attribute-token:
	identifier
	attribute-scoped-token

attribute-scoped-token:
	attribute-namespace :: identifier

attribute-namespace:
	identifier

attribute-argument-clause:
	( balanced-token-seq $_{o p t}$  )

balanced-token-seq:
	balanced-token
	balanced-token-seq balanced-token

balanced-token:
	( balanced-token-seq $_{o p t}$  )
	[ balanced-token-seq $_{o p t}$  ]
	{ balanced-token-seq $_{o p t}$  }
	any token other than a parenthesis, a bracket, or a brace