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

Files changed (1) hide show

tmp/tmplf5w5u91/{from.md → to.md} +132 -92

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

@@ -157,11 +157,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' ')'
@@ -238,13 +238,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
@@ -281,12 +281,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
@@ -347,29 +346,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;
@@ -400,17 +427,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 {
@@ -532,13 +560,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];
@@ -551,10 +580,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*:
@@ -603,58 +635,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
@@ -678,20 +707,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
@@ -750,14 +782,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`.
@@ -800,31 +834,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
@@ -971,24 +1007,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 = /* ... */;
@@ -1019,13 +1055,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 = /* ... */;
@@ -1109,20 +1144,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
@@ -1203,19 +1237,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 {
@@ -1280,14 +1314,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
@@ -1296,11 +1333,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
@@ -1325,15 +1364,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

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