[dcl.decl] - C++23 → Trunk

Files changed (1) hide show

tmp/tmppwnft8oz/{from.md → to.md} +169 -110

tmp/tmppwnft8oz/{from.md → to.md} RENAMED Viewed

@@ -13,23 +13,23 @@ init-declarator-list:
     init-declarator-list ',' init-declarator
 ```
 ``` bnf
 init-declarator:
-    declarator initializerₒₚₜ
-    declarator requires-clause
 ```
 In all contexts, a *declarator* is interpreted as given below. Where an
 *abstract-declarator* can be used (or omitted) in place of a
 *declarator* [[dcl.fct]], [[except.pre]], it is as if a unique
 identifier were included in the appropriate place [[dcl.name]]. The
-preceding specifiers indicate the type, storage class or other
-properties of the entity or entities being declared. Each declarator
-specifies one entity and (optionally) names it and/or modifies the type
-of the specifiers with operators such as `*` (pointer to) and `()`
-(function returning).
 [*Note 1*: An *init-declarator* can also specify an initializer
 [[dcl.init]]. — *end note*]
 Each *init-declarator* or *member-declarator* in a declaration is
@@ -107,10 +107,14 @@ void g(int (*)() requires true);            // error: constraint on a parameter-
 auto* p = new void(*)(char) requires true;  // error: not a function declaration
 ```
 — *end example*]
 Declarators have the syntax
 ``` bnf
 declarator:
     ptr-declarator
@@ -174,13 +178,13 @@ declarator-id:
 ### Type names <a id="dcl.name">[[dcl.name]]</a>
 To specify type conversions explicitly, and as an argument of `sizeof`,
 `alignof`, `new`, or `typeid`, the name of a type shall be specified.
-This can be done with a *type-id*, which is syntactically a declaration
-for a variable or function of that type that omits the name of the
-entity.
 ``` bnf
 type-id:
     type-specifier-seq abstract-declaratorₒₚₜ
 ```
@@ -217,11 +221,10 @@ abstract-pack-declarator:
 ```
 ``` bnf
 noptr-abstract-pack-declarator:
     noptr-abstract-pack-declarator parameters-and-qualifiers
-    noptr-abstract-pack-declarator '[' constant-expressionₒₚₜ ']' attribute-specifier-seqₒₚₜ
     '...'
 ```
 It is possible to identify uniquely the location in the
 *abstract-declarator* where the identifier would appear if the
@@ -244,12 +247,13 @@ pointers to `int`”, “pointer to array of 3 `int`”, “function of (no
 parameters) returning pointer to `int`”, and “pointer to a function of
 (`double`) returning `int`”.
 — *end example*]
-A type can also be named (often more easily) by using a `typedef`
-[[dcl.typedef]].
 ### Ambiguity resolution <a id="dcl.ambig.res">[[dcl.ambig.res]]</a>
 The ambiguity arising from the similarity between a function-style cast
 and a declaration mentioned in  [[stmt.ambig]] can also occur in the
@@ -257,11 +261,14 @@ context of a declaration. In that context, the choice is between an
 object declaration with a function-style cast as the initializer and a
 declaration involving a function declarator with a redundant set of
 parentheses around a parameter name. Just as for the ambiguities
 mentioned in  [[stmt.ambig]], the resolution is to consider any
 construct, such as the potential parameter declaration, that could
-possibly be a declaration to be a declaration.
 [*Note 1*: A declaration can be explicitly disambiguated by adding
 parentheses around the argument. The ambiguity can be avoided by use of
 copy-initialization or list-initialization syntax, or by use of a
 non-function-style cast. — *end note*]
@@ -270,26 +277,32 @@ non-function-style cast. — *end note*]
 ``` cpp
 struct S {
   S(int);
 };
 void foo(double a) {
-  S w(int(a));                  // function declaration
-  S x(int());                   // function declaration
-  S y((int(a)));                // object declaration
   S y((int)a);                  // object declaration
   S z = int(a);                 // object declaration
 }
 ```
 — *end example*]
 An ambiguity can arise from the similarity between a function-style cast
 and a *type-id*. The resolution is that any construct that could
 possibly be a *type-id* in its syntactic context shall be considered a
-*type-id*.
 [*Example 2*:
 ``` cpp
 template <class T> struct X {};
@@ -306,10 +319,16 @@ void foo(signed char a) {
   (int())+1;                    // type-id (ill-formed)
   (int(a))+1;                   // expression
   (int(unsigned(a)))+1;         // type-id (ill-formed)
 }
 ```
 — *end example*]
 Another ambiguity arises in a *parameter-declaration-clause* when a
