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

Files changed (1) hide show

tmp/tmpna7yauhj/{from.md → to.md} +341 -164

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

@@ -1,11 +1,13 @@
 ## Declarators <a id="dcl.decl">[[dcl.decl]]</a>
 A declarator declares a single variable, function, or type, within a
-declaration. The *init-declarator-list* appearing in a declaration is a
-comma-separated sequence of declarators, each of which can have an
-initializer.
 ``` bnf
 init-declarator-list:
     init-declarator
     init-declarator-list ',' init-declarator
@@ -15,28 +17,31 @@ init-declarator-list:
 init-declarator:
     declarator initializerₒₚₜ
     declarator requires-clause
 ```
-The three components of a *simple-declaration* are the attributes
-[[dcl.attr]], the specifiers (*decl-specifier-seq*; [[dcl.spec]]) and
-the declarators (*init-declarator-list*). The specifiers indicate the
-type, storage class or other properties of the entities being declared.
-The declarators specify the names of these entities and (optionally)
-modify the type of the specifiers with operators such as `*` (pointer
-to) and `()` (function returning). Initial values can also be specified
-in a declarator; initializers are discussed in  [[dcl.init]] and
-[[class.init]].
-Each *init-declarator* in a declaration is analyzed separately as if it
-was in a declaration by itself.
-[*Note 1*:
 A declaration with several declarators is usually equivalent to the
 corresponding sequence of declarations each with a single declarator.
-That is
 ``` cpp
 T D1, D2, ... Dn;
 ```
@@ -45,14 +50,14 @@ is usually equivalent to
 ``` cpp
 T D1; T D2; ... T Dn;
 ```
 where `T` is a *decl-specifier-seq* and each `Di` is an
-*init-declarator*. One exception is when a name introduced by one of the
-*declarator*s hides a type name used by the *decl-specifier*s, so that
-when the same *decl-specifier*s are used in a subsequent declaration,
-they do not have the same meaning, as in
 ``` cpp
 struct S { ... };
 S S, T;                 // declare two instances of struct S
 ```
@@ -72,19 +77,19 @@ auto i = 1, j = 2.0;    // error: deduced types for i and j do not match
 ```
 as opposed to
 ``` cpp
-auto i = 1;             // OK: i deduced to have type int
-auto j = 2.0;           // OK: j deduced to have type double
 ```
 — *end note*]
-The optional *requires-clause* [[temp.pre]] in an *init-declarator* or
 *member-declarator* shall be present only if the declarator declares a
-templated function [[dcl.fct]]. When present after a declarator, the
 *requires-clause* is called the *trailing *requires-clause**. The
 trailing *requires-clause* introduces the *constraint-expression* that
 results from interpreting its *constraint-logical-or-expression* as a
 *constraint-expression*.
@@ -246,16 +251,17 @@ A type can also be named (often more easily) by using a `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
-context of a declaration. In that context, the choice is between a
-function declaration with a redundant set of parentheses around a
-parameter name and an object declaration with a function-style cast as
-the initializer. Just as for the ambiguities mentioned in
-[[stmt.ambig]], the resolution is to consider any construct that could
-possibly be a declaration 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*]
@@ -338,41 +344,137 @@ void h(int *(C[10]));           // void h(int *(*_fp)(C _parm[10]));
 — *end example*]
 ### Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
-A declarator contains exactly one *declarator-id*; it names the
-identifier that is declared. An *unqualified-id* occurring in a
-*declarator-id* shall be a simple *identifier* except for the
-declaration of some special functions ([[class.ctor]], [[class.conv]],
-[[class.dtor]], [[over.oper]]) and for the declaration of template
-specializations or partial specializations [[temp.spec]]. When the
-*declarator-id* is qualified, the declaration shall refer to a
-previously declared member of the class or namespace to which the
-qualifier refers (or, in the case of a namespace, of an element of the
-inline namespace set of that namespace [[namespace.def]]) or to a
-specialization thereof; the member shall not merely have been introduced
-by a *using-declaration* in the scope of the class or namespace
-nominated by the *nested-name-specifier* of the *declarator-id*. The
-*nested-name-specifier* of a qualified *declarator-id* shall not begin
-with a *decltype-specifier*.
-[*Note 1*: If the qualifier is the global `::` scope resolution
-operator, the *declarator-id* refers to a name declared in the global
-namespace scope. — *end note*]
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
 A `static`, `thread_local`, `extern`, `mutable`, `friend`, `inline`,