@@ -503,11 +522,11 @@ the type specifiers `int` `unsigned` determine the type “`unsigned int`”
 [[dcl.type.simple]].
 — *end example*]
 In a declaration *attribute-specifier-seq*ₒₚₜ  `T` `D` where `D` is an
-unadorned name, the type of the declared entity is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 '(' 'D1' ')'
@@ -584,13 +603,13 @@ cv-unqualified pointer later, for example:
 ``` cpp
 *ppc = &ci;         // OK, but would make p point to ci because of previous error
 *p = 5;             // clobber ci
 ```
-— *end example*]
-See also  [[expr.ass]] and  [[dcl.init]].
 [*Note 1*: Forming a pointer to reference type is ill-formed; see
 [[dcl.ref]]. Forming a function pointer type is ill-formed if the
 function type has *cv-qualifier*s or a *ref-qualifier*; see
 [[dcl.fct]]. Since the address of a bit-field [[class.bit]] cannot be
@@ -627,12 +646,11 @@ to `const int`”.
 — *end example*]
 [*Note 1*: A reference can be thought of as a name of an
 object. — *end note*]
-A declarator that specifies the type “reference to cv `void`” is
-ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
@@ -693,29 +711,57 @@ There shall be no references to references, no arrays of references, and
 no pointers to references. The declaration of a reference shall contain
 an *initializer* [[dcl.init.ref]] except when the declaration contains
 an explicit `extern` specifier [[dcl.stc]], is a class member
 [[class.mem]] declaration within a class definition, or is the
 declaration of a parameter or a return type [[dcl.fct]]; see
-[[basic.def]]. A reference shall be initialized to refer to a valid
-object or function.
-[*Note 2*:  In particular, a null reference cannot exist in a
-well-defined program, because the only way to create such a reference
-would be to bind it to the “object” obtained by indirection through a
-null pointer, which causes undefined behavior. As described in
-[[class.bit]], a reference cannot be bound directly to a
-bit-field. — *end note*]
 If a *typedef-name* [[dcl.typedef]], [[temp.param]] or a
 *decltype-specifier* [[dcl.type.decltype]] denotes a type `TR` that is a
 reference to a type `T`, an attempt to create the type “lvalue reference
 to cv `TR`” creates the type “lvalue reference to `T`”, while an attempt
 to create the type “rvalue reference to cv `TR`” creates the type `TR`.
 [*Note 3*: This rule is known as reference collapsing. — *end note*]
-[*Example 3*:
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
@@ -746,17 +792,18 @@ In a declaration `T` `D` where `D` has the form
 ``` bnf
 nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
-and the *nested-name-specifier* denotes a class, and the type of the
 contained *declarator-id* in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, the type of the *declarator-id* in
 `D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
 member of class *nested-name-specifier* of type `T`”. The optional
 *attribute-specifier-seq* [[dcl.attr.grammar]] appertains to the
-pointer-to-member.
 [*Example 1*:
 ``` cpp
 struct X {
@@ -878,13 +925,14 @@ initialized and the declarator is followed by an initializer
 cases, the array bound is calculated from the number of initial elements
 (say, `N`) supplied [[dcl.init.aggr]], and the type of the array is
 “array of `N` `U`”.
 Furthermore, if there is a reachable declaration of the entity that
-inhabits the same scope in which the bound was specified, an omitted
-array bound is taken to be the same as in that earlier declaration, and
-similarly for the definition of a static data member of a class.
 [*Example 3*:
 ``` cpp
 extern int x[10];
@@ -897,10 +945,13 @@ int S::y[];             // OK, bound is 10
 void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 ```
 — *end example*]
 [*Note 3*:
@@ -949,58 +1000,55 @@ described in  [[conv.array]]. — *end note*]
 [[over.sub]]. For the operator’s built-in meaning, see
 [[expr.sub]]. — *end note*]
 #### Functions <a id="dcl.fct">[[dcl.fct]]</a>
-In a declaration `T` `D` where `D` has the form
 ``` bnf
 'D1' '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
-and the type of the contained *declarator-id* in the declaration `T`
-`D1` is “*derived-declarator-type-list* `T`”, the type of the
-*declarator-id* in `D` is “*derived-declarator-type-list* `noexcept`ₒₚₜ
-function of parameter-type-list *cv-qualifier-seq*ₒₚₜ
-*ref-qualifier*ₒₚₜ  returning `T`”, where
-- the parameter-type-list is derived from the
-  *parameter-declaration-clause* as described below and
-- the optional `noexcept` is present if and only if the exception
- specification [[except.spec]] is non-throwing.
-The optional *attribute-specifier-seq* appertains to the function type.
-In a declaration `T` `D` where `D` has the form
-``` bnf
-'D1' '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-type
-```
-and the type of the contained *declarator-id* in the declaration `T`
-`D1` is “*derived-declarator-type-list* `T`”, `T` shall be the single
-*type-specifier* `auto`. The type of the *declarator-id* in `D` is
 “*derived-declarator-type-list* `noexcept`ₒₚₜ  function of
 parameter-type-list *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  returning
 `U`”, where
 - the parameter-type-list is derived from the
-  *parameter-declaration-clause* as described below,
-- `U` is the type specified by the *trailing-return-type*, and
 - the optional `noexcept` is present if and only if the exception
-  specification is non-throwing.
 The optional *attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^2]
 ``` bnf
 parameter-declaration-clause:
- parameter-declaration-listₒₚₜ '...'ₒₚₜ
     parameter-declaration-list ',' '...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
@@ -1024,20 +1072,23 @@ specified, and their processing, when the function is called.
 [*Note 1*:  The *parameter-declaration-clause* is used to convert the
 arguments specified on the function call; see
 [[expr.call]]. — *end note*]
 If the *parameter-declaration-clause* is empty, the function takes no
-arguments. A parameter list consisting of a single unnamed parameter of
-non-dependent type `void` is equivalent to an empty parameter list.
-Except for this special case, a parameter shall not have type cv `void`.
-A parameter with volatile-qualified type is deprecated; see
-[[depr.volatile.type]]. If the *parameter-declaration-clause* terminates
-with an ellipsis or a function parameter pack [[temp.variadic]], the
-number of arguments shall be equal to or greater than the number of
-parameters that do not have a default argument and are not function
-parameter packs. Where syntactically correct and where “`...`” is not
-part of an *abstract-declarator*, “`, ...`” is synonymous with “`...`”.
 [*Example 1*:
 The declaration
@@ -1096,14 +1147,16 @@ void h(int (*)(int)) {}         // defines #3
 — *end example*]
 An *explicit-object-parameter-declaration* is a *parameter-declaration*
 with a `this` specifier. An explicit-object-parameter-declaration shall
 appear only as the first *parameter-declaration* of a
-*parameter-declaration-list* of either:
-- a *member-declarator* that declares a member function [[class.mem]],
-  or
 - a *lambda-declarator* [[expr.prim.lambda]].
 A *member-declarator* with an explicit-object-parameter-declaration
 shall not include a *ref-qualifier* or a *cv-qualifier-seq* and shall
 not be declared `static` or `virtual`.
@@ -1146,31 +1199,33 @@ explicit object parameter, if any, omitted.
 [*Note 4*: The non-object-parameter-type-list consists of the adjusted
 types of all the non-object parameters. — *end note*]
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
-(including a type named by *typedef-name*
 [[dcl.typedef]], [[temp.param]]) shall appear only as:
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
 - the *type-id* in the default argument of a *type-parameter*
-  [[temp.param]], or
 - the *type-id* of a *template-argument* for a *type-parameter*
-  [[temp.arg.type]].
 [*Example 4*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;                                                  // error: does not declare a member function
 struct S {
   FIC f;                                                // OK
 };
 FIC S::*pm = &S::f;                                     // OK
 ```
 — *end example*]
 The effect of a *cv-qualifier-seq* in a function declarator is not the
@@ -1317,24 +1372,24 @@ specialization.
 [*Note 11*: A function template is not a function. — *end note*]
 An *abbreviated function template* is a function declaration that has
 one or more generic parameter type placeholders [[dcl.spec.auto]]. An
 abbreviated function template is equivalent to a function template
-[[temp.fct]] whose *template-parameter-list* includes one invented type
-*template-parameter* for each generic parameter type placeholder of the
 function declaration, in order of appearance. For a
 *placeholder-type-specifier* of the form `auto`, the invented parameter
 is an unconstrained *type-parameter*. For a *placeholder-type-specifier*
 of the form *type-constraint* `auto`, the invented parameter is a