-`virtual`, `constexpr`, or `typedef` specifier or an
-*explicit-specifier* applies directly to each *declarator-id* in an
-*init-declarator-list* or *member-declarator-list*; the type specified
-for each *declarator-id* depends on both the *decl-specifier-seq* and
-its *declarator*.
-Thus, a declaration of a particular identifier has the form
 ``` cpp
 T D
 ```
@@ -387,11 +489,11 @@ First, the *decl-specifier-seq* determines a type. In a declaration
 T D
 ```
 the *decl-specifier-seq* `T` determines the type `T`.
-[*Example 1*:
 In the declaration
 ``` cpp
 int unsigned i;
@@ -401,11 +503,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 identifier the type of this identifier is “`T`”.
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 '(' 'D1' ')'
@@ -427,17 +529,17 @@ In a declaration `T` `D` where `D` has the form
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is
-“*derived-declarator-type-list* `T`”, then the type of the identifier of
-`D` is “*derived-declarator-type-list* *cv-qualifier-seq* pointer to
-`T`”. The *cv-qualifier*s apply to the pointer and not to the object
-pointed to. Similarly, the optional *attribute-specifier-seq*
-[[dcl.attr.grammar]] appertains to the pointer and not to the object
-pointed to.
 [*Example 1*:
 The declarations
@@ -501,18 +603,18 @@ In a declaration `T` `D` where `D` has either of the forms
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
-and the type of the identifier in the declaration `T` `D1` is
-“*derived-declarator-type-list* `T`”, then the type of the identifier of
-`D` is “*derived-declarator-type-list* reference to `T`”. The optional
-*attribute-specifier-seq* appertains to the reference type. Cv-qualified
-references are ill-formed except when the cv-qualifiers are introduced
-through the use of a *typedef-name* ([[dcl.typedef]], [[temp.param]])
-or *decltype-specifier* [[dcl.type.simple]], in which case the
-cv-qualifiers are ignored.
 [*Example 1*:
 ``` cpp
 typedef int& A;
@@ -601,12 +703,12 @@ 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.simple]] 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*]
@@ -635,19 +737,22 @@ decltype(r2)&& r7 = i;          // r7 has the type int&
 function type has *cv-qualifier*s or a *ref-qualifier*; see
 [[dcl.fct]]. — *end note*]
 #### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 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
-identifier in the declaration `T` `D1` is
-“*derived-declarator-type-list* `T`”, then the type of the identifier of
 `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.
@@ -722,12 +827,12 @@ unknown bound of `T`”, except as specified below.
 A type of the form “array of `N` `U`” or “array of unknown bound of `U`”
 is an *array type*. The optional *attribute-specifier-seq* appertains to
 the array type.
 `U` is called the array *element type*; this type shall not be a
-placeholder type [[dcl.spec.auto]], a reference type, a function type,
-an array of unknown bound, or cv `void`.
 [*Note 1*: An array can be constructed from one of the fundamental
 types (except `void`), from a pointer, from a pointer to member, from a
 class, from an enumeration type, or from an array of known
 bound. — *end note*]
@@ -758,39 +863,39 @@ typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 — *end example*]
 [*Note 2*: An “array of `N` *cv-qualifier-seq* `U`” has cv-qualified
 type; see  [[basic.type.qualifier]]. — *end note*]
-An object of type “array of `N` `U`” contains a contiguously allocated
-non-empty set of `N` subobjects of type `U`, known as the *elements* of
-the array, and numbered `0` to `N-1`.
 In addition to declarations in which an incomplete object type is
 allowed, an array bound may be omitted in some cases in the declaration
 of a function parameter [[dcl.fct]]. An array bound may also be omitted
 when an object (but not a non-static data member) of array type is
-initialized and the declarator is followed by an initializer (
-[[dcl.init]], [[class.mem]], [[expr.type.conv]], [[expr.new]]). In these
 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 preceding declaration of the entity in 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];
 struct S {
   static int y[10];
 };
-int x[];                // OK: bound is 10
-int S::y[];             // OK: bound is 10
 void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