-*type-parameter* with that *type-constraint*. The invented type
-*template-parameter* is a template parameter pack if the corresponding
 *parameter-declaration* declares a function parameter pack. If the
 placeholder contains `decltype(auto)`, the program is ill-formed. The
 adjusted function parameters of an abbreviated function template are
 derived from the *parameter-declaration-clause* by replacing each
 occurrence of a placeholder with the name of the corresponding invented
-*template-parameter*.
 [*Example 9*:
 ``` cpp
 template<typename T>     concept C1 = /* ... */;
@@ -1365,13 +1420,12 @@ template<> void g1<int>(const int*, const double&); // OK, specialization of g1<
 ```
 — *end example*]
 An abbreviated function template can have a *template-head*. The
-invented *template-parameter*s are appended to the
-*template-parameter-list* after the explicitly declared
-*template-parameter*s.
 [*Example 10*:
 ``` cpp
 template<typename> concept C = /* ... */;
@@ -1455,20 +1509,19 @@ respectively.
 — *end example*]
 A default argument shall be specified only in the
 *parameter-declaration-clause* of a function declaration or
-*lambda-declarator* or in a *template-parameter* [[temp.param]]; in the
-latter case, the *initializer-clause* shall be an
-*assignment-expression*. A default argument shall not be specified for a
-template parameter pack or a function parameter pack. If it is specified
-in a *parameter-declaration-clause*, it shall not occur within a
-*declarator* or *abstract-declarator* of a *parameter-declaration*.[^4]
 For non-template functions, default arguments can be added in later
-declarations of a function that inhabit the same scope. Declarations
-that inhabit different scopes have completely distinct sets of default
 arguments. That is, declarations in inner scopes do not acquire default
 arguments from declarations in outer scopes, and vice versa. In a given
 function declaration, each parameter subsequent to a parameter with a
 default argument shall have a default argument supplied in this or a
 previous declaration, unless the parameter was expanded from a parameter
@@ -1549,19 +1602,19 @@ void h() {
 [*Note 3*: A default argument is a complete-class context
 [[class.mem]]. Access checking applies to names in default arguments as
 described in [[class.access]]. — *end note*]
-Except for member functions of class templates, the default arguments in
-a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
 ill-formed if a default constructor [[class.default.ctor]], copy or move
 constructor [[class.copy.ctor]], or copy or move assignment operator
 [[class.copy.assign]] is so declared. Default arguments for a member
-function of a class template shall be specified on the initial
-declaration of the member function within the class template.
 [*Example 4*:
 ``` cpp
 class C {
@@ -1626,14 +1679,17 @@ int g(float I, int b = I(2));       // error: parameter I found
 int h(int a, int b = sizeof(a));    // OK, unevaluated operand[term.unevaluated.operand]
 ```
 — *end example*]
-A non-static member shall not appear in a default argument unless it
-appears as the *id-expression* of a class member access expression
-[[expr.ref]] or unless it is used to form a pointer to member
-[[expr.unary.op]].
 [*Example 8*:
 The declaration of `X::mem1()` in the following example is ill-formed
 because no object is supplied for the non-static member `X::a` used as
@@ -1642,11 +1698,13 @@ an initializer.
 ``` cpp
 int b;
 class X {
   int a;
   int mem1(int i = a);                      // error: non-static member a used as default argument
-  int mem2(int i = b); // OK;  use X::b
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
@@ -1671,15 +1729,16 @@ int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
-When an overload set contains a declaration of a function that inhabits
-a scope S, any default argument associated with any reachable
-declaration that inhabits S is available to the call.
-[*Note 7*: The candidate might have been found through a
 *using-declarator* from which the declaration that provides the default
 argument is not reachable. — *end note*]
 A virtual function call [[class.virtual]] uses the default arguments in
 the declaration of the virtual function determined by the static type of

     init-declarator-list ',' init-declarator
 ```
 ``` bnf
 init-declarator:
+    declarator initializer
+    declarator requires-clauseₒₚₜ function-contract-specifier-seqₒₚₜ
 ```
 In all contexts, a *declarator* is interpreted as given below. Where an
 *abstract-declarator* can be used (or omitted) in place of a
 *declarator* [[dcl.fct]], [[except.pre]], it is as if a unique
 identifier were included in the appropriate place [[dcl.name]]. The
+preceding specifiers indicate the type, storage duration, linkage, or
+other properties of the entity or entities being declared. Each
+declarator specifies one entity and (optionally) names it and/or
+modifies the type of the specifiers with operators such as `*` (pointer
+to) and `()` (function returning).
 [*Note 1*: An *init-declarator* can also specify an initializer
 [[dcl.init]]. — *end note*]
 Each *init-declarator* or *member-declarator* in a declaration is
 auto* p = new void(*)(char) requires true;  // error: not a function declaration
 ```
 — *end example*]
+The optional *function-contract-specifier-seq* [[dcl.contract.func]] in
+an *init-declarator* shall be present only if the *declarator* declares
+a function.
 Declarators have the syntax
 ``` bnf
 declarator:
     ptr-declarator
 ### Type names <a id="dcl.name">[[dcl.name]]</a>
 To specify type conversions explicitly, and as an argument of `sizeof`,
 `alignof`, `new`, or `typeid`, the name of a type shall be specified.
+This can be done with a *type-id* or *new-type-id* [[expr.new]], which
+is syntactically a declaration for a variable or function of that type
+that omits the name of the entity.
 ``` bnf
 type-id:
     type-specifier-seq abstract-declaratorₒₚₜ
 ```
 ```
 ``` bnf
 noptr-abstract-pack-declarator:
     noptr-abstract-pack-declarator parameters-and-qualifiers
     '...'
 ```
 It is possible to identify uniquely the location in the
 *abstract-declarator* where the identifier would appear if the
 parameters) returning pointer to `int`”, and “pointer to a function of
 (`double`) returning `int`”.
 — *end example*]
+[*Note 1*: A type can also be named by a *typedef-name*, which is
+introduced by a typedef declaration or *alias-declaration*
+[[dcl.typedef]]. — *end note*]
 ### Ambiguity resolution <a id="dcl.ambig.res">[[dcl.ambig.res]]</a>
 The ambiguity arising from the similarity between a function-style cast
 and a declaration mentioned in  [[stmt.ambig]] can also occur in the
 object declaration with a function-style cast as the initializer and a
 declaration involving a function declarator with a redundant set of
 parentheses around a parameter name. Just as for the ambiguities
 mentioned in  [[stmt.ambig]], the resolution is to consider any
 construct, such as the potential parameter declaration, that could
+possibly be a declaration to be a declaration. However, a construct that
+can syntactically be a *declaration* whose outermost *declarator* would
+match the grammar of a *declarator* with a *trailing-return-type* is a
+declaration only if it starts with `auto`.
 [*Note 1*: A declaration can be explicitly disambiguated by adding
 parentheses around the argument. The ambiguity can be avoided by use of
 copy-initialization or list-initialization syntax, or by use of a
 non-function-style cast. — *end note*]
 ``` cpp
 struct S {
   S(int);
 };
+typedef struct BB { int C[2]; } *B, C;
 void foo(double a) {
+  S v(int(a));                  // function declaration
+  S w(int());                   // function declaration
+  S x((int(a)));                // object declaration
   S y((int)a);                  // object declaration
   S z = int(a);                 // object declaration
+  S a(B()->C);                  // object declaration
+  S b(auto()->C);               // function declaration
 }
 ```
 — *end example*]
 An ambiguity can arise from the similarity between a function-style cast
 and a *type-id*. The resolution is that any construct that could
 possibly be a *type-id* in its syntactic context shall be considered a
+*type-id*. However, a construct that can syntactically be a *type-id*
+whose outermost *abstract-declarator* would match the grammar of an
+*abstract-declarator* with a *trailing-return-type* is considered a
+*type-id* only if it starts with `auto`.
 [*Example 2*:
 ``` cpp
 template <class T> struct X {};
   (int())+1;                    // type-id (ill-formed)
   (int(a))+1;                   // expression
   (int(unsigned(a)))+1;         // type-id (ill-formed)
 }
+typedef struct BB { int C[2]; } *B, C;
+void g() {
+  sizeof(B()->C[1]);            // OK, sizeof(expression)
+  sizeof(auto()->C[1]);         // error: sizeof of a function returning an array
+}
 ```
 — *end example*]
 Another ambiguity arises in a *parameter-declaration-clause* when a
 [[dcl.type.simple]].
 — *end example*]
 In a declaration *attribute-specifier-seq*ₒₚₜ  `T` `D` where `D` is an