@@ -800,11 +905,11 @@ void f() {
 [*Note 3*:
 When several “array of” specifications are adjacent, a multidimensional
 array type is created; only the first of the constant expressions that
-specify the bounds of the arrays may be omitted.
 [*Example 4*:
 ``` cpp
 int x3d[3][5][7];
@@ -902,13 +1007,13 @@ parameter-declaration-list:
     parameter-declaration-list ',' parameter-declaration
 ```
 ``` bnf
 parameter-declaration:
-    attribute-specifier-seqₒₚₜ decl-specifier-seq declarator
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator '=' initializer-clause
-    attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ
     attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ '=' initializer-clause
 ```
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
@@ -957,12 +1062,12 @@ However, the first argument must be of a type that can be converted to a
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
 [[support.runtime]]). — *end note*]
 The type of a function is determined using the following rules. The type
 of each parameter (including function parameter packs) is determined
-from its own *decl-specifier-seq* and *declarator*. After determining
-the type of each parameter, any parameter of type “array of `T`” or of
 function type `T` is adjusted to be “pointer to `T`”. After producing
 the list of parameter types, any top-level *cv-qualifier*s modifying a
 parameter type are deleted when forming the function type. The resulting
 list of transformed parameter types and the presence or absence of the
 ellipsis or a function parameter pack is the function’s
@@ -970,24 +1075,94 @@ ellipsis or a function parameter pack is the function’s
 [*Note 3*: This transformation does not affect the types of the
 parameters. For example, `int(*)(const int p, decltype(p)*)` and
 `int(*)(int, const int*)` are identical types. — *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 2*:
 ``` cpp
 typedef int FIC(int) const;
 FIC f;              // error: does not declare a member function
 struct S {
@@ -1000,35 +1175,35 @@ FIC S::*pm = &S::f; // OK
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
 latter case, the cv-qualifiers are ignored.
-[*Note 4*: A function type that has a *cv-qualifier-seq* is not a
 cv-qualified type; there are no cv-qualified function
 types. — *end note*]
-[*Example 3*:
 ``` cpp
 typedef void F();
 struct S {
-  const F f;        // OK: equivalent to: void f();
 };
 ```
 — *end example*]
 The return type, the parameter-type-list, the *ref-qualifier*, the
 *cv-qualifier-seq*, and the exception specification, but not the default
 arguments [[dcl.fct.default]] or the trailing *requires-clause*
 [[dcl.decl]], are part of the function type.
-[*Note 5*: Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
 pointers to member functions. — *end note*]
-[*Example 4*:
 The declaration
 ``` cpp
 int fseek(FILE*, long, int);
@@ -1037,50 +1212,46 @@ int fseek(FILE*, long, int);
 declares a function taking three arguments of the specified types, and
 returning `int` [[dcl.type]].
 — *end example*]
-A single name can be used for several different functions in a single
-scope; this is function overloading [[over]]. All declarations for a
-function shall have equivalent return types, parameter-type-lists, and
-*requires-clause*s [[temp.over.link]].
-Functions shall not have a return type of type array or function,
-although they may have a return type of type pointer or reference to
-such things. There shall be no arrays of functions, although there can
-be arrays of pointers to functions.
 A volatile-qualified return type is deprecated; see
 [[depr.volatile.type]].
 Types shall not be defined in return or parameter types.
 A typedef of function type may be used to declare a function but shall
 not be used to define a function [[dcl.fct.def]].
-[*Example 5*:
 ``` cpp
 typedef void F();
-F  fv;              // OK: equivalent to void fv();
 F  fv { }           // error
-void fv() { }       // OK: definition of fv
 ```
 — *end example*]
 An identifier can optionally be provided as a parameter name; if present
 in a function definition [[dcl.fct.def]], it names a parameter.
-[*Note 6*: In particular, parameter names are also optional in function
 definitions and names used for a parameter in different declarations and
-the definition of a function need not be the same. If a parameter name
-is present in a function declaration that is not a definition, it cannot
-be used outside of its function declarator because that is the extent of
-its potential scope [[basic.scope.param]]. — *end note*]
-[*Example 6*:
 The declaration
 ``` cpp
 int i,
@@ -1106,15 +1277,15 @@ calling of a function `fpi`, and then using indirection through the
 to indicate that indirection through a pointer to a function yields a
 function, which is then called.
 — *end example*]
-[*Note 7*:
 Typedefs and *trailing-return-type*s are sometimes convenient when the
 return type of a function is complex. For example, the function `fpif`
-above could have been declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
@@ -1141,11 +1312,11 @@ template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 — *end note*]
 A *non-template function* is a function that is not a function template
 specialization.
-[*Note 8*: 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
@@ -1154,18 +1325,18 @@ 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 [[dcl.fct]].
-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 7*:
 ``` cpp
 template<typename T>     concept C1 = /* ... */;
 template<typename T>     concept C2 = /* ... */;
 template<typename... Ts> concept C3 = /* ... */;
@@ -1174,12 +1345,12 @@ void g1(const C1 auto*, C2 auto&);
 void g2(C1 auto&...);
 void g3(C3 auto...);
 void g4(C3 auto);
 ```
-These declarations are functionally equivalent (but not equivalent) to
-the following declarations.
 ``` cpp
 template<C1 T, C2 U> void g1(const T*, U&);
 template<C1... Ts>   void g2(Ts&...);
 template<C3... Ts>   void g3(Ts...);
@@ -1194,15 +1365,15 @@ 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-parameters* are appended to the
 *template-parameter-list* after the explicitly declared
-*template-parameters*.
-[*Example 8*:
 ``` cpp
 template<typename> concept C = /* ... */;
 template <typename T, C U>
@@ -1232,11 +1403,11 @@ only be used in a *parameter-declaration*. When it is part of a
 function parameter pack [[temp.variadic]]. Otherwise, the
 *parameter-declaration* is part of a *template-parameter-list* and
 declares a template parameter pack; see  [[temp.param]]. A function
 parameter pack is a pack expansion [[temp.variadic]].
-[*Example 9*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
@@ -1292,18 +1463,18 @@ latter case, the *initializer-clause* shall be an
 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 in the same scope. Declarations in 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 pack, or
-shall be a function parameter pack.
 [*Note 2*: A default argument cannot be redefined by a later
 declaration (not even to the same value)
 [[basic.def.odr]]. — *end note*]
@@ -1337,22 +1508,26 @@ C<int> c;                       // OK, instantiates declaration void C::f(int n
 — *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; no diagnostic is required. If a friend
-declaration specifies a default argument expression, that declaration
-shall be a definition and shall be the only declaration of the function
-or function template in the translation unit.
 The default argument has the same semantic constraints as the
 initializer in a declaration of a variable of the parameter type, using
 the copy-initialization semantics [[dcl.init]]. The names in the default
-argument are bound, and the semantic constraints are checked, at the
-point where the default argument appears. Name lookup and checking of
-semantic constraints for default arguments in function templates and in
-member functions of class templates are performed as described in
-[[temp.inst]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
@@ -1370,14 +1545,13 @@ void h() {
 }
 ```
 — *end example*]
-[*Note 3*: In member function declarations, names in default arguments
-are looked up as described in  [[basic.lookup.unqual]]. 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
@@ -1394,16 +1568,16 @@ class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 };
 void C::f(int i = 3) {}         // error: default argument already specified in class scope
-void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no argument
 ```
 — *end example*]
-[*Note 4*: A local variable cannot be odr-used [[basic.def.odr]] in a
 default argument. — *end note*]
 [*Example 5*:
 ``` cpp
@@ -1417,11 +1591,11 @@ void f() {
 — *end example*]
 [*Note 5*:
-The keyword `this` may not appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
 ``` cpp
@@ -1434,22 +1608,24 @@ class A {
 — *end note*]
 A default argument is evaluated each time the function is called with no
 argument for the corresponding parameter. A parameter shall not appear
-as a potentially-evaluated expression in a default argument. Parameters
-of a function declared before a default argument are in scope and can
-hide namespace and class member names.
 [*Example 7*:
 ``` cpp
 int a;
 int f(int a, int b = a);            // error: parameter a used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter I found
-int h(int a, int b = sizeof(a));    // OK, unevaluated operand
 ```
 — *end example*]
 A non-static member shall not appear in a default argument unless it
@@ -1495,16 +1671,17 @@ int (*p1)(int) = &f;
 int (*p2)() = &f;                   // error: type mismatch
 ```
 — *end example*]
-When a declaration of a function is introduced by way of a
-*using-declaration* [[namespace.udecl]], any default argument
-information associated with the declaration is made known as well. If
-the function is redeclared thereafter in the namespace with additional
-default arguments, the additional arguments are also known at any point
-following the redeclaration where the *using-declaration* is in scope.
 A virtual function call [[class.virtual]] uses the default arguments in
 the declaration of the virtual function determined by the static type of
 the pointer or reference denoting the object. An overriding function in
 a derived class does not acquire default arguments from the function it

 ## Declarators <a id="dcl.decl">[[dcl.decl]]</a>
+### General <a id="dcl.decl.general">[[dcl.decl.general]]</a>
 A declarator declares a single variable, function, or type, within a
+declaration. The *init-declarator-list* appearing in a
+*simple-declaration* is a comma-separated sequence of declarators, each
+of which can have an initializer.
 ``` bnf
 init-declarator-list:
     init-declarator
     init-declarator-list ',' init-declarator
 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
+analyzed separately as if it were in a declaration by itself.
+[*Note 2*:
 A declaration with several declarators is usually equivalent to the
 corresponding sequence of declarations each with a single declarator.
+That is,
 ``` cpp
 T D1, D2, ... Dn;
 ```
 ``` cpp
 T D1; T D2; ... T Dn;
 ```
 where `T` is a *decl-specifier-seq* and each `Di` is an
+*init-declarator* or *member-declarator*. One exception is when a name
+introduced by one of the *declarator*s hides a type name used by the
+*decl-specifier*s, so that when the same *decl-specifier*s are used in a
+subsequent declaration, they do not have the same meaning, as in
 ``` cpp
 struct S { ... };
 S S, T;                 // declare two instances of struct S
 ```
 ```
 as opposed to
 ``` cpp
+auto i = 1;             // OK, i deduced to have type int
+auto j = 2.0;           // OK, j deduced to have type double
 ```
 — *end note*]
+The optional *requires-clause* in an *init-declarator* or
 *member-declarator* shall be present only if the declarator declares a
+templated function [[temp.pre]]. When present after a declarator, the
 *requires-clause* is called the *trailing *requires-clause**. The
 trailing *requires-clause* introduces the *constraint-expression* that
 results from interpreting its *constraint-logical-or-expression* as a
 *constraint-expression*.
 ### 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
+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*]
 — *end example*]
 ### Meaning of declarators <a id="dcl.meaning">[[dcl.meaning]]</a>