+unadorned *declarator-id*, the type of the declared entity is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 '(' 'D1' ')'
 ``` cpp
 *ppc = &ci;         // OK, but would make p point to ci because of previous error
 *p = 5;             // clobber ci
 ```
+See also  [[expr.assign]] and  [[dcl.init]].
+— *end example*]
 [*Note 1*: Forming a pointer to reference type is ill-formed; see
 [[dcl.ref]]. Forming a function pointer type is ill-formed if the
 function type has *cv-qualifier*s or a *ref-qualifier*; see
 [[dcl.fct]]. Since the address of a bit-field [[class.bit]] cannot be
 — *end example*]
 [*Note 1*: A reference can be thought of as a name of an
 object. — *end note*]
+Forming the type “reference to cv `void`” is ill-formed.
 A reference type that is declared using `&` is called an *lvalue
 reference*, and a reference type that is declared using `&&` is called
 an *rvalue reference*. Lvalue references and rvalue references are
 distinct types. Except where explicitly noted, they are semantically
 no pointers to references. The declaration of a reference shall contain
 an *initializer* [[dcl.init.ref]] except when the declaration contains
 an explicit `extern` specifier [[dcl.stc]], is a class member
 [[class.mem]] declaration within a class definition, or is the
 declaration of a parameter or a return type [[dcl.fct]]; see
+[[basic.def]].
+Attempting to bind a reference to a function where the converted
+initializer is a glvalue whose type is not call-compatible [[expr.call]]
+with the type of the function’s definition results in undefined
+behavior. Attempting to bind a reference to an object where the
+converted initializer is a glvalue through which the object is not
+type-accessible [[basic.lval]] results in undefined behavior.
+[*Note 2*:  The object designated by such a glvalue can be outside its
+lifetime [[basic.life]]. Because a null pointer value or a pointer past
+the end of an object does not point to an object, a reference in a
+well-defined program cannot refer to such things; see
+[[expr.unary.op]]. As described in  [[class.bit]], a reference cannot be
+bound directly to a bit-field. — *end note*]
+The behavior of an evaluation of a reference
+[[expr.prim.id]], [[expr.ref]] that does not happen after
+[[intro.races]] the initialization of the reference is undefined.
+[*Example 3*:
+``` cpp
+int &f(int&);
+int &g();
+extern int &ir3;
+int *ip = 0;
+int &ir1 = *ip;                 // undefined behavior: null pointer
+int &ir2 = f(ir3);              // undefined behavior: ir3 not yet initialized
+int &ir3 = g();
+int &ir4 = f(ir4);              // undefined behavior: ir4 used in its own initializer
+char x alignas(int);
+int &ir5 = *reinterpret_cast<int *>(&x);    // undefined behavior: initializer refers to char object
+```
+— *end example*]
 If a *typedef-name* [[dcl.typedef]], [[temp.param]] or a
 *decltype-specifier* [[dcl.type.decltype]] denotes a type `TR` that is a
 reference to a type `T`, an attempt to create the type “lvalue reference
 to cv `TR`” creates the type “lvalue reference to `T`”, while an attempt
 to create the type “rvalue reference to cv `TR`” creates the type `TR`.
 [*Note 3*: This rule is known as reference collapsing. — *end note*]
+[*Example 4*:
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
 ``` bnf
 nested-name-specifier '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
+and the *nested-name-specifier* designates a class, and the type of the
 contained *declarator-id* in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, the type of the *declarator-id* in
 `D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
 member of class *nested-name-specifier* of type `T`”. The optional
 *attribute-specifier-seq* [[dcl.attr.grammar]] appertains to the
+pointer-to-member. The *nested-name-specifier* shall not designate an
+anonymous union.
 [*Example 1*:
 ``` cpp
 struct X {
 cases, the array bound is calculated from the number of initial elements
 (say, `N`) supplied [[dcl.init.aggr]], and the type of the array is
 “array of `N` `U`”.
 Furthermore, if there is a reachable declaration of the entity that
+specifies a bound and has the same host scope [[basic.scope.scope]], an
+omitted array bound is taken to be the same as in that earlier
+declaration, and similarly for the definition of a static data member of
+a class.
 [*Example 3*:
 ``` cpp
 extern int x[10];
 void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
+namespace A { extern int z[3]; }
+int A::z[] = {};        // OK, defines an array of 3 elements
 ```
 — *end example*]
 [*Note 3*:
 [[over.sub]]. For the operator’s built-in meaning, see
 [[expr.sub]]. — *end note*]
 #### Functions <a id="dcl.fct">[[dcl.fct]]</a>
+In a declaration `T` `D` where `T` may be empty and `D` has the form
 ``` bnf
 'D1' '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ trailing-return-typeₒₚₜ
 ```
+a *derived-declarator-type-list* is determined as follows:
+- If the *unqualified-id* of the *declarator-id* is a
+  *conversion-function-id*, the *derived-declarator-type-list* is empty.
+- Otherwise, the *derived-declarator-type-list* is as appears in the
+ type “*derived-declarator-type-list* `T`” of the contained
+  *declarator-id* in the declaration `T` `D1`.
+The declared return type `U` of the function type is determined as
+follows:
+- If the *trailing-return-type* is present, `T` shall be the single
+  *type-specifier* `auto`, and `U` is the type specified by the
+  *trailing-return-type*.
+- Otherwise, if the declaration declares a conversion function, see
+  [[class.conv.fct]].
+- Otherwise, `U` is `T`.
+The type of the *declarator-id* in `D` is
 “*derived-declarator-type-list* `noexcept`ₒₚₜ  function of
 parameter-type-list *cv-qualifier-seq*ₒₚₜ  *ref-qualifier*ₒₚₜ  returning
 `U`”, where
 - the parameter-type-list is derived from the
+  *parameter-declaration-clause* as described below and
 - the optional `noexcept` is present if and only if the exception
+  specification [[except.spec]] is non-throwing.
+Such a type is a *function type*.[^2]
 The optional *attribute-specifier-seq* appertains to the function type.
 ``` bnf
 parameter-declaration-clause:
+    '...'
+    parameter-declaration-listₒₚₜ
     parameter-declaration-list ',' '...'
+    parameter-declaration-list '...'
 ```
 ``` bnf
 parameter-declaration-list:
     parameter-declaration
 [*Note 1*:  The *parameter-declaration-clause* is used to convert the
 arguments specified on the function call; see
 [[expr.call]]. — *end note*]
 If the *parameter-declaration-clause* is empty, the function takes no
+arguments. A parameter list consisting of a single unnamed non-object
+parameter of non-dependent type `void` is equivalent to an empty
+parameter list. Except for this special case, a parameter shall not have
+type cv `void`. A parameter with volatile-qualified type is deprecated;
+see  [[depr.volatile.type]]. If the *parameter-declaration-clause*
+terminates with an ellipsis or a function parameter pack
+[[temp.variadic]], the number of arguments shall be equal to or greater
+than the number of parameters that do not have a default argument and
+are not function parameter packs. Where syntactically correct and where
+“`...`” is not part of an *abstract-declarator*, “`...`” is synonymous
+with “`, ...`”. A *parameter-declaration-clause* of the form
+*parameter-declaration-list* `...` is deprecated
+[[depr.ellipsis.comma]].
 [*Example 1*:
 The declaration
 — *end example*]
 An *explicit-object-parameter-declaration* is a *parameter-declaration*
 with a `this` specifier. An explicit-object-parameter-declaration shall
 appear only as the first *parameter-declaration* of a
+*parameter-declaration-list* of one of:
+- a declaration of a member function or member function template
+ [[class.mem]], or
+- an explicit instantiation [[temp.explicit]] or explicit specialization
+  [[temp.expl.spec]] of a templated member function, or
 - a *lambda-declarator* [[expr.prim.lambda]].
 A *member-declarator* with an explicit-object-parameter-declaration
 shall not include a *ref-qualifier* or a *cv-qualifier-seq* and shall
 not be declared `static` or `virtual`.
 [*Note 4*: The non-object-parameter-type-list consists of the adjusted
 types of all the non-object parameters. — *end note*]
 A function type with a *cv-qualifier-seq* or a *ref-qualifier*
+(including a type denoted by *typedef-name*
 [[dcl.typedef]], [[temp.param]]) shall appear only as:
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
 - the *type-id* in the default argument of a *type-parameter*
+  [[temp.param]],
 - the *type-id* of a *template-argument* for a *type-parameter*
+  [[temp.arg.type]], or
+- the operand of a *reflect-expression* [[expr.reflect]].
 [*Example 4*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;                                                  // error: does not declare a member function
 struct S {
   FIC f;                                                // OK
 };
 FIC S::*pm = &S::f;                                     // OK
+constexpr std::meta::info yeti = ^^void(int) const &;   // OK
 ```
 — *end example*]
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 [*Note 11*: A function template is not a function. — *end note*]
 An *abbreviated function template* is a function declaration that has
 one or more generic parameter type placeholders [[dcl.spec.auto]]. An
 abbreviated function template is equivalent to a function template
+[[temp.fct]] whose *template-parameter-list* includes one invented
+*type-parameter* for each generic parameter type placeholder of the
 function declaration, in order of appearance. For a
 *placeholder-type-specifier* of the form `auto`, the invented parameter
 is an unconstrained *type-parameter*. For a *placeholder-type-specifier*
 of the form *type-constraint* `auto`, the invented parameter is a
+*type-parameter* with that *type-constraint*. The invented
+*type-parameter* declares a template parameter pack if the corresponding
 *parameter-declaration* declares a function parameter pack. If the
 placeholder contains `decltype(auto)`, the program is ill-formed. The
 adjusted function parameters of an abbreviated function template are
 derived from the *parameter-declaration-clause* by replacing each
 occurrence of a placeholder with the name of the corresponding invented
+*type-parameter*.
 [*Example 9*:
 ``` cpp
 template<typename T>     concept C1 = /* ... */;
 ```
 — *end example*]
 An abbreviated function template can have a *template-head*. The
+invented *type-parameter*s are appended to the *template-parameter-list*
+after the explicitly declared *template-parameter*s.
 [*Example 10*:
 ``` cpp
 template<typename> concept C = /* ... */;
 — *end example*]
 A default argument shall be specified only in the
 *parameter-declaration-clause* of a function declaration or
+*lambda-declarator* or in a *template-parameter* [[temp.param]]. A
+default argument shall not be specified for a template parameter pack or
+a function parameter pack. If it is specified in a
+*parameter-declaration-clause*, it shall not occur within a *declarator*
+or *abstract-declarator* of a *parameter-declaration*.[^4]
 For non-template functions, default arguments can be added in later
+declarations of a function that have the same host scope. Declarations
+that have different host scopes have completely distinct sets of default
 arguments. That is, declarations in inner scopes do not acquire default
 arguments from declarations in outer scopes, and vice versa. In a given
 function declaration, each parameter subsequent to a parameter with a
 default argument shall have a default argument supplied in this or a
 previous declaration, unless the parameter was expanded from a parameter
 [*Note 3*: A default argument is a complete-class context
 [[class.mem]]. Access checking applies to names in default arguments as
 described in [[class.access]]. — *end note*]
+Except for member functions of templated classes, the default arguments
+in a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
 member function declaration in the class definition; the program is
 ill-formed if a default constructor [[class.default.ctor]], copy or move
 constructor [[class.copy.ctor]], or copy or move assignment operator
 [[class.copy.assign]] is so declared. Default arguments for a member
+function of a templated class shall be specified on the initial
+declaration of the member function within the templated class.
 [*Example 4*:
 ``` cpp
 class C {
 int h(int a, int b = sizeof(a));    // OK, unevaluated operand[term.unevaluated.operand]
 ```
 — *end example*]
+A non-static member shall not be designated in a default argument unless
+- it is designated by the *id-expression* or *splice-expression* of a
+  class member access expression [[expr.ref]],
+- it is designated by an expression used to form a pointer to member
+  [[expr.unary.op]], or
+- it appears as the operand of a *reflect-expression* [[expr.reflect]].
 [*Example 8*:
 The declaration of `X::mem1()` in the following example is ill-formed
 because no object is supplied for the non-static member `X::a` used as
 ``` cpp
 int b;
 class X {
   int a;
   int mem1(int i = a);                      // error: non-static member a used as default argument
+  int mem2(int i = b); // OK, use X::b
+  consteval void mem3(std::meta::info r = ^^a) {}   // OK
+  int mem4(int i = [:^^a:]);                // error: non-static member a designated in default argument
   static int b;
 };
 ```
 The declaration of `X::mem2()` is meaningful, however, since no object
 int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
+[*Note 7*: When an overload set contains a declaration of a function
+whose host scope is S, any default argument associated with any
+reachable declaration whose host scope is S is available to the call
+[[over.match.viable]]. — *end note*]
+[*Note 8*: The candidate might have been found through a
 *using-declarator* from which the declaration that provides the default
 argument is not reachable. — *end note*]
 A virtual function call [[class.virtual]] uses the default arguments in
 the declaration of the virtual function determined by the static type of

Diff to HTML by rtfpessoa