+#### General <a id="dcl.meaning.general">[[dcl.meaning.general]]</a>
+A declarator contains exactly one *declarator-id*; it names the entity
+that is declared. If the *unqualified-id* occurring in a *declarator-id*
+is a *template-id*, the declarator shall appear in the *declaration* of
+a *template-declaration* [[temp.decls]], *explicit-specialization*
+[[temp.expl.spec]], or *explicit-instantiation* [[temp.explicit]].
+[*Note 1*: An *unqualified-id* that is not an *identifier* is used to
+declare certain functions
+[[class.conv.fct]], [[class.dtor]], [[over.oper]], [[over.literal]]. — *end note*]
 The optional *attribute-specifier-seq* following a *declarator-id*
 appertains to the entity that is declared.
+If the declaration is a friend declaration:
+- The *declarator* does not bind a name.
+- If the *id-expression* E in the *declarator-id* of the *declarator* is
+  a *qualified-id* or a *template-id*:
+  - If the friend declaration is not a template declaration, then in the
+    lookup for the terminal name of E:
+    - if the *unqualified-id* in E is a *template-id*, all function
+      declarations are discarded;
+    - otherwise, if the *declarator* corresponds [[basic.scope.scope]]
+      to any declaration found of a non-template function, all function
+      template declarations are discarded;
+    - each remaining function template is replaced with the
+      specialization chosen by deduction from the friend declaration
+      [[temp.deduct.decl]] or discarded if deduction fails.
+  - The *declarator* shall correspond to one or more declarations found
+    by the lookup; they shall all have the same target scope, and the
+    target scope of the *declarator* is that scope.
+- Otherwise, the terminal name of E is not looked up. The declaration’s
+  target scope is the innermost enclosing namespace scope; if the
+  declaration is contained by a block scope, the declaration shall
+  correspond to a reachable [[module.reach]] declaration that inhabits
+  the innermost block scope.
+Otherwise:
+- If the *id-expression* in the *declarator-id* of the *declarator* is a
+  *qualified-id* Q, let S be its lookup context [[basic.lookup.qual]];
+  the declaration shall inhabit a namespace scope.
+- Otherwise, let S be the entity associated with the scope inhabited by
+  the *declarator*.
+- If the *declarator* declares an explicit instantiation or a partial or
+  explicit specialization, the *declarator* does not bind a name. If it
+  declares a class member, the terminal name of the *declarator-id* is
+  not looked up; otherwise, only those lookup results that are nominable
+  in S are considered when identifying any function template
+  specialization being declared [[temp.deduct.decl]].
+  \[*Example 1*:
+  ``` cpp
+  namespace N {
+    inline namespace O {
+      template<class T> void f(T);        // #1
+      template<class T> void g(T) {}
+    }
+    namespace P {
+      template<class T> void f(T*);       // #2, more specialized than #1
+      template<class> int g;
+    }
+    using P::f,P::g;
+  }
+  template<> void N::f(int*) {}           // OK, #2 is not nominable
+  template void N::g(int);                // error: lookup is ambiguous
+  ```
+  — *end example*]
+- Otherwise, the terminal name of the *declarator-id* is not looked up.
+  If it is a qualified name, the *declarator* shall correspond to one or
+  more declarations nominable in S; all the declarations shall have the
+  same target scope and the target scope of the *declarator* is that
+  scope.
+  \[*Example 2*:
+  ``` cpp
+  namespace Q {
+    namespace V {
+      void f();
+    }
+    void V::f() { ... }     // OK
+    void V::g() { ... }     // error: g() is not yet a member of V
+    namespace V {
+      void g();
+    }
+  }
+  namespace R {
+    void Q::V::g() { ... }  // error: R doesn't enclose Q
+  }
+  ```
+  — *end example*]
+- If the declaration inhabits a block scope S and declares a function
+  [[dcl.fct]] or uses the `extern` specifier, the declaration shall not
+  be attached to a named module [[module.unit]]; its target scope is the
+  innermost enclosing namespace scope, but the name is bound in S.
+  \[*Example 3*:
+  ``` cpp
+  namespace X {
+    void p() {
+      q();                        // error: q not yet declared
+      extern void q();            // q is a member of namespace X
+      extern void r();            // r is a member of namespace X
+    }
+    void middle() {
+      q();                        // error: q not found
+    }
+    void q() { ... }        // definition of X::q
+  }
+  void q() { ... }          // some other, unrelated q
+  void X::r() { ... }       // error: r cannot be declared by qualified-id
+  ```
+  — *end example*]
 A `static`, `thread_local`, `extern`, `mutable`, `friend`, `inline`,
+`virtual`, `constexpr`, `consteval`, `constinit`, or `typedef` specifier
+or an *explicit-specifier* applies directly to each *declarator-id* in a
+declaration; the type specified for each *declarator-id* depends on both
+the *decl-specifier-seq* and its *declarator*.
+Thus, (for each *declarator*) a declaration has the form
 ``` cpp
 T D
 ```
 T D
 ```
 the *decl-specifier-seq* `T` determines the type `T`.
+[*Example 4*:
 In the declaration
 ``` cpp
 int unsigned i;
 [[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' ')'
 ``` bnf
 '*' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ 'D1'
 ```
+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 `T`”. The *cv-qualifier*s apply to the
+pointer and not to the object pointed to. Similarly, the optional
+*attribute-specifier-seq* [[dcl.attr.grammar]] appertains to the pointer
+and not to the object pointed to.
 [*Example 1*:
 The declarations
 ``` bnf
 '&' attribute-specifier-seqₒₚₜ 'D1'
 '&&' attribute-specifier-seqₒₚₜ 'D1'
 ```
+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* reference to
+`T`”. The optional *attribute-specifier-seq* appertains to the reference
+type. Cv-qualified references are ill-formed except when the
+cv-qualifiers are introduced through the use of a *typedef-name*
+[[dcl.typedef]], [[temp.param]] or *decltype-specifier*
+[[dcl.type.decltype]], in which case the cv-qualifiers are ignored.
 [*Example 1*:
 ``` cpp
 typedef int& A;
 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*]
 function type has *cv-qualifier*s or a *ref-qualifier*; see
 [[dcl.fct]]. — *end note*]
 #### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
+The component names of a *ptr-operator* are those of its
+*nested-name-specifier*, if any.
 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.
 A type of the form “array of `N` `U`” or “array of unknown bound of `U`”
 is an *array type*. The optional *attribute-specifier-seq* appertains to
 the array type.
 `U` is called the array *element type*; this type shall not be a
+reference type, a function type, an array of unknown bound, or
+cv `void`.
 [*Note 1*: An array can be constructed from one of the fundamental
 types (except `void`), from a pointer, from a pointer to member, from a
 class, from an enumeration type, or from an array of known
 bound. — *end note*]
 — *end example*]
 [*Note 2*: An “array of `N` *cv-qualifier-seq* `U`” has cv-qualified
 type; see  [[basic.type.qualifier]]. — *end note*]
+An object of type “array of `N` `U`” consists of a contiguously
+allocated non-empty set of `N` subobjects of type `U`, known as the
+*elements* of the array, and numbered `0` to `N-1`.
 In addition to declarations in which an incomplete object type is
 allowed, an array bound may be omitted in some cases in the declaration
 of a function parameter [[dcl.fct]]. An array bound may also be omitted
 when an object (but not a non-static data member) of array type is
+initialized and the declarator is followed by an initializer
+[[dcl.init]], [[class.mem]], [[expr.type.conv]], [[expr.new]]. In these
 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];
 struct S {
   static int y[10];
 };
+int x[];                // OK, bound is 10
+int S::y[];             // OK, bound is 10
 void f() {
   extern int x[];
   int i = sizeof(x);    // error: incomplete object type
 }
 [*Note 3*:
 When several “array of” specifications are adjacent, a multidimensional
 array type is created; only the first of the constant expressions that
+specify the bounds of the arrays can be omitted.
 [*Example 4*:
 ``` cpp
 int x3d[3][5][7];
     parameter-declaration-list ',' parameter-declaration
 ```
 ``` bnf
 parameter-declaration:
+    attribute-specifier-seqₒₚₜ thisₒₚₜ decl-specifier-seq declarator
     attribute-specifier-seqₒₚₜ decl-specifier-seq declarator '=' initializer-clause
+    attribute-specifier-seqₒₚₜ thisₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ
     attribute-specifier-seqₒₚₜ decl-specifier-seq abstract-declaratorₒₚₜ '=' initializer-clause
 ```
 The optional *attribute-specifier-seq* in a *parameter-declaration*
 appertains to the parameter.
 accessing arguments passed using the ellipsis (see  [[expr.call]] and
 [[support.runtime]]). — *end note*]
 The type of a function is determined using the following rules. The type
 of each parameter (including function parameter packs) is determined
+from its own *parameter-declaration* [[dcl.decl]]. After determining the
+type of each parameter, any parameter of type “array of `T`” or of
 function type `T` is adjusted to be “pointer to `T`”. After producing
 the list of parameter types, any top-level *cv-qualifier*s modifying a
 parameter type are deleted when forming the function type. The resulting
 list of transformed parameter types and the presence or absence of the
 ellipsis or a function parameter pack is the function’s
 [*Note 3*: This transformation does not affect the types of the
 parameters. For example, `int(*)(const int p, decltype(p)*)` and
 `int(*)(int, const int*)` are identical types. — *end note*]
+[*Example 2*:
+``` cpp
+void f(char*);                  // #1
+void f(char[]) {}               // defines #1
+void f(const char*) {}          // OK, another overload
+void f(char *const) {}          // error: redefines #1
+void g(char(*)[2]);             // #2
+void g(char[3][2]) {}           // defines #2
+void g(char[3][3]) {}           // OK, another overload
+void h(int x(const int));       // #3
+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`.
+[*Example 3*:
+``` cpp
+struct C {
+  void f(this C& self);
+  template <typename Self> void g(this Self&& self, int);
+  void h(this C) const;         // error: const not allowed here
+};
+void test(C c) {
+  c.f();                        // OK, calls C::f
+  c.g(42);                      // OK, calls C::g<C&>
+  std::move(c).g(42);           // OK, calls C::g<C>
+}
+```
+— *end example*]
+A function parameter declared with an
+explicit-object-parameter-declaration is an *explicit object parameter*.
+An explicit object parameter shall not be a function parameter pack
+[[temp.variadic]]. An *explicit object member function* is a non-static
+member function with an explicit object parameter. An
+*implicit object member function* is a non-static member function
+without an explicit object parameter.
+The *object parameter* of a non-static member function is either the
+explicit object parameter or the implicit object parameter
+[[over.match.funcs]].
+A *non-object parameter* is a function parameter that is not the
+explicit object parameter. The *non-object-parameter-type-list* of a
+member function is the parameter-type-list of that function with the
+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 {
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
 latter case, the cv-qualifiers are ignored.
+[*Note 5*: A function type that has a *cv-qualifier-seq* is not a
 cv-qualified type; there are no cv-qualified function
 types. — *end note*]
+[*Example 5*:
 ``` cpp
 typedef void F();
 struct S {
+  const F f;        // OK, equivalent to: void f();
 };
 ```
 — *end example*]
 The return type, the parameter-type-list, the *ref-qualifier*, the
 *cv-qualifier-seq*, and the exception specification, but not the default
 arguments [[dcl.fct.default]] or the trailing *requires-clause*
 [[dcl.decl]], are part of the function type.
+[*Note 6*: Function types are checked during the assignments and
 initializations of pointers to functions, references to functions, and
 pointers to member functions. — *end note*]
+[*Example 6*:
 The declaration
 ``` cpp
 int fseek(FILE*, long, int);
 declares a function taking three arguments of the specified types, and
 returning `int` [[dcl.type]].
 — *end example*]
+[*Note 7*: A single name can be used for several different functions in
+a single scope; this is function overloading [[over]]. — *end note*]
+The return type shall be a non-array object type, a reference type, or
+cv `void`.
+[*Note 8*: An array of placeholder type is considered an array
+type. — *end note*]
 A volatile-qualified return type is deprecated; see
 [[depr.volatile.type]].
 Types shall not be defined in return or parameter types.
 A typedef of function type may be used to declare a function but shall
 not be used to define a function [[dcl.fct.def]].
+[*Example 7*:
 ``` cpp
 typedef void F();
+F  fv;              // OK, equivalent to void fv();
 F  fv { }           // error
+void fv() { }       // OK, definition of fv
 ```
 — *end example*]
 An identifier can optionally be provided as a parameter name; if present
 in a function definition [[dcl.fct.def]], it names a parameter.
+[*Note 9*: In particular, parameter names are also optional in function
 definitions and names used for a parameter in different declarations and
+the definition of a function need not be the same. — *end note*]
+[*Example 8*:
 The declaration
 ``` cpp
 int i,
 to indicate that indirection through a pointer to a function yields a
 function, which is then called.
 — *end example*]
+[*Note 10*:
 Typedefs and *trailing-return-type*s are sometimes convenient when the
 return type of a function is complex. For example, the function `fpif`
+above can be declared
 ``` cpp
 typedef int  IFUNC(int);
 IFUNC*  fpif(int);
 ```
 — *end note*]
 A *non-template function* is a function that is not a function template
 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
 *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 = /* ... */;
 template<typename T>     concept C2 = /* ... */;
 template<typename... Ts> concept C3 = /* ... */;
 void g2(C1 auto&...);
 void g3(C3 auto...);
 void g4(C3 auto);
 ```
+The declarations above are functionally equivalent (but not equivalent)
+to their respective declarations below:
 ``` cpp
 template<C1 T, C2 U> void g1(const T*, U&);
 template<C1... Ts>   void g2(Ts&...);
 template<C3... Ts>   void g3(Ts...);
 ```
 — *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 = /* ... */;
 template <typename T, C U>
 function parameter pack [[temp.variadic]]. Otherwise, the
 *parameter-declaration* is part of a *template-parameter-list* and
 declares a template parameter pack; see  [[temp.param]]. A function
 parameter pack is a pack expansion [[temp.variadic]].
+[*Example 11*:
 ``` cpp
 template<typename... T> void f(T (* ...t)(int, int));
 int add(int, int);
 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
+pack, or shall be a function parameter pack.
 [*Note 2*: A default argument cannot be redefined by a later
 declaration (not even to the same value)
 [[basic.def.odr]]. — *end note*]
 — *end example*]
 For a given inline function defined in different translation units, the
 accumulated sets of default arguments at the end of the translation
 units shall be the same; no diagnostic is required. If a friend
+declaration D specifies a default argument expression, that declaration
+shall be a definition and there shall be no other declaration of the
+function or function template which is reachable from D or from which D
+is reachable.
 The default argument has the same semantic constraints as the
 initializer in a declaration of a variable of the parameter type, using
 the copy-initialization semantics [[dcl.init]]. The names in the default
+argument are looked up, and the semantic constraints are checked, at the
+point where the default argument appears, except that an immediate
+invocation [[expr.const]] that is a potentially-evaluated subexpression
+[[intro.execution]] of the *initializer-clause* in a
+*parameter-declaration* is neither evaluated nor checked for whether it
+is a constant expression at that point. Name lookup and checking of
+semantic constraints for default arguments of templated functions are
+performed as described in  [[temp.inst]].
 [*Example 3*:
 In the following code, `g` will be called with the value `f(2)`:
 }
 ```
 — *end example*]
+[*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
   void f(int i = 3);
   void g(int i, int j = 99);
 };
 void C::f(int i = 3) {}         // error: default argument already specified in class scope
+void C::g(int i = 88, int j) {} // in this translation unit, C::g can be called with no arguments
 ```
 — *end example*]
+[*Note 4*: A local variable cannot be odr-used [[term.odr.use]] in a
 default argument. — *end note*]
 [*Example 5*:
 ``` cpp
 — *end example*]
 [*Note 5*:
+The keyword `this` cannot appear in a default argument of a member
 function; see  [[expr.prim.this]].
 [*Example 6*:
 ``` cpp
 — *end note*]
 A default argument is evaluated each time the function is called with no
 argument for the corresponding parameter. A parameter shall not appear
+as a potentially-evaluated expression in a default argument.
+[*Note 6*: Parameters of a function declared before a default argument
+are in scope and can hide namespace and class member
+names. — *end note*]
 [*Example 7*:
 ``` cpp
 int a;
 int f(int a, int b = a);            // error: parameter a used as default argument
 typedef int I;
 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
 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
 the pointer or reference denoting the object. An overriding function in
 a derived class does not acquire default arguments from the function it

Diff to HTML by rtfpessoa