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

Files changed (1) hide show

tmp/tmp6vlduq3n/{from.md → to.md} +1410 -1500

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

@@ -11,25 +11,35 @@ declaration-seq:
     declaration-seq declaration
 ```
 ``` bnf
 declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
     template-declaration
     deduction-guide
-    explicit-instantiation
-    explicit-specialization
-    export-declaration
     linkage-specification
     namespace-definition
     empty-declaration
     attribute-declaration
     module-import-declaration
 ```
 ``` bnf
 block-declaration:
     simple-declaration
     asm-declaration
     namespace-alias-definition
@@ -81,10 +91,16 @@ attribute-declaration:
 [[temp.deduct.guide]]; *namespace-definition*s are described in
 [[namespace.def]], *using-declaration*s are described in
 [[namespace.udecl]] and *using-directive*s are described in
 [[namespace.udir]]. — *end note*]
 A *simple-declaration* or *nodeclspec-function-declaration* of the form
 ``` bnf
 attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 ```
@@ -95,116 +111,155 @@ are described in  [[dcl.spec]]. *declarator*s, the components of an
 *init-declarator-list*, are described in [[dcl.decl]]. The
 *attribute-specifier-seq* appertains to each of the entities declared by
 the *declarator*s of the *init-declarator-list*.
 [*Note 2*: In the declaration for an entity, attributes appertaining to
-that entity may appear at the start of the declaration and after the
 *declarator-id* for that declaration. — *end note*]
 [*Example 1*:
 ``` cpp
 [[noreturn]] void f [[noreturn]] ();    // OK
 ```
 — *end example*]
-Except where otherwise specified, the meaning of an
-*attribute-declaration* is *implementation-defined*.
-A declaration occurs in a scope [[basic.scope]]; the scope rules are
-summarized in  [[basic.lookup]]. A declaration that declares a function
-or defines a class, namespace, template, or function also has one or
-more scopes nested within it. These nested scopes, in turn, can have
-declarations nested within them. Unless otherwise stated, utterances in
-[[dcl.dcl]] about components in, of, or contained by a declaration or
-subcomponent thereof refer only to those components of the declaration
-that are *not* nested within scopes nested within the declaration.
 In a *simple-declaration*, the optional *init-declarator-list* can be
-omitted only when declaring a class [[class]] or enumeration
 [[dcl.enum]], that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key*
 [[class.name]], or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
-*decl-specifier-seq*, the identifiers in these specifiers are among the
-names being declared by the declaration (as *class-name*s, *enum-name*s,
-or *enumerator*s, depending on the syntax). In such cases, the
-*decl-specifier-seq* shall introduce one or more names into the program,
-or shall redeclare a name introduced by a previous declaration.
 [*Example 2*:
 ``` cpp
 enum { };           // error
 typedef class { };  // error
 ```
 — *end example*]
-In a *static_assert-declaration*, the *constant-expression* shall be a
-contextually converted constant expression of type `bool`
-[[expr.const]]. If the value of the expression when so converted is
-`true`, the declaration has no effect. Otherwise, the program is
-ill-formed, and the resulting diagnostic message [[intro.compliance]]
-shall include the text of the *string-literal*, if one is supplied,
-except that characters not in the basic source character set
-[[lex.charset]] are not required to appear in the diagnostic message.
-[*Example 3*:
-``` cpp
-static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
-```
-— *end example*]
-An *empty-declaration* has no effect.
 A *simple-declaration* with an *identifier-list* is called a *structured
-binding declaration* [[dcl.struct.bind]]. If the *decl-specifier-seq*
-contains any *decl-specifier* other than `static`, `thread_local`,
-`auto` [[dcl.spec.auto]], or *cv-qualifier*s, the program is ill-formed.
 The *initializer* shall be of the form “`=` *assignment-expression*”, of
 the form “`{` *assignment-expression* `}`”, or of the form “`(`
 *assignment-expression* `)`”, where the *assignment-expression* is of
 array or non-union class type.
-Each *init-declarator* in the *init-declarator-list* contains exactly
-one *declarator-id*, which is the name declared by that
-*init-declarator* and hence one of the names declared by the
-declaration. The *defining-type-specifier*s [[dcl.type]] in the
-*decl-specifier-seq* and the recursive *declarator* structure of the
-*init-declarator* describe a type [[dcl.meaning]], which is then
-associated with the name being declared by the *init-declarator*.
 If the *decl-specifier-seq* contains the `typedef` specifier, the
-declaration is called a *typedef declaration* and the name of each
-*init-declarator* is declared to be a *typedef-name*, synonymous with
-its associated type [[dcl.typedef]]. If the *decl-specifier-seq*
-contains no `typedef` specifier, the declaration is called a *function
-declaration* if the type associated with the name is a function type
-[[dcl.fct]] and an *object declaration* otherwise.
 Syntactic components beyond those found in the general form of
-declaration are added to a function declaration to make a
 *function-definition*. An object declaration, however, is also a
 definition unless it contains the `extern` specifier and has no
 initializer [[basic.def]]. An object definition causes storage of
 appropriate size and alignment to be reserved and any appropriate
 initialization [[dcl.init]] to be done.
 A *nodeclspec-function-declaration* shall declare a constructor,
 destructor, or conversion function.
-[*Note 3*: A *nodeclspec-function-declaration* can only be used in a
 *template-declaration* [[temp.pre]], *explicit-instantiation*
 [[temp.explicit]], or *explicit-specialization*
 [[temp.expl.spec]]. — *end note*]
 ## Specifiers <a id="dcl.spec">[[dcl.spec]]</a>
 The specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
@@ -296,15 +351,14 @@ At most one *storage-class-specifier* shall appear in a given
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
 *init-declarator-list* or *member-declarator-list* of the declaration
-shall not be empty (except for an anonymous union declared in a named
-namespace or in the global namespace, which shall be declared `static`
-[[class.union.anon]]). The *storage-class-specifier* applies to the name
-declared by each *init-declarator* in the list and not to any names
-declared by other specifiers.
 [*Note 1*: See [[temp.expl.spec]] and [[temp.explicit]] for
 restrictions in explicit specializations and explicit instantiations,
 respectively. — *end note*]
@@ -340,14 +394,15 @@ a name declared with an `extern` specifier, see  [[basic.link]].
 [*Note 3*: The `extern` keyword can also be used in
 *explicit-instantiation*s and *linkage-specification*s, but it is not a
 *storage-class-specifier* in such contexts. — *end note*]
-The linkages implied by successive declarations for a given entity shall
-agree. That is, within a given scope, each declaration declaring the
-same variable name or the same overloading of a function name shall
-imply the same linkage.
 [*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
@@ -418,15 +473,15 @@ class X {
 };
 ```
 — *end example*]
-[*Note 4*: The `mutable` specifier on a class data member nullifies a
 `const` specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
-object is const ([[basic.type.qualifier]],
-[[dcl.type.cv]]). — *end note*]
 ### Function specifiers <a id="dcl.fct.spec">[[dcl.fct.spec]]</a>
 A *function-specifier* can be used only in a function declaration.
@@ -441,11 +496,11 @@ explicit-specifier:
     explicit '(' constant-expression ')'
     explicit
 ```
 The `virtual` specifier shall be used only in the initial declaration of
-a non-static class member function; see  [[class.virtual]].
 An *explicit-specifier* shall be used only in the declaration of a
 constructor or conversion function within its class definition; see
 [[class.conv.ctor]] and  [[class.conv.fct]].
@@ -456,10 +511,21 @@ shall be a contextually converted constant expression of type `bool`
 `explicit(true)`. If the constant expression evaluates to `true`, the
 function is explicit. Otherwise, the function is not explicit. A `(`
 token that follows `explicit` is parsed as part of the
 *explicit-specifier*.
 ### The `typedef` specifier <a id="dcl.typedef">[[dcl.typedef]]</a>
 Declarations containing the *decl-specifier* `typedef` declare
 identifiers that can be used later for naming fundamental
 [[basic.fundamental]] or compound [[basic.compound]] types. The
@@ -502,118 +568,43 @@ are all correct declarations; the type of `distance` is `int` and that
 of `metricp` is “pointer to `int`”.
 — *end example*]
 A *typedef-name* can also be introduced by an *alias-declaration*. The
-*identifier* following the `using` keyword becomes a *typedef-name* and
-the optional *attribute-specifier-seq* following the *identifier*
-appertains to that *typedef-name*. Such a *typedef-name* has the same
-semantics as if it were introduced by the `typedef` specifier. In
-particular, it does not define a new type.
 [*Example 2*:
 ``` cpp
 using handler_t = void (*)(int);
 extern handler_t ignore;
 extern void (*ignore)(int);         // redeclare ignore
-using cell = pair<void*, cell*>;    // error
 ```
 — *end example*]
 The *defining-type-specifier-seq* of the *defining-type-id* shall not
 define a class or enumeration if the *alias-declaration* is the
 *declaration* of a *template-declaration*.
-In a given non-class scope, a `typedef` specifier can be used to
-redeclare the name of any type declared in that scope to refer to the
-type to which it already refers.
-[*Example 3*:
-``` cpp
-typedef struct s { ... } s;
-typedef int I;
-typedef int I;
-typedef I I;
-```
-— *end example*]
-In a given class scope, a `typedef` specifier can be used to redeclare
-any *class-name* declared in that scope that is not also a
-*typedef-name* to refer to the type to which it already refers.
-[*Example 4*:
-``` cpp
-struct S {
-  typedef struct A { } A;       // OK
-  typedef struct B B;           // OK
-  typedef A A;                  // error
-};
-```
-— *end example*]
-If a `typedef` specifier is used to redeclare in a given scope an entity
-that can be referenced using an *elaborated-type-specifier*, the entity
-can continue to be referenced by an *elaborated-type-specifier* or as an
-enumeration or class name in an enumeration or class definition
-respectively.
-[*Example 5*:
-``` cpp
-struct S;
-typedef struct S S;
-int main() {
-  struct S* p;                  // OK
-}
-struct S { };                   // OK
-```
-— *end example*]
-In a given scope, a `typedef` specifier shall not be used to redeclare
-the name of any type declared in that scope to refer to a different
-type.
-[*Example 6*:
-``` cpp
-class complex { ... };
-typedef int complex;            // error: redefinition
-```
-— *end example*]
-Similarly, in a given scope, a class or enumeration shall not be
-declared with the same name as a *typedef-name* that is declared in that
-scope and refers to a type other than the class or enumeration itself.
-[*Example 7*:
-``` cpp
-typedef int complex;
-class complex { ... };    // error: redefinition
-```
-— *end example*]
 A *simple-template-id* is only a *typedef-name* if its *template-name*
 names an alias template or a template *template-parameter*.
 [*Note 1*: A *simple-template-id* that names a class template
 specialization is a *class-name* [[class.name]]. If a *typedef-name* is
 used to identify the subject of an *elaborated-type-specifier*
 [[dcl.type.elab]], a class definition [[class]], a constructor
 declaration [[class.ctor]], or a destructor declaration [[class.dtor]],
 the program is ill-formed. — *end note*]
-[*Example 8*:
 ``` cpp
 struct S {
   S();
   ~S();
@@ -625,23 +616,23 @@ S a = T();                      // OK
 struct T * p;                   // error
 ```
 — *end example*]
-If the typedef declaration defines an unnamed class or enumeration, the
-first *typedef-name* declared by the declaration to be that type is used
-to denote the type for linkage purposes only [[basic.link]].
 [*Note 2*: A typedef declaration involving a *lambda-expression* does
 not itself define the associated closure type, and so the closure type
-is not given a name for linkage purposes. — *end note*]
-[*Example 9*:
 ``` cpp
-typedef struct { } *ps, S;      // S is the class name for linkage purposes
-typedef decltype([]{}) C;       // the closure type has no name for linkage purposes
 ```
 — *end example*]
 An unnamed class with a typedef name for linkage purposes shall not
@@ -652,11 +643,11 @@ An unnamed class with a typedef name for linkage purposes shall not
 - contain a *lambda-expression*,
 and all member classes shall also satisfy these requirements
 (recursively).
-[*Example 10*:
 ``` cpp
 typedef struct {
   int f() {}
 } X;                            // error: struct with typedef name for linkage has member functions
@@ -689,58 +680,52 @@ specifier. — *end note*]
 `constexpr`. — *end note*]
 [*Example 1*:
 ``` cpp
-constexpr void square(int &x);  // OK: declaration
-constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
   int x;
   int y;
-  constexpr pixel(int);         // OK: declaration
 };
 constexpr pixel::pixel(int a)
-  : x(a), y(x)                  // OK: definition
   { square(x); }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant[expr.const] so constexpr not satisfied
-constexpr void square(int &x) { // OK: definition
   x *= x;
 }
-constexpr pixel large(4);       // OK: square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
 extern constexpr int memsz;     // error: not a definition
 ```
 — *end example*]
 A `constexpr` or `consteval` specifier used in the declaration of a
-function declares that function to be a *constexpr function*. A function
-or constructor declared with the `consteval` specifier is called an
-*immediate function*. A destructor, an allocation function, or a
-deallocation function shall not be declared with the `consteval`
-specifier.
-The definition of a constexpr function shall satisfy the following
-requirements:
-- its return type (if any) shall be a literal type;
-- each of its parameter types shall be a literal type;
-- it shall not be a coroutine [[dcl.fct.def.coroutine]];
-- if the function is a constructor or destructor, its class shall not
-  have any virtual base classes;
-- its *function-body* shall not enclose [[stmt.pre]]
-  - a `goto` statement,
-  - an identifier label [[stmt.label]],
-  - a definition of a variable of non-literal type or of static or
-    thread storage duration.
-  \[*Note 3*: A *function-body* that is `= delete` or `= default`
-  encloses none of the above. — *end note*]
 [*Example 2*:
 ``` cpp
 constexpr int square(int x)
@@ -750,14 +735,17 @@ constexpr long long_max()
 constexpr int abs(int x) {
   if (x < 0)
     x = -x;
   return x;                     // OK
 }
-constexpr int first(int n) {
- static int value = n;         // error: variable has static storage duration
     return value;
   }
 constexpr int uninit() {
   struct { int a; } s;
   return s.a;                   // error: uninitialized read of s.a
 }
 constexpr int prev(int x)
@@ -769,77 +757,10 @@ constexpr int g(int x, int n) { // OK
 }
 ```
 — *end example*]
-The definition of a constexpr constructor whose *function-body* is not
-`= delete` shall additionally satisfy the following requirements:
-- for a non-delegating constructor, every constructor selected to
-  initialize non-static data members and base class subobjects shall be
-  a constexpr constructor;
-- for a delegating constructor, the target constructor shall be a
-  constexpr constructor.
-[*Example 3*:
-``` cpp
-struct Length {
-  constexpr explicit Length(int i = 0) : val(i) { }
-private:
-  int val;
-};
-```
-— *end example*]
-The definition of a constexpr destructor whose *function-body* is not
-`= delete` shall additionally satisfy the following requirement:
-- for every subobject of class type or (possibly multi-dimensional)
-  array thereof, that class type shall have a constexpr destructor.
-For a constexpr function or constexpr constructor that is neither
-defaulted nor a template, if no argument values exist such that an
-invocation of the function or constructor could be an evaluated
-subexpression of a core constant expression [[expr.const]], or, for a
-constructor, an evaluated subexpression of the initialization
-full-expression of some constant-initialized object
-[[basic.start.static]], the program is ill-formed, no diagnostic
-required.
-[*Example 4*:
-``` cpp
-constexpr int f(bool b)
-  { return b ? throw 0 : 0; }           // OK
-constexpr int f() { return f(true); }   // ill-formed, no diagnostic required
-struct B {
-  constexpr B(int x) : i(0) { }         // x is unused
-  int i;
-};
-int global;
-struct D : B {
-  constexpr D() : B(global) { }         // ill-formed, no diagnostic required
-                                        // lvalue-to-rvalue conversion on non-constant global
-};
-```
-— *end example*]
-If the instantiated template specialization of a constexpr function
-template or member function of a class template would fail to satisfy
-the requirements for a constexpr function, that specialization is still
-a constexpr function, even though a call to such a function cannot
-appear in a constant expression. If no specialization of the template
-would satisfy the requirements for a constexpr function when considered
-as a non-template function, the template is ill-formed, no diagnostic
-required.
 An invocation of a constexpr function in a given context produces the
 same result as an invocation of an equivalent non-constexpr function in
 the same context in all respects except that
 - an invocation of a constexpr function can appear in a constant
@@ -850,14 +771,18 @@ the same context in all respects except that
 [*Note 4*: Declaring a function constexpr can change whether an
 expression is a constant expression. This can indirectly cause calls to
 `std::is_constant_evaluated` within an invocation of the function to
 produce a different value. — *end note*]
 The `constexpr` and `consteval` specifiers have no effect on the type of
 a constexpr function.
-[*Example 5*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
     { return x + y + x*y; }
 // ...
@@ -869,13 +794,15 @@ int bar(int x, int y)                   // error: redefinition of bar
 A `constexpr` specifier used in an object declaration declares the
 object as const. Such an object shall have literal type and shall be
 initialized. In any `constexpr` variable declaration, the
 full-expression of the initialization shall be a constant expression
-[[expr.const]]. A `constexpr` variable shall have constant destruction.
-[*Example 6*:
 ``` cpp
 struct pixel {
   int x, y;
 };
@@ -892,15 +819,16 @@ variable with static or thread storage duration. If the specifier is
 applied to any declaration of a variable, it shall be applied to the
 initializing declaration. No diagnostic is required if no `constinit`
 declaration is reachable at the point of the initializing declaration.
 If a variable declared with the `constinit` specifier has dynamic
-initialization [[basic.start.dynamic]], the program is ill-formed.
 [*Note 1*: The `constinit` specifier ensures that the variable is
-initialized during static initialization
-[[basic.start.static]]. — *end note*]
 [*Example 1*:
 ``` cpp
 const char * g() { return "dynamic initialization"; }
@@ -914,11 +842,11 @@ constinit const char * d = f(false);    // error
 ### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
 The `inline` specifier shall be applied only to the declaration of a
 variable or function.
-A function declaration ([[dcl.fct]], [[class.mfct]], [[class.friend]])
 with an `inline` specifier declares an *inline function*. The inline
 specifier indicates to the implementation that inline substitution of
 the function body at the point of call is to be preferred to the usual
 function call mechanism. An implementation is not required to perform
 this inline substitution at the point of call; however, even if this
@@ -943,29 +871,30 @@ function or variable with external or module linkage is declared inline
 in one definition domain, an inline declaration of it shall be reachable
 from the end of every definition domain in which it is declared; no
 diagnostic is required.
 [*Note 2*: A call to an inline function or a use of an inline variable
-may be encountered before its definition becomes reachable in a
 translation unit. — *end note*]
 [*Note 3*: An inline function or variable with external or module
-linkage has the same address in all translation units. A `static` local
-variable in an inline function with external or module linkage always
-refers to the same object. A type defined within the body of an inline
-function with external or module linkage is the same type in every
-translation unit. — *end note*]
 If an inline function or variable that is attached to a named module is
 declared in a definition domain, it shall be defined in that domain.
 [*Note 4*: A constexpr function [[dcl.constexpr]] is implicitly inline.
 In the global module, a function defined within a class definition is
-implicitly inline ([[class.mfct]], [[class.friend]]). — *end note*]
 ### Type specifiers <a id="dcl.type">[[dcl.type]]</a>
 The type-specifiers are
 ``` bnf
 type-specifier:
   simple-type-specifier
@@ -1020,11 +949,11 @@ function, at least one *defining-type-specifier* that is not a
 complete *decl-specifier-seq*.[^1]
 [*Note 1*: *enum-specifier*s, *class-specifier*s, and
 *typename-specifier*s are discussed in [[dcl.enum]], [[class]], and
 [[temp.res]], respectively. The remaining *type-specifier*s are
-discussed in the rest of this subclause. — *end note*]
 #### The *cv-qualifier*s <a id="dcl.type.cv">[[dcl.type.cv]]</a>
 There are two *cv-qualifier*s, `const` and `volatile`. Each
 *cv-qualifier* shall appear at most once in a *cv-qualifier-seq*. If a
@@ -1053,23 +982,24 @@ the object referenced is a non-const object and can be modified through
 some other access path.
 [*Note 4*: Cv-qualifiers are supported by the type system so that they
 cannot be subverted without casting [[expr.const.cast]]. — *end note*]
-Any attempt to modify ([[expr.ass]], [[expr.post.incr]],
-[[expr.pre.incr]]) a const object [[basic.type.qualifier]] during its
-lifetime [[basic.life]] results in undefined behavior.
 [*Example 1*:
 ``` cpp
 const int ci = 3;                       // cv-qualified (initialized as required)
 ci = 4;                                 // error: attempt to modify const
 int i = 2;                              // not cv-qualified
 const int* cip;                         // pointer to const int
-cip = &i;                               // OK: cv-qualified access path to unqualified
 *cip = 4;                               // error: attempt to modify through ptr to const
 int* ip;
 ip = const_cast<int*>(cip);             // cast needed to convert const int* to int*
 *ip = 4;                                // defined: *ip points to i, a non-const object
@@ -1147,10 +1077,16 @@ type-name:
     class-name
     enum-name
     typedef-name
 ```
 A *placeholder-type-specifier* is a placeholder for a type to be deduced
 [[dcl.spec.auto]]. A *type-specifier* of the form `typename`ₒₚₜ
 *nested-name-specifier*ₒₚₜ  *template-name* is a placeholder for a
 deduced class type [[dcl.type.class.deduct]]. The
 *nested-name-specifier*, if any, shall be non-dependent and the
@@ -1233,49 +1169,72 @@ contexts. — *end note*]
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
     class-key simple-template-id
     class-key nested-name-specifier templateₒₚₜ simple-template-id
-    elaborated-enum-specifier
-```
-``` bnf
-elaborated-enum-specifier:
     enum nested-name-specifierₒₚₜ identifier
 ```
-An *attribute-specifier-seq* shall not appear in an
-*elaborated-type-specifier* unless the latter is the sole constituent of
-a declaration. If an *elaborated-type-specifier* is the sole constituent
-of a declaration, the declaration is ill-formed unless it is an explicit
 specialization [[temp.expl.spec]], an explicit instantiation
 [[temp.explicit]] or it has one of the following forms:
 ``` bnf
 class-key attribute-specifier-seqₒₚₜ identifier ';'
-friend class-key '::ₒₚₜ ' identifier ';'
-friend class-key '::ₒₚₜ ' simple-template-id ';'
-friend class-key nested-name-specifier identifier ';'
 friend class-key nested-name-specifier templateₒₚₜ simple-template-id ';'
 ```
-In the first case, the *attribute-specifier-seq*, if any, appertains to
-the class being declared; the attributes in the
-*attribute-specifier-seq* are thereafter considered attributes of the
-class whenever it is named.
-[*Note 1*:  [[basic.lookup.elab]] describes how name lookup proceeds
-for the *identifier* in an *elaborated-type-specifier*. — *end note*]
 If the *identifier* or *simple-template-id* resolves to a *class-name*
 or *enum-name*, the *elaborated-type-specifier* introduces it into the
 declaration the same way a *simple-type-specifier* introduces its
 *type-name* [[dcl.type.simple]]. If the *identifier* or
-*simple-template-id* resolves to a *typedef-name* ([[dcl.typedef]],
-[[temp.names]]), the *elaborated-type-specifier* is ill-formed.
-[*Note 2*:
 This implies that, within a class template with a template
 *type-parameter* `T`, the declaration
 ``` cpp
@@ -1323,23 +1282,23 @@ follows:
   [[dcl.struct.bind]], `decltype(E)` is the referenced type as given in
   the specification of the structured binding declaration;
 - otherwise, if E is an unparenthesized *id-expression* naming a
   non-type *template-parameter* [[temp.param]], `decltype(E)` is the
   type of the *template-parameter* after performing any necessary type
-  deduction ([[dcl.spec.auto]], [[dcl.type.class.deduct]]);
 - otherwise, if E is an unparenthesized *id-expression* or an
   unparenthesized class member access [[expr.ref]], `decltype(E)` is the
-  type of the entity named by E. If there is no such entity, or if E
- names a set of overloaded functions, the program is ill-formed;
 - otherwise, if E is an xvalue, `decltype(E)` is `T&&`, where `T` is the
   type of E;
 - otherwise, if E is an lvalue, `decltype(E)` is `T&`, where `T` is the
   type of E;
 - otherwise, `decltype(E)` is the type of E.
 The operand of the `decltype` specifier is an unevaluated operand
-[[expr.prop]].
 [*Example 1*:
 ``` cpp
 const int&& foo();
@@ -1389,11 +1348,11 @@ template<class T> auto f(T)     // #1
                                 // for the temporary introduced by the use of h().
                                 // (A temporary is not introduced as a result of the use of i().)
 template<class T> auto f(T)     // #2
   -> void;
 auto g() -> void {
-  f(42);                        // OK: calls #2. (#1 is not a viable candidate: type deduction
                                 // fails[temp.deduct] because A<int>::~A() is implicitly used in its
                                 // decltype-specifier)
 }
 template<class T> auto q(T)
   -> decltype((h<T>()));        // does not force completion of A<T>; A<T>::~A() is not implicitly
@@ -1408,10 +1367,12 @@ void r() {
 — *end example*]
 #### Placeholder type specifiers <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
 ``` bnf
 placeholder-type-specifier:
   type-constraintₒₚₜ auto
   type-constraintₒₚₜ decltype '(' auto ')'
 ```
@@ -1428,11 +1389,11 @@ placeholder* of the function declaration or *lambda-expression*.
 [*Note 1*: Having a generic parameter type placeholder signifies that
 the function is an abbreviated function template [[dcl.fct]] or the
 lambda is a generic lambda [[expr.prim.lambda]]. — *end note*]
-The placeholder type can appear with a function declarator in the
 *decl-specifier-seq*, *type-specifier-seq*, *conversion-function-id*, or
 *trailing-return-type*, in any context where such a declarator is valid.
 If the function declarator includes a *trailing-return-type*
 [[dcl.fct]], that *trailing-return-type* specifies the declared return
 type of the function. Otherwise, the function declarator shall declare a
@@ -1444,54 +1405,49 @@ non-discarded `return` statements, if any, in the body of the function
 The type of a variable declared using a placeholder type is deduced from
 its initializer. This use is allowed in an initializing declaration
 [[dcl.init]] of a variable. The placeholder type shall appear as one of
 the *decl-specifier*s in the *decl-specifier-seq* and the
 *decl-specifier-seq* shall be followed by one or more *declarator*s,
-each of which shall be followed by a non-empty *initializer*. In an
-*initializer* of the form
-``` cpp
-( expression-list )
-```
-the *expression-list* shall be a single *assignment-expression*.
 [*Example 1*:
 ``` cpp
-auto x = 5;                     // OK: x has type int
-const auto *v = &x, u = 6;      // OK: v has type const int*, u has type const int
-static auto y = 0.0;            // OK: y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
-auto f() -> int;                // OK: f returns int
-auto g() { return 0.0; }        // OK: g returns double
-auto h();                       // OK: h's return type will be deduced when it is defined
 ```
 — *end example*]
 The `auto` *type-specifier* can also be used to introduce a structured
 binding declaration [[dcl.struct.bind]].
 A placeholder type can also be used in the *type-specifier-seq* in the
 *new-type-id* or *type-id* of a *new-expression* [[expr.new]] and as a
 *decl-specifier* of the *parameter-declaration*'s *decl-specifier-seq*
-in a *template-parameter* [[temp.param]].
 A program that uses a placeholder type in a context not explicitly
-allowed in this subclause is ill-formed.
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
 variable is determined by placeholder type deduction
 [[dcl.type.auto.deduct]], and if the type that replaces the placeholder
 type is not the same in each deduction, the program is ill-formed.
 [*Example 2*:
 ``` cpp
-auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
 — *end example*]
@@ -1519,15 +1475,15 @@ type shall be defined in the translation unit containing its exported
 declaration, outside the *private-module-fragment* (if any).
 [*Note 2*: The deduced return type cannot have a name with internal
 linkage [[basic.link]]. — *end note*]
-If the name of an entity with an undeduced placeholder type appears in
-an expression, the program is ill-formed. Once a non-discarded `return`
-statement has been seen in a function, however, the return type deduced
-from that statement can be used in the rest of the function, including
-in other `return` statements.
 [*Example 4*:
 ``` cpp
 auto n = n;                     // error: n's initializer refers to n
@@ -1541,14 +1497,14 @@ auto sum(int i) {
 }
 ```
 — *end example*]
-Return type deduction for a templated entity that is a function or
-function template with a placeholder in its declared type occurs when
-the definition is instantiated even if the function body contains a
-`return` statement with a non-type-dependent operand.
 [*Note 3*: Therefore, any use of a specialization of the function
 template will cause an implicit instantiation. Any errors that arise
 from this instantiation are not in the immediate context of the function
 type and can result in the program being ill-formed
@@ -1564,24 +1520,22 @@ void g() { int (*p)(int*) = &f; }               // instantiates both fs to deter
                                                 // chooses second
 ```
 — *end example*]
-Redeclarations or specializations of a function or function template
-with a declared return type that uses a placeholder type shall also use
-that placeholder, not a deduced type. Similarly, redeclarations or
-specializations of a function or function template with a declared
-return type that does not use a placeholder type shall not use a
-placeholder.
 [*Example 6*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
-int f();                                        // error: cannot be overloaded with auto f()
 decltype(auto) f();                             // error: auto and decltype(auto) don't match
 template <typename T> auto g(T t) { return t; } // #1
 template auto g(int);                           // OK, return type is int
 template char g(char);                          // error: no matching template
@@ -1633,44 +1587,63 @@ int (*p)(int) = f;              // instantiates f<int> to determine its return t
 *Placeholder type deduction* is the process by which a type containing a
 placeholder type is replaced by a deduced type.
 A type `T` containing a placeholder type, and a corresponding
-initializer E, are determined as follows:
-- for a non-discarded `return` statement that occurs in a function
   declared with a return type that contains a placeholder type, `T` is
-  the declared return type and E is the operand of the `return`
- statement. If the `return` statement has no operand, then E is
- `void()`;
-- for a variable declared with a type that contains a placeholder type,
- `T` is the declared type of the variable and E is the initializer. If
-  the initialization is direct-list-initialization, the initializer
-  shall be a *braced-init-list* containing only a single
- *assignment-expression* and E is the *assignment-expression*;
-- for a non-type template parameter declared with a type that contains a
   placeholder type, `T` is the declared type of the non-type template
   parameter and E is the corresponding template argument.
-In the case of a `return` statement with no operand or with an operand
-of type `void`, `T` shall be either *type-constraint*ₒₚₜ
-`decltype(auto)` or cv *type-constraint*ₒₚₜ  `auto`.
-If the deduction is for a `return` statement and E is a
-*braced-init-list* [[dcl.init.list]], the program is ill-formed.
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `auto`, the deduced type T' replacing `T` is determined using the rules
-for template argument deduction. Obtain `P` from `T` by replacing the
-occurrences of *type-constraint*ₒₚₜ  `auto` either with a new invented
-type template parameter `U` or, if the initialization is
-copy-list-initialization, with `std::initializer_list<U>`. Deduce a
-value for `U` using the rules of template argument deduction from a
-function call [[temp.deduct.call]], where `P` is a function template
-parameter type and the corresponding argument is E. If the deduction
-fails, the declaration is ill-formed. Otherwise, T' is obtained by
-substituting the deduced `U` into `P`.
 [*Example 8*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
@@ -1697,12 +1670,12 @@ template <class U> void f(const U& u);
 — *end example*]
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `decltype(auto)`, `T` shall be the placeholder alone. The type deduced
-for `T` is determined as described in  [[dcl.type.simple]], as though E
-had been the operand of the `decltype`.
 [*Example 10*:
 ``` cpp
 int i;
@@ -1717,10 +1690,12 @@ auto           x5a = f();       // decltype(x5a) is int
 decltype(auto) x5d = f();       // decltype(x5d) is int&&
 auto           x6a = { 1, 2 };  // decltype(x6a) is std::initializer_list<int>
 decltype(auto) x6d = { 1, 2 };  // error: { 1, 2 } is not an expression
 auto          *x7a = &i;        // decltype(x7a) is int*
 decltype(auto)*x7d = &i;        // error: declared type is not plain decltype(auto)
 ```
 — *end example*]
 For a *placeholder-type-specifier* with a *type-constraint*, the
@@ -1779,14 +1754,16 @@ container e{5, 6};                      // error: int is not an iterator
 — *end example*]
 ## 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
@@ -1796,28 +1773,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;
 ```
@@ -1826,14 +1806,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
 ```
@@ -1853,19 +1833,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*.
@@ -2027,16 +2007,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*]
@@ -2119,41 +2100,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
 ```
@@ -2168,11 +2245,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;
@@ -2182,11 +2259,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' ')'
@@ -2208,17 +2285,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
@@ -2282,18 +2359,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;
@@ -2382,12 +2459,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*]
@@ -2416,19 +2493,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.
@@ -2503,12 +2583,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*]
@@ -2539,39 +2619,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
 }
@@ -2581,11 +2661,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];
@@ -2683,13 +2763,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.
@@ -2738,12 +2818,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
@@ -2751,24 +2831,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 {
@@ -2781,35 +2931,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);
@@ -2818,50 +2968,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,
@@ -2887,15 +3033,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);
 ```
@@ -2922,11 +3068,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
@@ -2935,18 +3081,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 = /* ... */;
@@ -2955,12 +3101,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...);
@@ -2975,15 +3121,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>
@@ -3013,11 +3159,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);
@@ -3073,18 +3219,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*]
@@ -3118,22 +3264,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)`:
@@ -3151,14 +3301,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
@@ -3175,16 +3324,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
@@ -3198,11 +3347,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
@@ -3215,22 +3364,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
@@ -3276,16 +3427,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
@@ -3310,11 +3462,13 @@ void m() {
 — *end example*]
 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
-The process of initialization described in this subclause applies to all
 initializations regardless of syntactic context, including the
 initialization of a function parameter [[expr.call]], the initialization
 of a return value [[stmt.return]], or when an initializer follows a
 declarator.
@@ -3369,13 +3523,13 @@ designator:
 expr-or-braced-init-list:
     expression
     braced-init-list
 ```
-[*Note 1*: The rules in this subclause apply even if the grammar
-permits only the *brace-or-equal-initializer* form of *initializer* in a
-given context. — *end note*]
 Except for objects declared with the `constexpr` specifier, for which
 see  [[dcl.constexpr]], an *initializer* in the definition of a variable
 can consist of arbitrary expressions involving literals and previously
 declared variables and functions, regardless of the variable’s storage
@@ -3397,26 +3551,26 @@ int c(b);
 [*Note 3*: The order of initialization of variables with static storage
 duration is described in  [[basic.start]] and
 [[stmt.dcl]]. — *end note*]
-A declaration of a block-scope variable with external or internal
-linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
-- if `T` is a scalar type [[basic.types]], the object is initialized to
-  the value obtained by converting the integer literal `0` (zero) to
-  `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
-  bits [[basic.types]] are initialized to zero bits and each non-static
-  data member, each non-virtual base class subobject, and, if the object
-  is not a base class subobject, each virtual base class subobject is
-  zero-initialized;
 - if `T` is a (possibly cv-qualified) union type, its padding bits
-  [[basic.types]] are initialized to zero bits and the object’s first
-  non-static named data member is zero-initialized;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
@@ -3466,62 +3620,25 @@ of an entity of reference type is ill-formed.
 [*Note 4*: For every object of static storage duration, static
 initialization [[basic.start.static]] is performed at program startup
 before any other initialization takes place. In some cases, additional
 initialization is done later. — *end note*]
-An object whose initializer is an empty set of parentheses, i.e., `()`,
-shall be value-initialized.
-[*Note 5*:
-Since `()` is not permitted by the syntax for *initializer*,
-``` cpp
-X a();
-```
-is not the declaration of an object of class `X`, but the declaration of
-a function taking no argument and returning an `X`. The form `()` is
-permitted in certain other initialization contexts ([[expr.new]],
-[[expr.type.conv]], [[class.base.init]]).
-— *end note*]
 If no initializer is specified for an object, the object is
 default-initialized.
-An initializer for a static member is in the scope of the member’s
-class.
-[*Example 2*:
-``` cpp
-int a;
-struct X {
-  static int a;
-  static int b;
-};
-int X::a = 1;
-int X::b = a;                   // X::b = X::a
-```
-— *end example*]
 If the entity being initialized does not have class type, the
 *expression-list* in a parenthesized initializer shall be a single
 expression.
 The initialization that occurs in the `=` form of a
 *brace-or-equal-initializer* or *condition* [[stmt.select]], as well as
 in argument passing, function return, throwing an exception
 [[except.throw]], handling an exception [[except.handle]], and aggregate
-member initialization [[dcl.init.aggr]], is called
-*copy-initialization*.
-[*Note 6*: Copy-initialization may invoke a move
 [[class.copy.ctor]]. — *end note*]
 The initialization that occurs
 - for an *initializer* that is a parenthesized *expression-list* or a
@@ -3546,10 +3663,21 @@ defined.
 - If the destination type is an array of characters, an array of
   `char8_t`, an array of `char16_t`, an array of `char32_t`, or an array
   of `wchar_t`, and the initializer is a *string-literal*, see
   [[dcl.init.string]].
 - If the initializer is `()`, the object is value-initialized.
 - Otherwise, if the destination type is an array, the object is
   initialized as follows. Let x₁, …, xₖ be the elements of the
   *expression-list*. If the destination type is an array of unknown
   bound, it is defined as having k elements. Let n denote the array size
   after this potential adjustment. If k is greater than n, the program
@@ -3562,12 +3690,12 @@ defined.
 - Otherwise, if the destination type is a (possibly cv-qualified) class
   type:
   - If the initializer expression is a prvalue and the cv-unqualified
     version of the source type is the same class as the class of the
     destination, the initializer expression is used to initialize the
-    destination object. \[*Example 3*: `T x = T(T(T()));` calls the `T`
- default constructor to initialize `x`. — *end example*]
   - Otherwise, if the initialization is direct-initialization, or if it
     is copy-initialization where the cv-unqualified version of the
     source type is the same class as, or a derived class of, the class
     of the destination, constructors are considered. The applicable
     constructors are enumerated [[over.match.ctor]], and the best one is
@@ -3590,11 +3718,11 @@ defined.
       \[*Note 7*:
       By contrast with direct-list-initialization, narrowing conversions
       [[dcl.init.list]] are permitted, designators are not permitted, a
       temporary object bound to a reference does not have its lifetime
       extended [[class.temporary]], and there is no brace elision.
-      \[*Example 4*:
       ``` cpp
       struct A {
         int a;
         int&& r;
       };
@@ -3652,13 +3780,24 @@ defined.
   int c = b;
   ```
   — *end note*]
 An *initializer-clause* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
 If the initializer is a parenthesized *expression-list*, the expressions
 are evaluated in the order specified for function calls [[expr.call]].
 The same *identifier* shall not appear in multiple *designator*s of a
 *designated-initializer-list*.
@@ -3680,23 +3819,24 @@ A declaration that specifies the initialization of a variable, whether
 from an explicit initializer or by default-initialization, is called the
 *initializing declaration* of that variable.
 [*Note 10*: In most cases this is the defining declaration
 [[basic.def]] of the variable, but the initializing declaration of a
-non-inline static data member [[class.static.data]] might be the
-declaration within the class definition and not the definition at
-namespace scope. — *end note*]
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class [[class]] with
 - no user-declared or inherited constructors [[class.ctor]],
 - no private or protected direct non-static data members
   [[class.access]],
-- no virtual functions [[class.virtual]], and
-- no virtual, private, or protected base classes [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
 and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
@@ -3709,29 +3849,29 @@ The *elements* of an aggregate are:
 When an aggregate is initialized by an initializer list as specified in
 [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the elements of the aggregate. The *explicitly
 initialized elements* of the aggregate are determined as follows:
-- If the initializer list is a *designated-initializer-list*, the
-  aggregate shall be of class type, the *identifier* in each
-  *designator* shall name a direct non-static data member of the class,
-  and the explicitly initialized elements of the aggregate are the
-  elements that are, or contain, those members.
-- If the initializer list is an *initializer-list*, the explicitly
-  initialized elements of the aggregate are the first n elements of the
-  aggregate, where n is the number of elements in the initializer list.
 - Otherwise, the initializer list must be `{}`, and there are no
   explicitly initialized elements.
 For each explicitly initialized element:
-- If the element is an anonymous union object and the initializer list
-  is a *designated-initializer-list*, the anonymous union object is
-  initialized by the *designated-initializer-list* `{ `*D*` }`, where
-  *D* is the *designated-initializer-clause* naming a member of the
- anonymous union object. There shall be only one such
-  *designated-initializer-clause*.
   \[*Example 1*:
   ``` cpp
   struct C {
     union {
       int a;
@@ -3748,11 +3888,15 @@ For each explicitly initialized element:
   *brace-or-equal-initializer* of the corresponding
   *designated-initializer-clause*. If that initializer is of the form
   *assignment-expression* or `= `*assignment-expression* and a narrowing
   conversion [[dcl.init.list]] is required to convert the expression,
   the program is ill-formed.
-  \[*Note 2*: If an initializer is itself an initializer list, the
   element is list-initialized, which will result in a recursive
   application of the rules in this subclause if the element is an
   aggregate. — *end note*]
   \[*Example 2*:
   ``` cpp
@@ -3848,11 +3992,11 @@ expression not enclosed in braces, as described in  [[dcl.init]].
 The destructor for each element of class type is potentially invoked
 [[class.dtor]] from the context where the aggregate initialization
 occurs.
-[*Note 3*: This provision ensures that destructors can be called for
 fully-constructed subobjects in case an exception is thrown
 [[except.ctor]]. — *end note*]
 An array of unknown bound initialized with a brace-enclosed
 *initializer-list* containing `n` *initializer-clause*s is defined as
@@ -3870,11 +4014,11 @@ elements since no size was specified and there are three initializers.
 — *end example*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
-[*Note 4*:
 A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
 if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
@@ -3890,11 +4034,11 @@ struct S {
 — *end example*]
 — *end note*]
-[*Note 5*:
 Static data members, non-static data members of anonymous union members,
 and unnamed bit-fields are not considered elements of the aggregate.
 [*Example 6*:
@@ -3977,11 +4121,11 @@ struct A {
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
 — *end example*]
-When initializing a multi-dimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest [[dcl.array]].
 [*Example 10*:
@@ -4051,11 +4195,11 @@ the element with an *assignment-expression*. If the
 *assignment-expression* can initialize an element, the element is
 initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
 initialization of the first element of the subaggregate.
-[*Note 6*: As specified above, brace elision cannot apply to
 subaggregates with no elements; an *initializer-clause* for the entire
 subobject is required. — *end note*]
 [*Example 12*:
@@ -4076,16 +4220,16 @@ Braces are elided around the *initializer-clause* for `b.a1.i`. `b.a1.i`
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
-[*Note 7*: An aggregate array or an aggregate class may contain
 elements of a class type with a user-declared constructor
 [[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
-[*Note 8*: Whether the initialization of aggregates with static storage
 duration is static or dynamic is specified in  [[basic.start.static]],
 [[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
 When a union is initialized with an initializer list, there shall not be
 more than one explicitly initialized element.
@@ -4103,23 +4247,27 @@ u f = { .b = "asdf" };
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
-[*Note 9*: As described above, the braces around the
 *initializer-clause* for a union member can be omitted if the union is a
 member of another aggregate. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of ordinary character type [[basic.fundamental]], `char8_t`
-array, `char16_t` array, `char32_t` array, or `wchar_t` array can be
 initialized by an ordinary string literal, UTF-8 string literal, UTF-16
 string literal, UTF-32 string literal, or wide string literal,
 respectively, or by an appropriately-typed *string-literal* enclosed in
-braces [[lex.string]]. Successive characters of the value of the
-*string-literal* initialize the elements of the array.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
@@ -4147,12 +4295,12 @@ If there are fewer initializers than there are array elements, each
 element not explicitly initialized shall be zero-initialized
 [[dcl.init]].
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
-A variable whose declared type is “reference to type `T`” [[dcl.ref]]
-shall be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
@@ -4217,14 +4365,14 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
-  then the reference is bound to the initializer expression lvalue in
- the first case and to the lvalue result of the conversion in the
- second case (or, in either case, to the appropriate base class
- subobject of the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
@@ -4258,55 +4406,57 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
-  then the value of the initializer expression in the first case and the
- result of the conversion in the second case is called the converted
- initializer. If the converted initializer is a prvalue, its type `T4`
- is adjusted to type “*cv1* `T4`” [[conv.qual]] and the temporary
- materialization conversion [[conv.rval]] is applied. In any case, the
- reference is bound to the resulting glvalue (or to an appropriate base
-  class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
-  const A& rca2 = f();                // bound to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
-  const A& r = x;                     // bound to the A subobject of the result of the conversion
   int i2 = 42;
-  int&& rri = static_cast<int&&>(i2); // bound directly to i2
-  B&& rrb = x;                        // bound directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
-    user-defined conversion ([[dcl.init]], [[over.match.copy]],
-    [[over.match.conv]]); the program is ill-formed if the corresponding
- non-reference copy-initialization would be ill-formed. The result of
- the call to the conversion function, as described for the
-    non-reference copy-initialization, is then used to direct-initialize
-    the reference. For this direct-initialization, user-defined
-    conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
-    prvalue of type “*cv1* `T1`”. The temporary materialization
- conversion is applied and the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
-    shall not be an lvalue.
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
@@ -4337,11 +4487,11 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
-[*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
@@ -4363,12 +4513,12 @@ List-initialization can be used
 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
-- as an argument to a constructor invocation ([[dcl.init]],
-  [[expr.type.conv]])
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
@@ -4400,12 +4550,13 @@ initializer list as the argument to the constructor template
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
-The template `std::initializer_list` is not predefined; if the header
-`<initializer_list>` is not imported or included prior to a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
@@ -4444,22 +4595,22 @@ follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
-  S2 s23 { };                         // OK: default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
-  through overload resolution ([[over.match]], [[over.match.list]]). If
- a narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
@@ -4488,13 +4639,13 @@ follows:
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
-  S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
-  S s3 { };                           // OK: invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
@@ -4535,32 +4686,32 @@ follows:
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
-  prvalue initializes its result object by copy-list-initialization. The
-  prvalue is then used to direct-initialize the reference. The type of
-  the temporary is the type referenced by `T`, unless `T` is “reference
-  to array of unknown bound of `U`”, in which case the type of the
- temporary is the type of `x` in the declaration `U x[] H`, where H is
-  the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
-  const S& r1 = { 1, 2, 3.0 };        // OK: invoke #1
-  const S& r2 { "Spinach" };          // OK: invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
-  const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
@@ -4679,27 +4830,34 @@ variable, so the array persists for the lifetime of the variable. For
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
-read-only memory if an explicit array with the same initializer could be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
-- from `long double` to `double` or `float`, or from `double` to
- `float`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
@@ -4708,25 +4866,25 @@ top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
-char c1 = x;                    // OK, though it might narrow (in this case, it does narrow)
-char c2{x};                     // error: might narrow
 char c3{y};                     // error: narrows (assuming char is 8 bits)
-char c4{z};                     // OK: no narrowing needed
-unsigned char uc1 = {5};        // OK: no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
-float f1 { x };                 // error: might narrow
-float f2 { 7 };                 // OK: 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
-int a[] = { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 ```
 — *end example*]
 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
@@ -4781,11 +4939,11 @@ Here `int` is the *decl-specifier-seq*; `max(int` `a,` `int` `b,` `int`
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
 [*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
-of a member function; see  [[dcl.ref]]. — *end note*]
 [*Note 2*:
 Unused parameters need not be named. For example,
@@ -4795,13 +4953,12 @@ void print(int a, int) {
 }
 ```
 — *end note*]
-In the *function-body*, a *function-local predefined variable* denotes a
-block-scope object of static storage duration that is implicitly defined
-(see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
@@ -4832,47 +4989,50 @@ explicitly defaulted shall
 - be a special member function or a comparison operator function
   [[over.binary]], and
 - not have default arguments.
-The type `T`₁ of an explicitly defaulted special member function `F` is
-allowed to differ from the type `T`₂ it would have had if it were
-implicitly declared, as follows:
-- `T`₁ and `T`₂ may have differing *ref-qualifier*s;
-- `T`₁ and `T`₂ may have differing exception specifications; and
-- if `T`₂ has a parameter of type `const C&`, the corresponding
-  parameter of `T`₁ may be of type `C&`.
-If `T`₁ differs from `T`₂ in any other way, then:
-- if `F` is an assignment operator, and the return type of `T`₁ differs
-  from the return type of `T`₂ or `T`₁’s parameter type is not a
-  reference, the program is ill-formed;
-- otherwise, if `F` is explicitly defaulted on its first declaration, it
-  is defined as deleted;
 - otherwise, the program is ill-formed.
-An explicitly-defaulted function that is not defined as deleted may be
-declared `constexpr` or `consteval` only if it is constexpr-compatible (
-[[special]], [[class.compare.default]]). A function explicitly defaulted
-on its first declaration is implicitly inline [[dcl.inline]], and is
-implicitly constexpr [[dcl.constexpr]] if it is constexpr-compatible.
 [*Example 1*:
 ``` cpp
 struct S {
-  constexpr S() = default;              // error: implicit S() is not constexpr
   S(int a = 0) = default;               // error: default argument
   void operator=(const S&) = default;   // error: non-matching return type
   ~S() noexcept(false) = default;       // OK, despite mismatched exception specification
 private:
   int i;
-  S(S&);                                // OK: private copy constructor
 };
-S::S(S&) = default;                     // OK: defines copy constructor
 struct T {
   T();
   T(T &&) noexcept(false);
 };
@@ -4887,21 +5047,26 @@ U u2 = static_cast<U&&>(u1);            // OK, calls std::terminate if T::T(T&&)
 — *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
-provide implicit definitions for them ([[class.ctor]], [[class.dtor]],
-[[class.copy.ctor]], [[class.copy.assign]]), which might mean defining
-them as deleted. A defaulted prospective destructor [[class.dtor]] that
-is not a destructor is defined as deleted. A defaulted special member
-function that is neither a prospective destructor nor an eligible
-special member function [[special]] is defined as deleted. A function is
-*user-provided* if it is user-declared and not explicitly defaulted or
-deleted on its first declaration. A user-provided explicitly-defaulted
-function (i.e., explicitly defaulted after its first declaration) is
-defined at the point where it is explicitly defaulted; if such a
-function is implicitly defined as deleted, the program is ill-formed.
 [*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
 enabling a stable binary interface to an evolving code
 base. — *end note*]
@@ -4926,24 +5091,25 @@ nontrivial1::nontrivial1() = default;   // not first declaration
 — *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
-A function definition whose *function-body* is of the form `= delete ;`
-is called a *deleted definition*. A function with a deleted definition
-is also called a *deleted function*.
 A program that refers to a deleted function implicitly or explicitly,
 other than to declare it, is ill-formed.
 [*Note 1*: This includes calling the function implicitly or explicitly
 and forming a pointer or pointer-to-member to the function. It applies
 even for references in expressions that are not potentially-evaluated.
-If a function is overloaded, it is referenced only if the function is
-selected by overload resolution. The implicit odr-use [[basic.def.odr]]
-of a virtual function does not, by itself, constitute a
-reference. — *end note*]
 [*Example 1*:
 One can prevent default initialization and initialization by
 non-`double`s with
@@ -5052,19 +5218,21 @@ task<void> g3(int a, ...) {     // error: variable parameter list not allowed
 — *end example*]
 The *promise type* of a coroutine is
 `std::coroutine_traits<R, P₁, …, Pₙ>::promise_type`, where `R` is the
-return type of the function, and `P₁` … `Pₙ` are the sequence of types
-of the function parameters, preceded by the type of the implicit object
-parameter [[over.match.funcs]] if the coroutine is a non-static member
-function. The promise type shall be a class type.
-In the following, `pᵢ` is an lvalue of type `Pᵢ`, where `p₁` denotes
-`*this` and `p_i+1` denotes the $i^\textrm{th}$ function parameter for a
-non-static member function, and `pᵢ` denotes the $i^\textrm{th}$
-function parameter otherwise.
 A coroutine behaves as if its *function-body* were replaced by:
 ``` bnf
 '{'
@@ -5085,75 +5253,81 @@ final-suspend ':'
 ```
 where
 - the *await-expression* containing the call to `initial_suspend` is the
-  *initial suspend point*, and
 - the *await-expression* containing the call to `final_suspend` is the
-  *final suspend point*, and
 - *initial-await-resume-called* is initially `false` and is set to
   `true` immediately before the evaluation of the *await-resume*
-  expression [[expr.await]] of the initial suspend point, and
 - *promise-type* denotes the promise type, and
 - the object denoted by the exposition-only name *`promise`* is the
   *promise object* of the coroutine, and
 - the label denoted by the name *`final-suspend`* is defined for
   exposition only [[stmt.return.coroutine]], and
 - *promise-constructor-arguments* is determined as follows: overload
   resolution is performed on a promise constructor call created by
-  assembling an argument list with lvalues `p₁` … `pₙ`. If a viable
- constructor is found [[over.match.viable]], then
- *promise-constructor-arguments* is `(p₁, …, pₙ)`, otherwise
-  *promise-constructor-arguments* is empty.
-The *unqualified-id*s `return_void` and `return_value` are looked up in
-the scope of the promise type. If both are found, the program is
 ill-formed.
-[*Note 1*: If the *unqualified-id* `return_void` is found, flowing off
-the end of a coroutine is equivalent to a `co_return` with no operand.
-Otherwise, flowing off the end of a coroutine results in undefined
-behavior [[stmt.return.coroutine]]. — *end note*]
 The expression `promise.get_return_object()` is used to initialize the
-glvalue result or prvalue result object of a call to a coroutine. The
-call to `get_return_object` is sequenced before the call to
 `initial_suspend` and is invoked at most once.
 A suspended coroutine can be resumed to continue execution by invoking a
 resumption member function [[coroutine.handle.resumption]] of a
 coroutine handle [[coroutine.handle]] that refers to the coroutine. The
-function that invoked a resumption member function is called the
 *resumer*. Invoking a resumption member function for a coroutine that is
 not suspended results in undefined behavior.
 An implementation may need to allocate additional storage for a
 coroutine. This storage is known as the *coroutine state* and is
 obtained by calling a non-array allocation function
 [[basic.stc.dynamic.allocation]]. The allocation function’s name is
-looked up in the scope of the promise type. If this lookup fails, the
-allocation function’s name is looked up in the global scope. If the
-lookup finds an allocation function in the scope of the promise type,
-overload resolution is performed on a function call created by
-assembling an argument list. The first argument is the amount of space
-requested, and has type `std::size_t`. The lvalues `p₁` … `pₙ` are the
-succeeding arguments. If no viable function is found
-[[over.match.viable]], overload resolution is performed again on a
-function call created by passing just the amount of space required as an
-argument of type `std::size_t`.
-The *unqualified-id* `get_return_object_on_allocation_failure` is looked
-up in the scope of the promise type by class member access lookup
-[[basic.lookup.classref]]. If any declarations are found, then the
-result of a call to an allocation function used to obtain storage for
-the coroutine state is assumed to return `nullptr` if it fails to obtain
-storage, and if a global allocation function is selected, the
-`::operator new(size_t, nothrow_t)` form is used. The allocation
-function used in this case shall have a non-throwing
-*noexcept-specification*. If the allocation function returns `nullptr`,
-the coroutine returns control to the caller of the coroutine and the
-return value is obtained by a call to
 `T::get_return_object_on_allocation_failure()`, where `T` is the promise
 type.
 [*Example 2*:
@@ -5168,11 +5342,11 @@ struct generator {
   struct promise_type {
     int current_value;
     static auto get_return_object_on_allocation_failure() { return generator{nullptr}; }
     auto get_return_object() { return generator{handle::from_promise(*this)}; }
     auto initial_suspend() { return std::suspend_always{}; }
-    auto final_suspend() { return std::suspend_always{}; }
     void unhandled_exception() { std::terminate(); }
     void return_void() {}
     auto yield_value(int value) {
       current_value = value;
       return std::suspend_always{};
@@ -5198,30 +5372,28 @@ int main() {
 The coroutine state is destroyed when control flows off the end of the
 coroutine or the `destroy` member function
 [[coroutine.handle.resumption]] of a coroutine handle
 [[coroutine.handle]] that refers to the coroutine is invoked. In the
-latter case objects with automatic storage duration that are in scope at
-the suspend point are destroyed in the reverse order of the
-construction. The storage for the coroutine state is released by calling
-a non-array deallocation function [[basic.stc.dynamic.deallocation]]. If
-`destroy` is called for a coroutine that is not suspended, the program
-has undefined behavior.
-The deallocation function’s name is looked up in the scope of the
-promise type. If this lookup fails, the deallocation function’s name is
-looked up in the global scope. If deallocation function lookup finds
-both a usual deallocation function with only a pointer parameter and a
-usual deallocation function with both a pointer parameter and a size
-parameter, then the selected deallocation function shall be the one with
-two parameters. Otherwise, the selected deallocation function shall be
-the function with one parameter. If no usual deallocation function is
-found, the program is ill-formed. The selected deallocation function
-shall be called with the address of the block of storage to be reclaimed
-as its first argument. If a deallocation function with a parameter of
-type `std::size_t` is used, the size of the block is passed as the
-corresponding argument.
 When a coroutine is invoked, after initializing its parameters
 [[expr.call]], a copy is created for each coroutine parameter. For a
 parameter of type cv `T`, the copy is a variable of type cv `T` with
 automatic storage duration that is direct-initialized from an xvalue of
@@ -5242,26 +5414,27 @@ the coroutine after the lifetime of the entity referred to by that
 parameter has ended is likely to result in undefined
 behavior. — *end note*]
 If the evaluation of the expression `promise.unhandled_exception()`
 exits via an exception, the coroutine is considered suspended at the
-final suspend point.
 The expression `co_await` `promise.final_suspend()` shall not be
 potentially-throwing [[except.spec]].
 ## Structured binding declarations <a id="dcl.struct.bind">[[dcl.struct.bind]]</a>
 A structured binding declaration introduces the *identifier*s `v₀`,
-`v₁`, `v₂`, … of the *identifier-list* as names
-[[basic.scope.declarative]] of *structured binding*s. Let cv denote the
-*cv-qualifier*s in the *decl-specifier-seq* and *S* consist of the
-*storage-class-specifier*s of the *decl-specifier-seq* (if any). A cv
-that includes `volatile` is deprecated; see  [[depr.volatile.type]].
-First, a variable with a unique name *`e`* is introduced. If the
-*assignment-expression* in the *initializer* has array type `A` and no
-*ref-qualifier* is present, *`e`* is defined by
 ``` bnf
 attribute-specifier-seqₒₚₜ *S* cv 'A' e ';'
 ```
@@ -5283,11 +5456,11 @@ from the corresponding structured binding declaration. The type of the
 If the *initializer* refers to one of the names introduced by the
 structured binding declaration, the program is ill-formed.
 If `E` is an array type with element type `T`, the number of elements in
 the *identifier-list* shall be equal to the number of elements of `E`.
-Each `v`ᵢ is the name of an lvalue that refers to the element i of the
 array and whose type is `T`; the referenced type is `T`.
 [*Note 2*: The top-level cv-qualifiers of `T` are cv. — *end note*]
 [*Example 1*:
@@ -5303,18 +5476,17 @@ auto& [ xr, yr ] = f();         // xr and yr refer to elements in the array refe
 Otherwise, if the *qualified-id* `std::tuple_size<E>` names a complete
 class type with a member named `value`, the expression
 `std::tuple_size<E>::value` shall be a well-formed integral constant
 expression and the number of elements in the *identifier-list* shall be
 equal to the value of that expression. Let `i` be an index prvalue of
-type `std::size_t` corresponding to `v`_`i`. The *unqualified-id* `get`
-is looked up in the scope of `E` by class member access lookup
-[[basic.lookup.classref]], and if that finds at least one declaration
-that is a function template whose first template parameter is a non-type
-parameter, the initializer is `e.get<i>()`. Otherwise, the initializer
-is `get<i>(e)`, where `get` is looked up in the associated namespaces
-[[basic.lookup.argdep]]. In either case, `get<i>` is interpreted as a
-*template-id*.
 [*Note 3*: Ordinary unqualified lookup [[basic.lookup.unqual]] is not
 performed. — *end note*]
 In either case, *`e`* is an lvalue if the type of the entity *`e`* is an
@@ -5335,24 +5507,25 @@ Otherwise, all of `E`’s non-static data members shall be direct members
 of `E` or of the same base class of `E`, well-formed when named as
 `e.name` in the context of the structured binding, `E` shall not have an
 anonymous union member, and the number of elements in the
 *identifier-list* shall be equal to the number of non-static data
 members of `E`. Designating the non-static data members of `E` as `m₀`,
-`m₁`, `m₂`, … (in declaration order), each `v`ᵢ is the name of an lvalue
-that refers to the member `m`ᵢ of *`e`* and whose type is cv `Tᵢ`, where
-`Tᵢ` is the declared type of that member; the referenced type is
-cv `Tᵢ`. The lvalue is a bit-field if that member is a bit-field.
 [*Example 2*:
 ``` cpp
-struct S { int x1 : 2; volatile double y1; };
 S f();
 const auto [ x, y ] = f();
 ```
-The type of the *id-expression* `x` is “`const int`”, the type of the
 *id-expression* `y` is “`const volatile double`”.
 — *end example*]
 ## Enumerations <a id="enum">[[enum]]</a>
@@ -5442,11 +5615,13 @@ struct S {
 — *end example*]
 — *end note*]
-If the *enum-head-name* of an *opaque-enum-declaration* contains a
 *nested-name-specifier*, the declaration shall be an explicit
 specialization [[temp.expl.spec]].
 The enumeration type declared with an *enum-key* of only `enum` is an
 *unscoped enumeration*, and its *enumerator*s are *unscoped
@@ -5457,16 +5632,18 @@ enumerators*. The optional *enum-head-name* shall not be omitted in the
 declaration of a scoped enumeration. The *type-specifier-seq* of an
 *enum-base* shall name an integral type; any cv-qualification is
 ignored. An *opaque-enum-declaration* declaring an unscoped enumeration
 shall not omit the *enum-base*. The identifiers in an *enumerator-list*
 are declared as constants, and can appear wherever constants are
-required. An *enumerator-definition* with `=` gives the associated
-*enumerator* the value indicated by the *constant-expression*. If the
-first *enumerator* has no *initializer*, the value of the corresponding
-constant is zero. An *enumerator-definition* without an *initializer*
-gives the *enumerator* the value obtained by increasing the value of the
-previous *enumerator* by one.
 [*Example 2*:
 ``` cpp
 enum { a, b, c=0 };
@@ -5492,19 +5669,17 @@ can be provided in a later redeclaration with an
 A scoped enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
-If an *enum-head-name* contains a *nested-name-specifier*, it shall not
-begin with a *decltype-specifier* and the enclosing *enum-specifier* or
-*opaque-enum-declaration* shall refer to an enumeration that was
-previously declared directly in the class or namespace to which the
-*nested-name-specifier* refers, or in an element of the inline namespace
-set [[namespace.def]] of that namespace (i.e., neither inherited nor
-introduced by a *using-declaration*), and the *enum-specifier* or
-*opaque-enum-declaration* shall appear in a namespace enclosing the
-previous declaration.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an *underlying type*. The underlying type can
 be explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
@@ -5528,16 +5703,15 @@ the closing brace is determined as follows:
   preceding enumerator unless the incremented value is not representable
   in that type, in which case the type is an unspecified integral type
   sufficient to contain the incremented value. If no such type exists,
   the program is ill-formed.
-An enumeration whose underlying type is fixed is an incomplete type from
-its point of declaration [[basic.scope.pdecl]] to immediately after its
-*enum-base* (if any), at which point it becomes a complete type. An
-enumeration whose underlying type is not fixed is an incomplete type
-from its point of declaration to immediately after the closing `}` of
-its *enum-specifier*, at which point it becomes a complete type.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
@@ -5555,10 +5729,15 @@ represented. The width of the smallest bit-field large enough to hold
 all the values of the enumeration type is M. It is possible to define an
 enumeration that has values not defined by any of its enumerators. If
 the *enumerator-list* is empty, the values of the enumeration are as if
 the enumeration had a single enumerator with value 0.[^9]
 Two enumeration types are *layout-compatible enumerations* if they have
 the same underlying type.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion [[conv.prom]].
@@ -5579,11 +5758,11 @@ type. The possible values of an object of type `color` are `red`,
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
 color c = 1;                    // error: type mismatch, no conversion from int to color
-int i = yellow;                 // OK: yellow converted to integral value 1, integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
@@ -5594,19 +5773,17 @@ Col y = Col::red;
 if (y) { }                      // error: no Col to bool conversion
 ```
 — *end example*]
-Each *enum-name* and each unscoped *enumerator* is declared in the scope
-that immediately contains the *enum-specifier*. Each scoped *enumerator*
-is declared in the scope of the enumeration. An unnamed enumeration that
 does not have a typedef name for linkage purposes [[dcl.typedef]] and
 that has a first enumerator is denoted, for linkage purposes
 [[basic.link]], by its underlying type and its first enumerator; such an
 enumeration is said to have an enumerator as a name for linkage
-purposes. These names obey the scope rules defined for all names in
-[[basic.scope]] and  [[basic.lookup]].
 [*Note 3*: Each unnamed enumeration with no enumerators is a distinct
 type. — *end note*]
 [*Example 4*:
@@ -5629,52 +5806,35 @@ void h()  {
 }
 ```
 — *end example*]
-An enumerator declared in class scope can be referred to using the class
-member access operators (`::`, `.` (dot) and `->` (arrow)), see
-[[expr.ref]].
-[*Example 5*:
-``` cpp
-struct X {
-  enum direction { left='l', right='r' };
-  int f(int i) { return i==left ? 0 : i==right ? 1 : 2; }
-};
-void g(X* p) {
-  direction d;                  // error: direction not in scope
-  int i;
-  i = p->f(left);               // error: left not in scope
-  i = p->f(X::right);           // OK
-  i = p->f(p->left);            // OK
-  // ...
-}
-```
-— *end example*]
 ### The `using enum` declaration <a id="enum.udecl">[[enum.udecl]]</a>
 ``` bnf
 using-enum-declaration:
- 'using' elaborated-enum-specifier ';'
 ```
-The *elaborated-enum-specifier* shall not name a dependent type and the
-type shall have a reachable *enum-specifier*.
-A *using-enum-declaration* introduces the enumerator names of the named
-enumeration as if by a *using-declaration* for each enumerator.
 [*Note 1*:
-A *using-enum-declaration* in class scope adds the enumerators of the
-named enumeration as members to the scope. This means they are
-accessible for member lookup.
 [*Example 1*:
 ``` cpp
 enum class fruit { orange, apple };
@@ -5712,21 +5872,23 @@ void f() {
 — *end note*]
 ## Namespaces <a id="basic.namespace">[[basic.namespace]]</a>
-A namespace is an optionally-named declarative region. The name of a
-namespace can be used to access entities declared in that namespace;
-that is, the members of the namespace. Unlike other declarative regions,
-the definition of a namespace can be split over several parts of one or
-more translation units.
-[*Note 1*: A namespace name with external linkage is exported if any of
-its *namespace-definition*s is exported, or if it contains any
 *export-declaration*s [[module.interface]]. A namespace is never
-attached to a module, and never has module linkage even if it is not
-exported. — *end note*]
 [*Example 1*:
 ``` cpp
 export module M;
@@ -5735,15 +5897,21 @@ export namespace N2 {}          // N2 is exported
 namespace N3 { export int n; }  // N3 is exported
 ```
 — *end example*]
-The outermost declarative region of a translation unit is a namespace;
-see  [[basic.scope.namespace]].
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
 ``` bnf
 namespace-name:
         identifier
         namespace-alias
 ```
@@ -5779,22 +5947,20 @@ enclosing-namespace-specifier:
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
-Every *namespace-definition* shall appear at namespace scope
 [[basic.scope.namespace]].
-In a *named-namespace-definition*, the *identifier* is the name of the
-namespace. If the *identifier*, when looked up [[basic.lookup.unqual]],
-refers to a *namespace-name* (but not a *namespace-alias*) that was
-introduced in the namespace in which the *named-namespace-definition*
-appears or that was introduced in a member of the inline namespace set
-of that namespace, the *namespace-definition* *extends* the
-previously-declared namespace. Otherwise, the *identifier* is introduced
-as a *namespace-name* into the declarative region in which the
-*named-namespace-definition* appears.
 Because a *namespace-definition* contains *declaration*s in its
 *namespace-body* and a *namespace-definition* is itself a *declaration*,
 it follows that *namespace-definition*s can be nested.
@@ -5811,34 +5977,10 @@ namespace Outer {
 }
 ```
 — *end example*]
-The *enclosing namespaces* of a declaration are those namespaces in
-which the declaration lexically appears, except for a redeclaration of a
-namespace member outside its original namespace (e.g., a definition as
-specified in  [[namespace.memdef]]). Such a redeclaration has the same
-enclosing namespaces as the original declaration.
-[*Example 2*:
-``` cpp
-namespace Q {
-  namespace V {
-    void f();                   // enclosing namespaces are the global namespace, Q, and Q::V
-    class C { void m(); };
-  }
-  void V::f() {                 // enclosing namespaces are the global namespace, Q, and Q::V
-    extern void h();            // ... so this declares Q::V::h
-  }
-  void V::C::m() {              // enclosing namespaces are the global namespace, Q, and Q::V
-  }
-}
-```
-— *end example*]
 If the optional initial `inline` keyword appears in a
 *namespace-definition* for a particular namespace, that namespace is
 declared to be an *inline namespace*. The `inline` keyword may be used
 on a *namespace-definition* that extends a namespace only if it was
 previously used on the *namespace-definition* that initially declared
@@ -5846,33 +5988,30 @@ the *namespace-name* for that namespace.
 The optional *attribute-specifier-seq* in a *named-namespace-definition*
 appertains to the namespace being defined or extended.
 Members of an inline namespace can be used in most respects as though
-they were members of the enclosing namespace. Specifically, the inline
-namespace and its enclosing namespace are both added to the set of
-associated namespaces used in argument-dependent lookup
 [[basic.lookup.argdep]] whenever one of them is, and a *using-directive*
 [[namespace.udir]] that names the inline namespace is implicitly
 inserted into the enclosing namespace as for an unnamed namespace
 [[namespace.unnamed]]. Furthermore, each member of the inline namespace
-can subsequently be partially specialized [[temp.class.spec]],
 explicitly instantiated [[temp.explicit]], or explicitly specialized
 [[temp.expl.spec]] as though it were a member of the enclosing
 namespace. Finally, looking up a name in the enclosing namespace via
 explicit qualification [[namespace.qual]] will include members of the
-inline namespace brought in by the *using-directive* even if there are
-declarations of that name in the enclosing namespace.
 These properties are transitive: if a namespace `N` contains an inline
 namespace `M`, which in turn contains an inline namespace `O`, then the
 members of `O` can be used as though they were members of `M` or `N`.
 The *inline namespace set* of `N` is the transitive closure of all
-inline namespaces in `N`. The *enclosing namespace set* of `O` is the
-set of namespaces consisting of the innermost non-inline namespace
-enclosing an inline namespace `O`, together with any intervening inline
-namespaces.
 A *nested-namespace-definition* with an *enclosing-namespace-specifier*
 `E`, *identifier* `I` and *namespace-body* `B` is equivalent to
 ``` cpp
@@ -5880,11 +6019,11 @@ namespace E { \opt{inline} namespace I { B } }
 ```
 where the optional `inline` is present if and only if the *identifier*
 `I` is preceded by `inline`.
-[*Example 3*:
 ``` cpp
 namespace A::inline B::C {
   int i;
 }
@@ -5943,128 +6082,10 @@ void h() {
 }
 ```
 — *end example*]
-#### Namespace member definitions <a id="namespace.memdef">[[namespace.memdef]]</a>
-A declaration in a namespace `N` (excluding declarations in nested
-scopes) whose *declarator-id* is an *unqualified-id* [[dcl.meaning]],
-whose *class-head-name* [[class.pre]] or *enum-head-name* [[dcl.enum]]
-is an *identifier*, or whose *elaborated-type-specifier* is of the form
-*class-key* *attribute-specifier-seq*ₒₚₜ  *identifier*
-[[dcl.type.elab]], or that is an *opaque-enum-declaration*, declares (or
-redeclares) its *unqualified-id* or *identifier* as a member of `N`.
-[*Note 1*: An explicit instantiation [[temp.explicit]] or explicit
-specialization [[temp.expl.spec]] of a template does not introduce a
-name and thus may be declared using an *unqualified-id* in a member of
-the enclosing namespace set, if the primary template is declared in an
-inline namespace. — *end note*]
-[*Example 1*:
-``` cpp
-namespace X {
-  void f() { ... }        // OK: introduces X::f()
-  namespace M {
-    void g();                   // OK: introduces X::M::g()
-  }
-  using M::g;
-  void g();                     // error: conflicts with X::M::g()
-}
-```
-— *end example*]
-Members of a named namespace can also be defined outside that namespace
-by explicit qualification [[namespace.qual]] of the name being defined,
-provided that the entity being defined was already declared in the
-namespace and the definition appears after the point of declaration in a
-namespace that encloses the declaration’s namespace.
-[*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 a friend declaration in a non-local class first declares a class,
-function, class template or function template[^10] the friend is a
-member of the innermost enclosing namespace. The friend declaration does
-not by itself make the name visible to unqualified lookup
-[[basic.lookup.unqual]] or qualified lookup [[basic.lookup.qual]].
-[*Note 2*: The name of the friend will be visible in its namespace if a
-matching declaration is provided at namespace scope (either before or
-after the class definition granting friendship). — *end note*]
-If a friend function or function template is called, its name may be
-found by the name lookup that considers functions from namespaces and
-classes associated with the types of the function arguments
-[[basic.lookup.argdep]]. If the name in a friend declaration is neither
-qualified nor a *template-id* and the declaration is a function or an
-*elaborated-type-specifier*, the lookup to determine whether the entity
-has been previously declared shall not consider any scopes outside the
-innermost enclosing namespace.
-[*Note 3*: The other forms of friend declarations cannot declare a new
-member of the innermost enclosing namespace and thus follow the usual
-lookup rules. — *end note*]
-[*Example 3*:
-``` cpp
-// Assume f and g have not yet been declared.
-void h(int);
-template <class T> void f2(T);
-namespace A {
-  class X {
-    friend void f(X);           // A::f(X) is a friend
-    class Y {
-      friend void g();          // A::g is a friend
-      friend void h(int);       // A::h is a friend
-                                // ::h not considered
-      friend void f2<>(int);    // ::f2<>(int) is a friend
-    };
-  };
-  // A::f, A::g and A::h are not visible here
-  X x;
-  void g() { f(x); }            // definition of A::g
-  void f(X) { ... }       // definition of A::f
-  void h(int) { ... }     // definition of A::h
-  // A::f, A::g and A::h are visible here and known to be friends
-}
-using A::x;
-void h() {
-  A::f(x);
-  A::X::f(x);                   // error: f is not a member of A::X
-  A::X::Y::g();                 // error: g is not a member of A::X::Y
-}
-```
-— *end example*]
 ### Namespace alias <a id="namespace.alias">[[namespace.alias]]</a>
 A *namespace-alias-definition* declares an alternate name for a
 namespace according to the following grammar:
@@ -6081,35 +6102,18 @@ namespace-alias-definition:
 ``` bnf
 qualified-namespace-specifier:
     nested-name-specifierₒₚₜ namespace-name
 ```
-The *identifier* in a *namespace-alias-definition* is a synonym for the
-name of the namespace denoted by the *qualified-namespace-specifier* and
-becomes a *namespace-alias*.
 [*Note 1*: When looking up a *namespace-name* in a
 *namespace-alias-definition*, only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
-In a declarative region, a *namespace-alias-definition* can be used to
-redefine a *namespace-alias* declared in that declarative region to
-refer only to the namespace to which it already refers.
-[*Example 1*:
-The following declarations are well-formed:
-``` cpp
-namespace Company_with_very_long_name { ... }
-namespace CWVLN = Company_with_very_long_name;
-namespace CWVLN = Company_with_very_long_name;  // OK: duplicate
-namespace CWVLN = CWVLN;
-```
-— *end example*]
 ### Using namespace directive <a id="namespace.udir">[[namespace.udir]]</a>
 ``` bnf
 using-directive:
     attribute-specifier-seqₒₚₜ using namespace nested-name-specifierₒₚₜ namespace-name ';'
@@ -6123,22 +6127,19 @@ only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
 The optional *attribute-specifier-seq* appertains to the
 *using-directive*.
-A *using-directive* specifies that the names in the nominated namespace
-can be used in the scope in which the *using-directive* appears after
-the *using-directive*. During unqualified name lookup
-[[basic.lookup.unqual]], the names appear as if they were declared in
-the nearest enclosing namespace which contains both the
-*using-directive* and the nominated namespace.
-[*Note 2*: In this context, “contains” means “contains directly or
-indirectly”. — *end note*]
-A *using-directive* does not add any members to the declarative region
-in which it appears.
 [*Example 1*:
 ``` cpp
 namespace A {
@@ -6168,18 +6169,14 @@ void f4() {
 }
 ```
 — *end example*]
-For unqualified lookup [[basic.lookup.unqual]], the *using-directive* is
-transitive: if a scope contains a *using-directive* that nominates a
-second namespace that itself contains *using-directive*s, the effect is
-as if the *using-directive*s from the second namespace also appeared in
-the first.
-[*Note 3*: For qualified lookup, see
-[[namespace.qual]]. — *end note*]
 [*Example 2*:
 ``` cpp
 namespace M {
@@ -6222,17 +6219,15 @@ namespace B {
 }
 ```
 — *end example*]
-If a namespace is extended [[namespace.def]] after a *using-directive*
-for that namespace is given, the additional members of the extended
-namespace and the members of namespaces nominated by *using-directive*s
-in the extending *namespace-definition* can be used after the extending
-*namespace-definition*.
-[*Note 4*:
 If name lookup finds a declaration for a name in two different
 namespaces, and the declarations do not declare the same entity and do
 not declare functions or function templates, the use of the name is
 ill-formed [[basic.lookup]]. In particular, the name of a variable,
@@ -6253,40 +6248,37 @@ namespace B {
 using namespace A;
 using namespace B;
 void f() {
   X(1);             // error: name X found in two namespaces
-  g();              // OK: name g refers to the same entity
-  h();              // OK: overload resolution selects A::h
 }
 ```
 — *end note*]
-During overload resolution, all functions from the transitive search are
-considered for argument matching. The set of declarations found by the
-transitive search is unordered.
-[*Note 5*: In particular, the order in which namespaces were considered
-and the relationships among the namespaces implied by the
-*using-directive*s do not cause preference to be given to any of the
-declarations found by the search. — *end note*]
-An ambiguity exists if the best match finds two functions with the same
-signature, even if one is in a namespace reachable through
-*using-directive*s in the namespace of the other.[^11]
 [*Example 3*:
 ``` cpp
 namespace D {
   int d1;
   void f(char);
 }
 using namespace D;
-int d1;             // OK: no conflict with D::d1
 namespace E {
   int e;
   void f(int);
 }
@@ -6299,14 +6291,14 @@ namespace D {       // namespace extension
 void f() {
   d1++;             // error: ambiguous ::d1 or D::d1?
   ::d1++;           // OK
   D::d1++;          // OK
-  d2++;             // OK: D::d2
-  e++;              // OK: E::e
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
-  f('a');           // OK: D::f(char)
 }
 ```
 — *end example*]
@@ -6326,57 +6318,43 @@ using-declarator-list:
 ``` bnf
 using-declarator:
     typenameₒₚₜ nested-name-specifier unqualified-id
 ```
-Each *using-declarator* in a *using-declaration* [^12] introduces a set
-of declarations into the declarative region in which the
-*using-declaration* appears. The set of declarations introduced by the
-*using-declarator* is found by performing qualified name lookup (
-[[basic.lookup.qual]], [[class.member.lookup]]) for the name in the
-*using-declarator*, excluding functions that are hidden as described
-below. If the *using-declarator* does not name a constructor, the
-*unqualified-id* is declared in the declarative region in which the
-*using-declaration* appears as a synonym for each declaration introduced
-by the *using-declarator*.
-[*Note 1*: Only the specified name is so declared; specifying an
-enumeration name in a *using-declaration* does not declare its
-enumerators in the *using-declaration*'s declarative
-region. — *end note*]
 If the *using-declarator* names a constructor, it declares that the
-class *inherits* the set of constructor declarations introduced by the
-*using-declarator* from the nominated base class.
-Every *using-declaration* is a *declaration* and a *member-declaration*
-and can therefore be used in a class definition.
-[*Example 1*:
-``` cpp
-struct B {
-  void f(char);
-  void g(char);
-  enum E { e };
-  union { int x; };
-};
-struct D : B {
-  using B::f;
-  void f(int) { f('c'); }       // calls B::f(char)
-  void g(int) { g('c'); }       // recursively calls D::g(int)
-};
-```
-— *end example*]
 In a *using-declaration* used as a *member-declaration*, each
 *using-declarator* shall either name an enumerator or have a
-*nested-name-specifier* naming a base class of the class being defined.
-[*Example 2*:
 ``` cpp
 enum class button { up, down };
 struct S {
   using button::up;
@@ -6385,60 +6363,59 @@ struct S {
 ```
 — *end example*]
 If a *using-declarator* names a constructor, its *nested-name-specifier*
-shall name a direct base class of the class being defined.
-[*Example 3*:
 ``` cpp
 template <typename... bases>
 struct X : bases... {
-  using bases::g...;
-};
-X<B, D> x;                      // OK: B::g and D::g introduced
-```
-— *end example*]
-[*Example 4*:
-``` cpp
-class C {
-  int g();
-};
-class D2 : public B {
-  using B::f;                   // OK: B is a base of D2
-  using B::e;                   // OK: e is an enumerator of base B
-  using B::x;                   // OK: x is a union member of base B
-  using C::g;                   // error: C isn't a base of D2
 };
 ```
 — *end example*]
 [*Note 2*: Since destructors do not have names, a *using-declaration*
-cannot refer to a destructor for a base class. Since specializations of
-member templates for conversion functions are not found by name lookup,
-they are not considered when a *using-declaration* specifies a
-conversion function [[temp.mem]]. — *end note*]
 If a constructor or assignment operator brought from a base class into a
 derived class has the signature of a copy/move constructor or assignment
-operator for the derived class ([[class.copy.ctor]],
-[[class.copy.assign]]), the *using-declaration* does not by itself
-suppress the implicit declaration of the derived class member; the
-member from the base class is hidden or overridden by the
 implicitly-declared copy/move constructor or assignment operator of the
 derived class, as described below.
 A *using-declaration* shall not name a *template-id*.
-[*Example 5*:
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
@@ -6454,11 +6431,11 @@ struct B : A {
 A *using-declaration* shall not name a namespace.
 A *using-declaration* that names a class member other than an enumerator
 shall be a *member-declaration*.
-[*Example 6*:
 ``` cpp
 struct X {
   int i;
   static int s;
@@ -6470,71 +6447,21 @@ void f() {
 }
 ```
 — *end example*]
-Members declared by a *using-declaration* can be referred to by explicit
-qualification just like other member names [[namespace.qual]].
-[*Example 7*:
-``` cpp
-void f();
-namespace A {
-  void g();
-}
-namespace X {
-  using ::f;                    // global f
-  using A::g;                   // A's g
-}
-void h()
-{
-  X::f();                       // calls ::f
-  X::g();                       // calls A::g
-}
-```
-— *end example*]
-A *using-declaration* is a *declaration* and can therefore be used
-repeatedly where (and only where) multiple declarations are allowed.
-[*Example 8*:
-``` cpp
-namespace A {
-  int i;
-}
-namespace A1 {
-  using A::i, A::i;             // OK: double declaration
-}
-struct B {
-  int i;
-};
-struct X : B {
-  using B::i, B::i;             // error: double member declaration
-};
-```
-— *end example*]
-[*Note 3*: For a *using-declaration* whose *nested-name-specifier*
-names a namespace, members added to the namespace after the
-*using-declaration* are not in the set of introduced declarations, so
-they are not considered when a use of the name is made. Thus, additional
-overloads added after the *using-declaration* are ignored, but default
-function arguments [[dcl.fct.default]], default template arguments
-[[temp.param]], and template specializations ([[temp.class.spec]],
-[[temp.expl.spec]]) are considered. — *end note*]
-[*Example 9*:
 ``` cpp
 namespace A {
   void f(int);
 }
@@ -6554,107 +6481,70 @@ void bar() {
 }
 ```
 — *end example*]
-[*Note 4*: Partial specializations of class templates are found by
-looking up the primary class template and then considering all partial
-specializations of that template. If a *using-declaration* names a class
-template, partial specializations introduced after the
-*using-declaration* are effectively visible because the primary template
-is visible [[temp.class.spec]]. — *end note*]
-Since a *using-declaration* is a declaration, the restrictions on
-declarations of the same name in the same declarative region
-[[basic.scope]] also apply to *using-declaration*s.
-[*Example 10*:
 ``` cpp
 namespace A {
   int x;
 }
 namespace B {
   int i;
   struct g { };
   struct x { };
   void f(int);
   void f(double);
-  void g(char); // OK: hides struct g
 }
 void func() {
   int i;
-  using B::i; // error: i declared twice
   void f(char);
-  using B::f; // OK: each f is a function
   f(3.5);                               // calls B::f(double)
   using B::g;
   g('a');                               // calls B::g(char)
   struct g g1;                          // g1 has class type B::g
   using B::x;
-  using A::x; // OK: hides struct B::x
   x = 99;                               // assigns to A::x
   struct x x1;                          // x1 has class type B::x
 }
 ```
 — *end example*]
-If a function declaration in namespace scope or block scope has the same
-name and the same parameter-type-list [[dcl.fct]] as a function
-introduced by a *using-declaration*, and the declarations do not declare
-the same function, the program is ill-formed. If a function template
-declaration in namespace scope has the same name, parameter-type-list,
-trailing *requires-clause* (if any), return type, and *template-head*,
-as a function template introduced by a *using-declaration*, the program
-is ill-formed.
-[*Note 5*:
-Two *using-declaration*s may introduce functions with the same name and
-the same parameter-type-list. If, for a call to an unqualified function
-name, function overload resolution selects the functions introduced by
-such *using-declaration*s, the function call is ill-formed.
-[*Example 11*:
-``` cpp
-namespace B {
-  void f(int);
-  void f(double);
-}
-namespace C {
-  void f(int);
-  void f(double);
-  void f(char);
-}
-void h() {
-  using B::f;       // B::f(int) and B::f(double)
-  using C::f;       // C::f(int), C::f(double), and C::f(char)
-  f('h');           // calls C::f(char)
-  f(1);             // error: ambiguous: B::f(int) or C::f(int)?
-  void f(int);      // error: f(int) conflicts with C::f(int) and B::f(int)
-}
-```
-— *end example*]
-— *end note*]
-When a *using-declarator* brings declarations from a base class into a
-derived class, member functions and member function templates in the
-derived class override and/or hide member functions and member function
-templates with the same name, parameter-type-list [[dcl.fct]], trailing
-*requires-clause* (if any), cv-qualification, and *ref-qualifier* (if
-any), in a base class (rather than conflicting). Such hidden or
-overridden declarations are excluded from the set of declarations
-introduced by the *using-declarator*.
-[*Example 12*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
@@ -6662,17 +6552,17 @@ struct B {
   void h(int);
 };
 struct D : B {
   using B::f;
-  void f(int);      // OK: D::f(int) overrides B::f(int);
   using B::g;
   void g(char);     // OK
   using B::h;
-  void h(int);      // OK: D::h(int) hides B::h(int)
 };
 void k(D* p)
 {
   p->f(1);          // calls D::f(int)
@@ -6696,58 +6586,51 @@ struct D1 : B1, B2 {
 D1 d1(0);           // error: ambiguous
 struct D2 : B1, B2 {
   using B1::B1;
   using B2::B2;
-  D2(int);          // OK: D2::D2(int) hides B1::B1(int) and B2::B2(int)
 };
 D2 d2(0);           // calls D2::D2(int)
 ```
 — *end example*]
-[*Note 6*: For the purpose of forming a set of candidates during
-overload resolution, the functions that are introduced by a
-*using-declaration* into a derived class are treated as though they were
-members of the derived class [[class.member.lookup]]. In particular, the
-implicit object parameter is treated as if it were a reference to the
-derived class rather than to the base class [[over.match.funcs]]. This
-has no effect on the type of the function, and in all other respects the
-function remains a member of the base class. — *end note*]
-Constructors that are introduced by a *using-declaration* are treated as
 though they were constructors of the derived class when looking up the
 constructors of the derived class [[class.qual]] or forming a set of
-overload candidates ([[over.match.ctor]], [[over.match.copy]],
-[[over.match.list]]).
-[*Note 7*: If such a constructor is selected to perform the
 initialization of an object of class type, all subobjects other than the
 base class from which the constructor originated are implicitly
 initialized [[class.inhctor.init]]. A constructor of a derived class is
 sometimes preferred to a constructor of a base class if they would
 otherwise be ambiguous [[over.match.best]]. — *end note*]
-In a *using-declarator* that does not name a constructor, all members of
-the set of introduced declarations shall be accessible. In a
-*using-declarator* that names a constructor, no access check is
-performed. In particular, if a derived class uses a *using-declarator*
-to access a member of a base class, the member name shall be accessible.
-If the name is that of an overloaded member function, then all functions
-named shall be accessible. The base class members mentioned by a
-*using-declarator* shall be visible in the scope of at least one of the
-direct base classes of the class where the *using-declarator* is
-specified.
-[*Note 8*:
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
-[*Example 13*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
@@ -6766,18 +6649,17 @@ int f(D* d) {
 — *end example*]
 — *end note*]
-A synonym created by a *using-declaration* has the usual accessibility
-for a *member-declaration*. A *using-declarator* that names a
-constructor does not create a synonym; instead, the additional
-constructors are accessible if they would be accessible when used to
-construct an object of the corresponding base class, and the
-accessibility of the *using-declaration* is ignored.
-[*Example 14*:
 ``` cpp
 class A {
 private:
     void f(char);
@@ -6794,14 +6676,10 @@ public:
 };
 ```
 — *end example*]
-If a *using-declarator* uses the keyword `typename` and specifies a
-dependent name [[temp.dep]], the name introduced by the
-*using-declaration* is treated as a *typedef-name* [[dcl.typedef]].
 ## The `asm` declaration <a id="dcl.asm">[[dcl.asm]]</a>
 An `asm` declaration has the form
 ``` bnf
@@ -6816,32 +6694,32 @@ The `asm` declaration is conditionally-supported; its meaning is
 [*Note 1*: Typically it is used to pass information through the
 implementation to an assembler. — *end note*]
 ## Linkage specifications <a id="dcl.link">[[dcl.link]]</a>
-All function types, function names with external linkage, and variable
-names with external linkage have a *language linkage*.
 [*Note 1*: Some of the properties associated with an entity with
 language linkage are specific to each implementation and are not
-described here. For example, a particular language linkage may be
 associated with a particular form of representing names of objects and
 functions with external linkage, or with a particular calling
 convention, etc. — *end note*]
-The default language linkage of all function types, function names, and
-variable names is C++ language linkage. Two function types with
-different language linkages are distinct types even if they are
-otherwise identical.
 Linkage [[basic.link]] between C++ and non-C++ code fragments can be
 achieved using a *linkage-specification*:
 ``` bnf
 linkage-specification:
     extern string-literal '{' declaration-seqₒₚₜ '}'
-    extern string-literal declaration
 ```
 The *string-literal* indicates the required language linkage. This
 document specifies the semantics for the *string-literal*s `"C"` and
 `"C++"`. Use of a *string-literal* other than `"C"` or `"C++"` is
@@ -6849,143 +6727,119 @@ conditionally-supported, with *implementation-defined* semantics.
 [*Note 2*: Therefore, a linkage-specification with a *string-literal*
 that is unknown to the implementation requires a
 diagnostic. — *end note*]
-[*Note 3*: It is recommended that the spelling of the *string-literal*
-be taken from the document defining that language. For example, `Ada`
-(not `ADA`) and `Fortran` or `FORTRAN`, depending on the
-vintage. — *end note*]
-Every implementation shall provide for linkage to functions written in
-the C programming language, `"C"`, and linkage to C++ functions,
-`"C++"`.
 [*Example 1*:
 ``` cpp
-complex sqrt(complex);          // C++{} linkage by default
 extern "C" {
-  double sqrt(double);          // C linkage
 }
 ```
 — *end example*]
-A *module-import-declaration* shall not be directly contained in a
-*linkage-specification*. A *module-import-declaration* appearing in a
-linkage specification with other than C++ language linkage is
-conditionally-supported with *implementation-defined* semantics.
 Linkage specifications nest. When linkage specifications nest, the
-innermost one determines the language linkage. A linkage specification
-does not establish a scope. A *linkage-specification* shall occur only
-in namespace scope [[basic.scope]]. In a *linkage-specification*, the
-specified language linkage applies to the function types of all function
-declarators, function names with external linkage, and variable names
-with external linkage declared within the *linkage-specification*.
 [*Example 2*:
 ``` cpp
-extern "C"                      // the name f1 and its function type have C language linkage;
   void f1(void(*pf)(int));      // pf is a pointer to a C function
 extern "C" typedef void FUNC();
-FUNC f2;                        // the name f2 has C++{} language linkage and the
-                                // function's type has C language linkage
-extern "C" FUNC f3;             // the name of function f3 and the function's type have C language linkage
-void (*pf2)(FUNC*);             // the name of the variable pf2 has C++{} linkage and the type
-                                // of pf2 is ``pointer to C++{} function that takes one parameter of type
                                 // pointer to C function''
 extern "C" {
-  static void f4();             // the name of the function f4 has internal linkage (not C language linkage)
-                                // and the function's type has C language linkage.
 }
 extern "C" void f5() {
-  extern void f4();             // OK: Name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 }
-extern void f4();               // OK: Name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 void f6() {
-  extern void f4();             // OK: Name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 }
 ```
 — *end example*]
 A C language linkage is ignored in determining the language linkage of
-the names of class members and the function type of class member
-functions.
 [*Example 3*:
 ``` cpp
 extern "C" typedef void FUNC_c();
 class C {
-  void mf1(FUNC_c*);            // the name of the function mf1 and the member function's type have
-                                // C++{} language linkage; the parameter has type ``pointer to C function''
-  FUNC_c mf2;                   // the name of the function mf2 and the member function's type have
-                                // C++{} language linkage
-  static FUNC_c* q;             // the name of the data member q has C++{} language linkage and
-                                // the data member's type is ``pointer to C function''
 };
 extern "C" {
   class X {
-    void mf();                  // the name of the function mf and the member function's type have
- // C++{} language linkage
-    void mf2(void(*)());        // the name of the function mf2 has C++{} language linkage;
                                 // the parameter has type ``pointer to C function''
   };
 }
 ```
 — *end example*]
-If two declarations declare functions with the same name and
-parameter-type-list [[dcl.fct]] to be members of the same namespace or
-declare objects with the same name to be members of the same namespace
-and the declarations give the names different language linkages, the
-program is ill-formed; no diagnostic is required if the declarations
-appear in different translation units. Except for functions with C++
-linkage, a function declaration without a linkage specification shall
-not precede the first linkage specification for that function. A
-function can be declared without a linkage specification after an
-explicit linkage specification has been seen; the linkage explicitly
-specified in the earlier declaration is not affected by such a function
-declaration.
-At most one function with a particular name can have C language linkage.
-Two declarations for a function with C language linkage with the same
-function name (ignoring the namespace names that qualify it) that appear
-in different namespace scopes refer to the same function. Two
-declarations for a variable with C language linkage with the same name
-(ignoring the namespace names that qualify it) that appear in different
-namespace scopes refer to the same variable. An entity with C language
-linkage shall not be declared with the same name as a variable in global
-scope, unless both declarations denote the same entity; no diagnostic is
-required if the declarations appear in different translation units. A
-variable with C language linkage shall not be declared with the same
-name as a function with C language linkage (ignoring the namespace names
-that qualify the respective names); no diagnostic is required if the
-declarations appear in different translation units.
-[*Note 4*: Only one definition for an entity with a given name with C
-language linkage may appear in the program (see  [[basic.def.odr]]);
-this implies that such an entity must not be defined in more than one
-namespace scope. — *end note*]
 [*Example 4*:
 ``` cpp
 int x;
@@ -7025,11 +6879,11 @@ extern "C" {
 extern "C" static void g();         // error
 ```
 — *end example*]
-[*Note 5*: Because the language linkage is part of a function type,
 when indirecting through a pointer to C function, the function to which
 the resulting lvalue refers is considered a C function. — *end note*]
 Linkage from C++ to objects defined in other languages and to objects
 defined in C++ from other languages is *implementation-defined* and
@@ -7152,39 +7006,53 @@ contained in an *attribute-token*, it is considered an identifier. No
 name lookup [[basic.lookup]] is performed on any of the identifiers
 contained in an *attribute-token*. The *attribute-token* determines
 additional requirements on the *attribute-argument-clause* (if any).
 Each *attribute-specifier-seq* is said to *appertain* to some entity or
-statement, identified by the syntactic context where it appears (
-[[stmt.stmt]], [[dcl.dcl]], [[dcl.decl]]). If an
 *attribute-specifier-seq* that appertains to some entity or statement
 contains an *attribute* or *alignment-specifier* that is not allowed to
 apply to that entity or statement, the program is ill-formed. If an
 *attribute-specifier-seq* appertains to a friend declaration
 [[class.friend]], that declaration shall be a definition.
 [*Note 3*: An *attribute-specifier-seq* cannot appeartain to an
 explicit instantiation [[temp.explicit]]. — *end note*]
 For an *attribute-token* (including an *attribute-scoped-token*) not
-specified in this document, the behavior is *implementation-defined*.
-Any *attribute-token* that is not recognized by the implementation is
-ignored. An *attribute-token* is reserved for future standardization if
 - it is not an *attribute-scoped-token* and is not specified in this
   document, or
 - it is an *attribute-scoped-token* and its *attribute-namespace* is
   `std` followed by zero or more digits.
-[*Note 4*: Each implementation should choose a distinctive name for the
-*attribute-namespace* in an *attribute-scoped-token*. — *end note*]
 Two consecutive left square bracket tokens shall appear only when
 introducing an *attribute-specifier* or within the *balanced-token-seq*
 of an *attribute-argument-clause*.
-[*Note 5*: If two consecutive left square brackets appear where an
 *attribute-specifier* is not allowed, the program is ill-formed even if
 the brackets match an alternative grammar production. — *end note*]
 [*Example 2*:
@@ -7289,23 +7157,58 @@ alignas(float)
   extern unsigned char c[sizeof(double)];           // error: different alignment in declaration
 ```
 — *end example*]
 ### Carries dependency attribute <a id="dcl.attr.depend">[[dcl.attr.depend]]</a>
 The *attribute-token* `carries_dependency` specifies dependency
-propagation into and out of functions. It shall appear at most once in
-each *attribute-list* and no *attribute-argument-clause* shall be
-present. The attribute may be applied to the *declarator-id* of a
-*parameter-declaration* in a function declaration or lambda, in which
-case it specifies that the initialization of the parameter carries a
-dependency to [[intro.multithread]] each lvalue-to-rvalue conversion
-[[conv.lval]] of that object. The attribute may also be applied to the
-*declarator-id* of a function declaration, in which case it specifies
-that the return value, if any, carries a dependency to the evaluation of
-the function call expression.
 The first declaration of a function shall specify the
 `carries_dependency` attribute for its *declarator-id* if any
 declaration of the function specifies the `carries_dependency`
 attribute. Furthermore, the first declaration of a function shall
@@ -7317,11 +7220,11 @@ declaration in one translation unit and the same function or one of its
 parameters is declared without the `carries_dependency` attribute in its
 first declaration in another translation unit, the program is
 ill-formed, no diagnostic required.
 [*Note 1*: The `carries_dependency` attribute does not change the
-meaning of the program, but may result in generation of more efficient
 code. — *end note*]
 [*Example 1*:
 ``` cpp
@@ -7373,28 +7276,28 @@ The *attribute-token* `deprecated` can be used to mark names and
 entities whose use is still allowed, but is discouraged for some reason.
 [*Note 1*: In particular, `deprecated` is appropriate for names and
 entities that are deemed obsolescent or unsafe. — *end note*]
-It shall appear at most once in each *attribute-list*. An
-*attribute-argument-clause* may be present and, if present, it shall
 have the form:
 ``` bnf
 '(' string-literal ')'
 ```
-[*Note 2*: The *string-literal* in the *attribute-argument-clause*
-could be used to explain the rationale for deprecation and/or to suggest
-a replacing entity. — *end note*]
 The attribute may be applied to the declaration of a class, a
 *typedef-name*, a variable, a non-static data member, a function, a
-namespace, an enumeration, an enumerator, or a template specialization.
-A name or entity declared without the `deprecated` attribute can later
-be redeclared with the attribute and vice-versa.
 [*Note 3*: Thus, an entity initially declared without the attribute can
 be marked as deprecated by a subsequent redeclaration. However, after an
 entity is marked as deprecated, later redeclarations do not un-deprecate
 the entity. — *end note*]
@@ -7411,21 +7314,20 @@ provided within the *attribute-argument-clause* of any `deprecated`
 attribute applied to the name or entity.
 ### Fallthrough attribute <a id="dcl.attr.fallthrough">[[dcl.attr.fallthrough]]</a>
 The *attribute-token* `fallthrough` may be applied to a null statement
-[[stmt.expr]]; such a statement is a fallthrough statement. The
-*attribute-token* `fallthrough` shall appear at most once in each
-*attribute-list* and no *attribute-argument-clause* shall be present. A
-fallthrough statement may only appear within an enclosing `switch`
-statement [[stmt.switch]]. The next statement that would be executed
-after a fallthrough statement shall be a labeled statement whose label
-is a case label or default label for the same `switch` statement and, if
-the fallthrough statement is contained in an iteration statement, the
-next statement shall be part of the same execution of the substatement
-of the innermost enclosing iteration statement. The program is
-ill-formed if there is no such statement.
 *Recommended practice:* The use of a fallthrough statement should
 suppress a warning that an implementation might otherwise issue for a
 case or default label that is reachable from another case or default
 label along some path of execution. Implementations should issue a
@@ -7465,15 +7367,14 @@ void f(int n) {
 — *end example*]
 ### Likelihood attributes <a id="dcl.attr.likelihood">[[dcl.attr.likelihood]]</a>
 The *attribute-token*s `likely` and `unlikely` may be applied to labels
-or statements. The *attribute-token*s `likely` and `unlikely` shall
-appear at most once in each *attribute-list* and no
-*attribute-argument-clause* shall be present. The *attribute-token*
-`likely` shall not appear in an *attribute-specifier-seq* that contains
-the *attribute-token* `unlikely`.
 *Recommended practice:* The use of the `likely` attribute is intended to
 allow implementations to optimize for the case where paths of execution
 including it are arbitrarily more likely than any alternative path of
 execution that does not include such an attribute on a statement or
@@ -7513,12 +7414,12 @@ int f(int n) {
 — *end example*]
 ### Maybe unused attribute <a id="dcl.attr.unused">[[dcl.attr.unused]]</a>
 The *attribute-token* `maybe_unused` indicates that a name or entity is
-possibly intentionally unused. It shall appear at most once in each
-*attribute-list* and no *attribute-argument-clause* shall be present.
 The attribute may be applied to the declaration of a class, a
 *typedef-name*, a variable (including a structured binding declaration),
 a non-static data member, a function, an enumeration, or an enumerator.
@@ -7548,13 +7449,12 @@ Implementations should not warn that `b` is unused, whether or not
 — *end example*]
 ### Nodiscard attribute <a id="dcl.attr.nodiscard">[[dcl.attr.nodiscard]]</a>
-The *attribute-token* `nodiscard` may be applied to the *declarator-id*
-in a function declaration or to the declaration of a class or
-enumeration. It shall appear at most once in each *attribute-list*. An
 *attribute-argument-clause* may be present and, if present, shall have
 the form:
 ``` bnf
 '(' string-literal ')'
@@ -7577,14 +7477,15 @@ type marked `nodiscard` in a reachable declaration. A *nodiscard call*
 is either
 - a function call expression [[expr.call]] that calls a function
   declared `nodiscard` in a reachable declaration or whose return type
   is a nodiscard type, or
-- an explicit type conversion ([[expr.type.conv]],
-  [[expr.static.cast]], [[expr.cast]]) that constructs an object through
-  a constructor declared `nodiscard` in a reachable declaration, or that
-  initializes an object of a nodiscard type.
 *Recommended practice:* Appearance of a nodiscard call as a
 potentially-evaluated discarded-value expression [[expr.prop]] is
 discouraged unless explicitly cast to `void`. Implementations should
 issue a warning in such cases.
@@ -7626,13 +7527,12 @@ void f() { foo(); }             // warning not encouraged: not a nodiscard call,
 — *end example*]
 ### Noreturn attribute <a id="dcl.attr.noreturn">[[dcl.attr.noreturn]]</a>
 The *attribute-token* `noreturn` specifies that a function does not
-return. It shall appear at most once in each *attribute-list* and no
-*attribute-argument-clause* shall be present. The attribute may be
-applied to the *declarator-id* in a function declaration. The first
 declaration of a function shall specify the `noreturn` attribute if any
 declaration of that function specifies the `noreturn` attribute. If a
 function is declared with the `noreturn` attribute in one translation
 unit and the same function is declared without the `noreturn` attribute
 in another translation unit, the program is ill-formed, no diagnostic
@@ -7664,12 +7564,11 @@ function marked `[[noreturn]]` might return.
 — *end example*]
 ### No unique address attribute <a id="dcl.attr.nouniqueaddr">[[dcl.attr.nouniqueaddr]]</a>
 The *attribute-token* `no_unique_address` specifies that a non-static
-data member is a potentially-overlapping subobject [[intro.object]]. It
-shall appear at most once in each *attribute-list* and no
 *attribute-argument-clause* shall be present. The attribute may
 appertain to a non-static data member other than a bit-field.
 [*Note 1*: The non-static data member can share the address of another
 non-static data member or that of a base class, and any padding that
@@ -7705,22 +7604,19 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
-[basic.lookup.classref]: basic.md#basic.lookup.classref
 [basic.lookup.elab]: basic.md#basic.lookup.elab
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.namespace]: #basic.namespace
-[basic.scope]: basic.md#basic.scope
-[basic.scope.block]: basic.md#basic.scope.block
-[basic.scope.declarative]: basic.md#basic.scope.declarative
 [basic.scope.namespace]: basic.md#basic.scope.namespace
-[basic.scope.param]: basic.md#basic.scope.param
-[basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.start]: basic.md#basic.start
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
@@ -7728,17 +7624,15 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
-[basic.types]: basic.md#basic.types
 [class]: class.md#class
 [class.access]: class.md#class.access
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
-[class.compare.default]: class.md#class.compare.default
-[class.conv]: class.md#class.conv
 [class.conv.ctor]: class.md#class.conv.ctor
 [class.conv.fct]: class.md#class.conv.fct
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
@@ -7748,11 +7642,12 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [class.expl.init]: class.md#class.expl.init
 [class.friend]: class.md#class.friend
 [class.inhctor.init]: class.md#class.inhctor.init
 [class.init]: class.md#class.init
 [class.mem]: class.md#class.mem
-[class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mi]: class.md#class.mi
 [class.name]: class.md#class.name
 [class.pre]: class.md#class.pre
 [class.qual]: basic.md#class.qual
@@ -7763,10 +7658,12 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [conv]: expr.md#conv
 [conv.array]: expr.md#conv.array
 [conv.func]: expr.md#conv.func
 [conv.lval]: expr.md#conv.lval
 [conv.prom]: expr.md#conv.prom
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rval]: expr.md#conv.rval
@@ -7775,10 +7672,11 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.likelihood]: #dcl.attr.likelihood
@@ -7788,10 +7686,11 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.constinit]: #dcl.constinit
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.fct.def]: #dcl.fct.def
 [dcl.fct.def.coroutine]: #dcl.fct.def.coroutine
 [dcl.fct.def.default]: #dcl.fct.def.default
@@ -7800,80 +7699,92 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [dcl.fct.default]: #dcl.fct.default
 [dcl.fct.spec]: #dcl.fct.spec
 [dcl.friend]: #dcl.friend
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
 [dcl.inline]: #dcl.inline
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.pre]: #dcl.pre
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
 [dcl.stc]: #dcl.stc
 [dcl.struct.bind]: #dcl.struct.bind
 [dcl.type]: #dcl.type
 [dcl.type.auto.deduct]: #dcl.type.auto.deduct
 [dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.decltype]: #dcl.type.decltype
 [dcl.type.elab]: #dcl.type.elab
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
 [depr.volatile.type]: future.md#depr.volatile.type
 [enum]: #enum
 [enum.udecl]: #enum.udecl
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
 [expr.post.incr]: expr.md#expr.post.incr
 [expr.pre.incr]: expr.md#expr.pre.incr
 [expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.prim.this]: expr.md#expr.prim.this
 [expr.prop]: expr.md#expr.prop
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.yield]: expr.md#expr.yield
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: basic.md#intro.execution
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
-[lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [lex.string]: lex.md#lex.string
 [module.interface]: module.md#module.interface
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
-[namespace.memdef]: #namespace.memdef
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.binary]: over.md#over.binary
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
@@ -7883,42 +7794,44 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
 [over.match.ref]: over.md#over.match.ref
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [special]: class.md#special
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.expr]: stmt.md#stmt.expr
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
-[stmt.label]: stmt.md#stmt.label
-[stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
 [temp.arg.type]: temp.md#temp.arg.type
-[temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.deduct.guide]: temp.md#temp.deduct.guide
-[temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.fct]: temp.md#temp.fct
 [temp.inst]: temp.md#temp.inst
 [temp.local]: temp.md#temp.local
-[temp.mem]: temp.md#temp.mem
 [temp.names]: temp.md#temp.names
-[temp.over.link]: temp.md#temp.over.link
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
-[temp.spec]: temp.md#temp.spec
 [temp.variadic]: temp.md#temp.variadic
 [^1]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
@@ -7946,25 +7859,22 @@ Here, `hasher`, `pred`, and `alloc` could have the same address as
     reference type.
 [^8]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation
     [[lex.name]]. If a predefined variable is not odr-used
-    [[basic.def.odr]], its string value need not be present in the
     program image.
 [^9]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
-[^10]: this implies that the name of the class or function is
-    unqualified.
-[^11]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
-    some paths [[class.member.lookup]]. There is no such disambiguation
-    when considering the set of names found as a result of following
-    *using-directive*s.
-[^12]: A *using-declaration* with more than one *using-declarator* is
     equivalent to a corresponding sequence of *using-declaration*s with
     one *using-declarator* each.

     declaration-seq declaration
 ```
 ``` bnf
 declaration:
+    name-declaration
+    special-declaration
+```
+``` bnf
+name-declaration:
     block-declaration
     nodeclspec-function-declaration
     function-definition
     template-declaration
     deduction-guide
     linkage-specification
     namespace-definition
     empty-declaration
     attribute-declaration
     module-import-declaration
 ```
+``` bnf
+special-declaration:
+    explicit-instantiation
+    explicit-specialization
+    export-declaration
+```
 ``` bnf
 block-declaration:
     simple-declaration
     asm-declaration
     namespace-alias-definition
 [[temp.deduct.guide]]; *namespace-definition*s are described in
 [[namespace.def]], *using-declaration*s are described in
 [[namespace.udecl]] and *using-directive*s are described in
 [[namespace.udir]]. — *end note*]
+Certain declarations contain one or more scopes [[basic.scope.scope]].
+Unless otherwise stated, utterances in [[dcl.dcl]] about components in,
+of, or contained by a declaration or subcomponent thereof refer only to
+those components of the declaration that are *not* nested within scopes
+nested within the declaration.
 A *simple-declaration* or *nodeclspec-function-declaration* of the form
 ``` bnf
 attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 ```
 *init-declarator-list*, are described in [[dcl.decl]]. The
 *attribute-specifier-seq* appertains to each of the entities declared by
 the *declarator*s of the *init-declarator-list*.
 [*Note 2*: In the declaration for an entity, attributes appertaining to
+that entity can appear at the start of the declaration and after the
 *declarator-id* for that declaration. — *end note*]
 [*Example 1*:
 ``` cpp
 [[noreturn]] void f [[noreturn]] ();    // OK
 ```
 — *end example*]
+If a *declarator-id* is a name, the *init-declarator* and (hence) the
+declaration introduce that name.
+[*Note 3*: Otherwise, the *declarator-id* is a *qualified-id* or names
+a destructor or its *unqualified-id* is a *template-id* and no name is
+introduced. — *end note*]
+The *defining-type-specifier*s [[dcl.type]] in the *decl-specifier-seq*
+and the recursive *declarator* structure describe a type
+[[dcl.meaning]], which is then associated with the *declarator-id*.
 In a *simple-declaration*, the optional *init-declarator-list* can be
+omitted only when declaring a class [[class.pre]] or enumeration
 [[dcl.enum]], that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key*
 [[class.name]], or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
+*decl-specifier-seq*, the identifiers in these specifiers are also
+declared (as *class-name*s, *enum-name*s, or *enumerator*s, depending on
+the syntax). In such cases, the *decl-specifier-seq* shall (re)introduce
+one or more names into the program.
 [*Example 2*:
 ``` cpp
 enum { };           // error
 typedef class { };  // error
 ```
 — *end example*]
 A *simple-declaration* with an *identifier-list* is called a *structured
+binding declaration* [[dcl.struct.bind]]. Each *decl-specifier* in the
+*decl-specifier-seq* shall be `static`, `thread_local`, `auto`
+[[dcl.spec.auto]], or a *cv-qualifier*.
+[*Example 3*:
+``` cpp
+template<class T> concept C = true;
+C auto [x, y] = std::pair{1, 2};    // error: constrained placeholder-type-specifier
+                                    // not permitted for structured bindings
+```
+— *end example*]
 The *initializer* shall be of the form “`=` *assignment-expression*”, of
 the form “`{` *assignment-expression* `}`”, or of the form “`(`
 *assignment-expression* `)`”, where the *assignment-expression* is of
 array or non-union class type.
 If the *decl-specifier-seq* contains the `typedef` specifier, the
+declaration is a *typedef declaration* and each *declarator-id* is
+declared to be a *typedef-name*, synonymous with its associated type
+[[dcl.typedef]].
+[*Note 4*: Such a *declarator-id* is an *identifier*
+[[class.conv.fct]]. — *end note*]
+Otherwise, if the type associated with a *declarator-id* is a function
+type [[dcl.fct]], the declaration is a *function declaration*.
+Otherwise, if the type associated with a *declarator-id* is an object or
+reference type, the declaration is an *object declaration*. Otherwise,
+the program is ill-formed.
+[*Example 4*:
+``` cpp
+int f(), x;             // OK, function declaration for f and object declaration for x
+extern void g(),        // OK, function declaration for g
+  y;                    // error: void is not an object type
+```
+— *end example*]
 Syntactic components beyond those found in the general form of
+*simple-declaration* are added to a function declaration to make a
 *function-definition*. An object declaration, however, is also a
 definition unless it contains the `extern` specifier and has no
 initializer [[basic.def]]. An object definition causes storage of
 appropriate size and alignment to be reserved and any appropriate
 initialization [[dcl.init]] to be done.
 A *nodeclspec-function-declaration* shall declare a constructor,
 destructor, or conversion function.
+[*Note 5*: Because a member function cannot be subject to a
+non-defining declaration outside of a class definition [[class.mfct]], a
+*nodeclspec-function-declaration* can only be used in a
 *template-declaration* [[temp.pre]], *explicit-instantiation*
 [[temp.explicit]], or *explicit-specialization*
 [[temp.expl.spec]]. — *end note*]
+In a *static_assert-declaration*, the *constant-expression* is
+contextually converted to `bool` and the converted expression shall be a
+constant expression [[expr.const]]. If the value of the expression when
+so converted is `true` or the expression is evaluated in the context of
+a template definition, the declaration has no effect. Otherwise, the
+*static_assert-declaration* *fails*, the program is ill-formed, and the
+resulting diagnostic message [[intro.compliance]] should include the
+text of the *string-literal*, if one is supplied.
+[*Example 5*:
+``` cpp
+static_assert(sizeof(int) == sizeof(void*), "wrong pointer size");
+static_assert(sizeof(int[2]));          // OK, narrowing allowed
+template <class T>
+void f(T t) {
+  if constexpr (sizeof(T) == sizeof(int)) {
+    use(t);
+  } else {
+    static_assert(false, "must be int-sized");
+  }
+}
+void g(char c) {
+  f(0);                                 // OK
+  f(c);                                 // error on implementations where sizeof(int) > 1: must be int-sized
+}
+```
+— *end example*]
+An *empty-declaration* has no effect.
+Except where otherwise specified, the meaning of an
+*attribute-declaration* is *implementation-defined*.
 ## Specifiers <a id="dcl.spec">[[dcl.spec]]</a>
+### General <a id="dcl.spec.general">[[dcl.spec.general]]</a>
 The specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
 *init-declarator-list* or *member-declarator-list* of the declaration
+shall not be empty (except for an anonymous union declared in a
+namespace scope [[class.union.anon]]). The *storage-class-specifier*
+applies to the name declared by each *init-declarator* in the list and
+not to any names declared by other specifiers.
 [*Note 1*: See [[temp.expl.spec]] and [[temp.explicit]] for
 restrictions in explicit specializations and explicit instantiations,
 respectively. — *end note*]
 [*Note 3*: The `extern` keyword can also be used in
 *explicit-instantiation*s and *linkage-specification*s, but it is not a
 *storage-class-specifier* in such contexts. — *end note*]
+All declarations for a given entity shall give its name the same
+linkage.
+[*Note 4*: The linkage given by some declarations is affected by
+previous declarations. Overloads are distinct entities. — *end note*]
 [*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
 };
 ```
 — *end example*]
+[*Note 5*: The `mutable` specifier on a class data member nullifies a
 `const` specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
+object is const
+[[basic.type.qualifier]], [[dcl.type.cv]]. — *end note*]
 ### Function specifiers <a id="dcl.fct.spec">[[dcl.fct.spec]]</a>
 A *function-specifier* can be used only in a function declaration.
     explicit '(' constant-expression ')'
     explicit
 ```
 The `virtual` specifier shall be used only in the initial declaration of
+a non-static member function; see  [[class.virtual]].
 An *explicit-specifier* shall be used only in the declaration of a
 constructor or conversion function within its class definition; see
 [[class.conv.ctor]] and  [[class.conv.fct]].
 `explicit(true)`. If the constant expression evaluates to `true`, the
 function is explicit. Otherwise, the function is not explicit. A `(`
 token that follows `explicit` is parsed as part of the
 *explicit-specifier*.
+[*Example 1*:
+``` cpp
+struct S {
+  explicit(sizeof(char[2])) S(char);    // error: narrowing conversion of value 2 to type bool
+  explicit(sizeof(char)) S(bool);       // OK, conversion of value 1 to type bool is non-narrowing
+};
+```
+— *end example*]
 ### The `typedef` specifier <a id="dcl.typedef">[[dcl.typedef]]</a>
 Declarations containing the *decl-specifier* `typedef` declare
 identifiers that can be used later for naming fundamental
 [[basic.fundamental]] or compound [[basic.compound]] types. The
 of `metricp` is “pointer to `int`”.
 — *end example*]
 A *typedef-name* can also be introduced by an *alias-declaration*. The
+*identifier* following the `using` keyword is not looked up; it becomes
+a *typedef-name* and the optional *attribute-specifier-seq* following
+the *identifier* appertains to that *typedef-name*. Such a
+*typedef-name* has the same semantics as if it were introduced by the
+`typedef` specifier. In particular, it does not define a new type.
 [*Example 2*:
 ``` cpp
 using handler_t = void (*)(int);
 extern handler_t ignore;
 extern void (*ignore)(int);         // redeclare ignore
+template<class T> struct P { };
+using cell = P<cell*>;              // error: cell not found[basic.scope.pdecl]
 ```
 — *end example*]
 The *defining-type-specifier-seq* of the *defining-type-id* shall not
 define a class or enumeration if the *alias-declaration* is the
 *declaration* of a *template-declaration*.
 A *simple-template-id* is only a *typedef-name* if its *template-name*
 names an alias template or a template *template-parameter*.
 [*Note 1*: A *simple-template-id* that names a class template
 specialization is a *class-name* [[class.name]]. If a *typedef-name* is
 used to identify the subject of an *elaborated-type-specifier*
 [[dcl.type.elab]], a class definition [[class]], a constructor
 declaration [[class.ctor]], or a destructor declaration [[class.dtor]],
 the program is ill-formed. — *end note*]
+[*Example 3*:
 ``` cpp
 struct S {
   S();
   ~S();
 struct T * p;                   // error
 ```
 — *end example*]
+An unnamed class or enumeration C defined in a typedef declaration has
+the first *typedef-name* declared by the declaration to be of type C as
+its *typedef name for linkage purposes* [[basic.link]].
 [*Note 2*: A typedef declaration involving a *lambda-expression* does
 not itself define the associated closure type, and so the closure type
+is not given a typedef name for linkage purposes. — *end note*]
+[*Example 4*:
 ``` cpp
+typedef struct { } *ps, S;      // S is the typedef name for linkage purposes
+typedef decltype([]{}) C;       // the closure type has no typedef name for linkage purposes
 ```
 — *end example*]
 An unnamed class with a typedef name for linkage purposes shall not
 - contain a *lambda-expression*,
 and all member classes shall also satisfy these requirements
 (recursively).
+[*Example 5*:
 ``` cpp
 typedef struct {
   int f() {}
 } X;                            // error: struct with typedef name for linkage has member functions
 `constexpr`. — *end note*]
 [*Example 1*:
 ``` cpp
+constexpr void square(int &x);  // OK, declaration
+constexpr int bufsz = 1024;     // OK, definition
 constexpr struct pixel {        // error: pixel is a type
   int x;
   int y;
+  constexpr pixel(int);         // OK, declaration
 };
 constexpr pixel::pixel(int a)
+  : x(a), y(x)                  // OK, definition
   { square(x); }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant[expr.const] so constexpr not satisfied
+constexpr void square(int &x) { // OK, definition
   x *= x;
 }
+constexpr pixel large(4);       // OK, square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
 extern constexpr int memsz;     // error: not a definition
 ```
 — *end example*]
 A `constexpr` or `consteval` specifier used in the declaration of a
+function declares that function to be a *constexpr function*.
+[*Note 3*: A function or constructor declared with the `consteval`
+specifier is an immediate function [[expr.const]]. — *end note*]
+A destructor, an allocation function, or a deallocation function shall
+not be declared with the `consteval` specifier.
+A function is *constexpr-suitable* if:
+- it is not a coroutine [[dcl.fct.def.coroutine]], and
+- if the function is a constructor or destructor, its class does not
+  have any virtual base classes.
+Except for instantiated constexpr functions, non-templated constexpr
+functions shall be constexpr-suitable.
 [*Example 2*:
 ``` cpp
 constexpr int square(int x)
 constexpr int abs(int x) {
   if (x < 0)
     x = -x;
   return x;                     // OK
 }
+constexpr int constant_non_42(int n) {  // OK
+ if (n == 42) {
+    static int value = n;
     return value;
   }
+  return n;
+}
 constexpr int uninit() {
   struct { int a; } s;
   return s.a;                   // error: uninitialized read of s.a
 }
 constexpr int prev(int x)
 }
 ```
 — *end example*]
 An invocation of a constexpr function in a given context produces the
 same result as an invocation of an equivalent non-constexpr function in
 the same context in all respects except that
 - an invocation of a constexpr function can appear in a constant
 [*Note 4*: Declaring a function constexpr can change whether an
 expression is a constant expression. This can indirectly cause calls to
 `std::is_constant_evaluated` within an invocation of the function to
 produce a different value. — *end note*]
+[*Note 5*: It is possible to write a constexpr function for which no
+invocation satisfies the requirements of a core constant
+expression. — *end note*]
 The `constexpr` and `consteval` specifiers have no effect on the type of
 a constexpr function.
+[*Example 3*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
     { return x + y + x*y; }
 // ...
 A `constexpr` specifier used in an object declaration declares the
 object as const. Such an object shall have literal type and shall be
 initialized. In any `constexpr` variable declaration, the
 full-expression of the initialization shall be a constant expression
+[[expr.const]]. A `constexpr` variable that is an object, as well as any
+temporary to which a `constexpr` reference is bound, shall have constant
+destruction.
+[*Example 4*:
 ``` cpp
 struct pixel {
   int x, y;
 };
 applied to any declaration of a variable, it shall be applied to the
 initializing declaration. No diagnostic is required if no `constinit`
 declaration is reachable at the point of the initializing declaration.
 If a variable declared with the `constinit` specifier has dynamic
+initialization [[basic.start.dynamic]], the program is ill-formed, even
+if the implementation would perform that initialization as a static
+initialization [[basic.start.static]].
 [*Note 1*: The `constinit` specifier ensures that the variable is
+initialized during static initialization. — *end note*]
 [*Example 1*:
 ``` cpp
 const char * g() { return "dynamic initialization"; }
 ### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
 The `inline` specifier shall be applied only to the declaration of a
 variable or function.
+A function declaration [[dcl.fct]], [[class.mfct]], [[class.friend]]
 with an `inline` specifier declares an *inline function*. The inline
 specifier indicates to the implementation that inline substitution of
 the function body at the point of call is to be preferred to the usual
 function call mechanism. An implementation is not required to perform
 this inline substitution at the point of call; however, even if this
 in one definition domain, an inline declaration of it shall be reachable
 from the end of every definition domain in which it is declared; no
 diagnostic is required.
 [*Note 2*: A call to an inline function or a use of an inline variable
+can be encountered before its definition becomes reachable in a
 translation unit. — *end note*]
 [*Note 3*: An inline function or variable with external or module
+linkage can be defined in multiple translation units [[basic.def.odr]],
+but is one entity with one address. A type or `static` variable defined
+in the body of such a function is therefore a single
+entity. — *end note*]
 If an inline function or variable that is attached to a named module is
 declared in a definition domain, it shall be defined in that domain.
 [*Note 4*: A constexpr function [[dcl.constexpr]] is implicitly inline.
 In the global module, a function defined within a class definition is
+implicitly inline [[class.mfct]], [[class.friend]]. — *end note*]
 ### Type specifiers <a id="dcl.type">[[dcl.type]]</a>
+#### General <a id="dcl.type.general">[[dcl.type.general]]</a>
 The type-specifiers are
 ``` bnf
 type-specifier:
   simple-type-specifier
 complete *decl-specifier-seq*.[^1]
 [*Note 1*: *enum-specifier*s, *class-specifier*s, and
 *typename-specifier*s are discussed in [[dcl.enum]], [[class]], and
 [[temp.res]], respectively. The remaining *type-specifier*s are
+discussed in the rest of [[dcl.type]]. — *end note*]
 #### The *cv-qualifier*s <a id="dcl.type.cv">[[dcl.type.cv]]</a>
 There are two *cv-qualifier*s, `const` and `volatile`. Each
 *cv-qualifier* shall appear at most once in a *cv-qualifier-seq*. If a
 some other access path.
 [*Note 4*: Cv-qualifiers are supported by the type system so that they
 cannot be subverted without casting [[expr.const.cast]]. — *end note*]
+Any attempt to modify
+[[expr.ass]], [[expr.post.incr]], [[expr.pre.incr]] a const object
+[[basic.type.qualifier]] during its lifetime [[basic.life]] results in
+undefined behavior.
 [*Example 1*:
 ``` cpp
 const int ci = 3;                       // cv-qualified (initialized as required)
 ci = 4;                                 // error: attempt to modify const
 int i = 2;                              // not cv-qualified
 const int* cip;                         // pointer to const int
+cip = &i;                               // OK, cv-qualified access path to unqualified
 *cip = 4;                               // error: attempt to modify through ptr to const
 int* ip;
 ip = const_cast<int*>(cip);             // cast needed to convert const int* to int*
 *ip = 4;                                // defined: *ip points to i, a non-const object
     class-name
     enum-name
     typedef-name
 ```
+The component names of a *simple-type-specifier* are those of its
+*nested-name-specifier*, *type-name*, *simple-template-id*,
+*template-name*, and/or *type-constraint* (if it is a
+*placeholder-type-specifier*). The component name of a *type-name* is
+the first name in it.
 A *placeholder-type-specifier* is a placeholder for a type to be deduced
 [[dcl.spec.auto]]. A *type-specifier* of the form `typename`ₒₚₜ
 *nested-name-specifier*ₒₚₜ  *template-name* is a placeholder for a
 deduced class type [[dcl.type.class.deduct]]. The
 *nested-name-specifier*, if any, shall be non-dependent and the
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
     class-key simple-template-id
     class-key nested-name-specifier templateₒₚₜ simple-template-id
     enum nested-name-specifierₒₚₜ identifier
 ```
+The component names of an *elaborated-type-specifier* are its
+*identifier* (if any) and those of its *nested-name-specifier* and
+*simple-template-id* (if any).
+If an *elaborated-type-specifier* is the sole constituent of a
+declaration, the declaration is ill-formed unless it is an explicit
 specialization [[temp.expl.spec]], an explicit instantiation
 [[temp.explicit]] or it has one of the following forms:
 ``` bnf
 class-key attribute-specifier-seqₒₚₜ identifier ';'
+class-key attribute-specifier-seqₒₚₜ simple-template-id ';'
+```
+In the first case, the *elaborated-type-specifier* declares the
+*identifier* as a *class-name*. The second case shall appear only in an
+*explicit-specialization* [[temp.expl.spec]] or in a
+*template-declaration* (where it declares a partial specialization
+[[temp.decls]]). The *attribute-specifier-seq*, if any, appertains to
+the class or template being declared.
+Otherwise, an *elaborated-type-specifier* E shall not have an
+*attribute-specifier-seq*. If E contains an *identifier* but no
+*nested-name-specifier* and (unqualified) lookup for the *identifier*
+finds nothing, E shall not be introduced by the `enum` keyword and
+declares the *identifier* as a *class-name*. The target scope of E is
+the nearest enclosing namespace or block scope.
+If an *elaborated-type-specifier* appears with the `friend` specifier as
+an entire *member-declaration*, the *member-declaration* shall have one
+of the following forms:
+``` bnf
+friend class-key nested-name-specifierₒₚₜ identifier ';'
+friend class-key simple-template-id ';'
 friend class-key nested-name-specifier templateₒₚₜ simple-template-id ';'
 ```
+Any unqualified lookup for the *identifier* (in the first case) does not
+consider scopes that contain the target scope; no name is bound.
+[*Note 1*: A *using-directive* in the target scope is ignored if it
+refers to a namespace not contained by that scope. [[basic.lookup.elab]]
+describes how name lookup proceeds in an
+*elaborated-type-specifier*. — *end note*]
+[*Note 2*: An *elaborated-type-specifier* can be used to refer to a
+previously declared *class-name* or *enum-name* even if the name has
+been hidden by a non-type declaration. — *end note*]
 If the *identifier* or *simple-template-id* resolves to a *class-name*
 or *enum-name*, the *elaborated-type-specifier* introduces it into the
 declaration the same way a *simple-type-specifier* introduces its
 *type-name* [[dcl.type.simple]]. If the *identifier* or
+*simple-template-id* resolves to a *typedef-name*
+[[dcl.typedef]], [[temp.names]], the *elaborated-type-specifier* is
+ill-formed.
+[*Note 3*:
 This implies that, within a class template with a template
 *type-parameter* `T`, the declaration
 ``` cpp
   [[dcl.struct.bind]], `decltype(E)` is the referenced type as given in
   the specification of the structured binding declaration;
 - otherwise, if E is an unparenthesized *id-expression* naming a
   non-type *template-parameter* [[temp.param]], `decltype(E)` is the
   type of the *template-parameter* after performing any necessary type
+  deduction [[dcl.spec.auto]], [[dcl.type.class.deduct]];
 - otherwise, if E is an unparenthesized *id-expression* or an
   unparenthesized class member access [[expr.ref]], `decltype(E)` is the
+  type of the entity named by E. If there is no such entity, the program
+  is ill-formed;
 - otherwise, if E is an xvalue, `decltype(E)` is `T&&`, where `T` is the
   type of E;
 - otherwise, if E is an lvalue, `decltype(E)` is `T&`, where `T` is the
   type of E;
 - otherwise, `decltype(E)` is the type of E.
 The operand of the `decltype` specifier is an unevaluated operand
+[[term.unevaluated.operand]].
 [*Example 1*:
 ``` cpp
 const int&& foo();
                                 // for the temporary introduced by the use of h().
                                 // (A temporary is not introduced as a result of the use of i().)
 template<class T> auto f(T)     // #2
   -> void;
 auto g() -> void {
+  f(42);                        // OK, calls #2. (#1 is not a viable candidate: type deduction
                                 // fails[temp.deduct] because A<int>::~A() is implicitly used in its
                                 // decltype-specifier)
 }
 template<class T> auto q(T)
   -> decltype((h<T>()));        // does not force completion of A<T>; A<T>::~A() is not implicitly
 — *end example*]
 #### Placeholder type specifiers <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
+##### General <a id="dcl.spec.auto.general">[[dcl.spec.auto.general]]</a>
 ``` bnf
 placeholder-type-specifier:
   type-constraintₒₚₜ auto
   type-constraintₒₚₜ decltype '(' auto ')'
 ```
 [*Note 1*: Having a generic parameter type placeholder signifies that
 the function is an abbreviated function template [[dcl.fct]] or the
 lambda is a generic lambda [[expr.prim.lambda]]. — *end note*]
+A placeholder type can appear with a function declarator in the
 *decl-specifier-seq*, *type-specifier-seq*, *conversion-function-id*, or
 *trailing-return-type*, in any context where such a declarator is valid.
 If the function declarator includes a *trailing-return-type*
 [[dcl.fct]], that *trailing-return-type* specifies the declared return
 type of the function. Otherwise, the function declarator shall declare a
 The type of a variable declared using a placeholder type is deduced from
 its initializer. This use is allowed in an initializing declaration
 [[dcl.init]] of a variable. The placeholder type shall appear as one of
 the *decl-specifier*s in the *decl-specifier-seq* and the
 *decl-specifier-seq* shall be followed by one or more *declarator*s,
+each of which shall be followed by a non-empty *initializer*.
 [*Example 1*:
 ``` cpp
+auto x = 5;                     // OK, x has type int
+const auto *v = &x, u = 6;      // OK, v has type const int*, u has type const int
+static auto y = 0.0;            // OK, y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
+auto f() -> int;                // OK, f returns int
+auto g() { return 0.0; }        // OK, g returns double
+auto h();                       // OK, h's return type will be deduced when it is defined
 ```
 — *end example*]
 The `auto` *type-specifier* can also be used to introduce a structured
 binding declaration [[dcl.struct.bind]].
 A placeholder type can also be used in the *type-specifier-seq* in the
 *new-type-id* or *type-id* of a *new-expression* [[expr.new]] and as a
 *decl-specifier* of the *parameter-declaration*'s *decl-specifier-seq*
+in a *template-parameter* [[temp.param]]. The `auto` *type-specifier*
+can also be used as the *simple-type-specifier* in an explicit type
+conversion (functional notation) [[expr.type.conv]].
 A program that uses a placeholder type in a context not explicitly
+allowed in [[dcl.spec.auto]] is ill-formed.
 If the *init-declarator-list* contains more than one *init-declarator*,
 they shall all form declarations of variables. The type of each declared
 variable is determined by placeholder type deduction
 [[dcl.type.auto.deduct]], and if the type that replaces the placeholder
 type is not the same in each deduction, the program is ill-formed.
 [*Example 2*:
 ``` cpp
+auto x = 5, *y = &x;            // OK, auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
 — *end example*]
 declaration, outside the *private-module-fragment* (if any).
 [*Note 2*: The deduced return type cannot have a name with internal
 linkage [[basic.link]]. — *end note*]
+If a variable or function with an undeduced placeholder type is named by
+an expression [[basic.def.odr]], the program is ill-formed. Once a
+non-discarded `return` statement has been seen in a function, however,
+the return type deduced from that statement can be used in the rest of
+the function, including in other `return` statements.
 [*Example 4*:
 ``` cpp
 auto n = n;                     // error: n's initializer refers to n
 }
 ```
 — *end example*]
+Return type deduction for a templated function with a placeholder in its
+declared type occurs when the definition is instantiated even if the
+function body contains a `return` statement with a non-type-dependent
+operand.
 [*Note 3*: Therefore, any use of a specialization of the function
 template will cause an implicit instantiation. Any errors that arise
 from this instantiation are not in the immediate context of the function
 type and can result in the program being ill-formed
                                                 // chooses second
 ```
 — *end example*]
+If a function or function template F has a declared return type that
+uses a placeholder type, redeclarations or specializations of F shall
+use that placeholder type, not a deduced type; otherwise, they shall not
+use a placeholder type.
 [*Example 6*:
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
+int f();                                        // error: auto and int don't match
 decltype(auto) f();                             // error: auto and decltype(auto) don't match
 template <typename T> auto g(T t) { return t; } // #1
 template auto g(int);                           // OK, return type is int
 template char g(char);                          // error: no matching template
 *Placeholder type deduction* is the process by which a type containing a
 placeholder type is replaced by a deduced type.
 A type `T` containing a placeholder type, and a corresponding
+*initializer-clause* E, are determined as follows:
+- For a non-discarded `return` statement that occurs in a function
   declared with a return type that contains a placeholder type, `T` is
+  the declared return type.
+ - If the `return` statement has no operand, then E is `void()`.
+ - If the operand is a *braced-init-list* [[dcl.init.list]], the
+    program is ill-formed.
+ - If the operand is an *expression* X that is not an
+    *assignment-expression*, E is `(X)`. \[*Note 4*: A comma expression
+    [[expr.comma]] is not an *assignment-expression*. — *end note*]
+  - Otherwise, E is the operand of the `return` statement.
+  If E has type `void`, `T` shall be either *type-constraint*ₒₚₜ
+  `decltype(auto)` or cv *type-constraint*ₒₚₜ  `auto`.
+- For a variable declared with a type that contains a placeholder type,
+  `T` is the declared type of the variable.
+  - If the initializer of the variable is a *brace-or-equal-initializer*
+    of the form `= initializer-clause`, E is the *initializer-clause*.
+  - If the initializer is a *braced-init-list*, it shall consist of a
+    single brace-enclosed *assignment-expression* and E is the
+    *assignment-expression*.
+  - If the initializer is a parenthesized *expression-list*, the
+    *expression-list* shall be a single *assignment-expression* and E is
+    the *assignment-expression*.
+- For an explicit type conversion [[expr.type.conv]], `T` is the
+  specified type, which shall be `auto`.
+  - If the initializer is a *braced-init-list*, it shall consist of a
+    single brace-enclosed *assignment-expression* and E is the
+    *assignment-expression*.
+  - If the initializer is a parenthesized *expression-list*, the
+    *expression-list* shall be a single *assignment-expression* and E is
+    the *assignment-expression*.
+- For a non-type template parameter declared with a type that contains a
   placeholder type, `T` is the declared type of the non-type template
   parameter and E is the corresponding template argument.
+`T` shall not be an array type.
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `auto`, the deduced type T' replacing `T` is determined using the rules
+for template argument deduction. If the initialization is
+copy-list-initialization, a declaration of `std::initializer_list` shall
+precede [[basic.lookup.general]] the *placeholder-type-specifier*.
+Obtain `P` from `T` by replacing the occurrences of
+*type-constraint*ₒₚₜ  `auto` either with a new invented type template
+parameter `U` or, if the initialization is copy-list-initialization,
+with `std::initializer_list<U>`. Deduce a value for `U` using the rules
+of template argument deduction from a function call
+[[temp.deduct.call]], where `P` is a function template parameter type
+and the corresponding argument is E. If the deduction fails, the
+declaration is ill-formed. Otherwise, T' is obtained by substituting the
+deduced `U` into `P`.
 [*Example 8*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
 — *end example*]
 If the *placeholder-type-specifier* is of the form *type-constraint*ₒₚₜ
 `decltype(auto)`, `T` shall be the placeholder alone. The type deduced
+for `T` is determined as described in  [[dcl.type.decltype]], as though
+E had been the operand of the `decltype`.
 [*Example 10*:
 ``` cpp
 int i;
 decltype(auto) x5d = f();       // decltype(x5d) is int&&
 auto           x6a = { 1, 2 };  // decltype(x6a) is std::initializer_list<int>
 decltype(auto) x6d = { 1, 2 };  // error: { 1, 2 } is not an expression
 auto          *x7a = &i;        // decltype(x7a) is int*
 decltype(auto)*x7d = &i;        // error: declared type is not plain decltype(auto)
+auto f1(int x) -> decltype((x)) { return (x); }         // return type is int&
+auto f2(int x) -> decltype(auto) { return (x); }        // return type is int&&
 ```
 — *end example*]
 For a *placeholder-type-specifier* with a *type-constraint*, the
 — *end example*]
 ## 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
 — *end example*]
 ## Initializers <a id="dcl.init">[[dcl.init]]</a>
+### General <a id="dcl.init.general">[[dcl.init.general]]</a>
+The process of initialization described in [[dcl.init]] applies to all
 initializations regardless of syntactic context, including the
 initialization of a function parameter [[expr.call]], the initialization
 of a return value [[stmt.return]], or when an initializer follows a
 declarator.
 expr-or-braced-init-list:
     expression
     braced-init-list
 ```
+[*Note 1*: The rules in [[dcl.init]] apply even if the grammar permits
+only the *brace-or-equal-initializer* form of *initializer* in a given
+context. — *end note*]
 Except for objects declared with the `constexpr` specifier, for which
 see  [[dcl.constexpr]], an *initializer* in the definition of a variable
 can consist of arbitrary expressions involving literals and previously
 declared variables and functions, regardless of the variable’s storage
 [*Note 3*: The order of initialization of variables with static storage
 duration is described in  [[basic.start]] and
 [[stmt.dcl]]. — *end note*]
+A declaration D of a variable with linkage shall not have an
+*initializer* if D inhabits a block scope.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is a scalar type [[term.scalar.type]], the object is
+ initialized to the value obtained by converting the integer literal
+  `0` (zero) to `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
+  bits [[term.padding.bits]] are initialized to zero bits and each
+ non-static data member, each non-virtual base class subobject, and, if
+ the object is not a base class subobject, each virtual base class
+ subobject is zero-initialized;
 - if `T` is a (possibly cv-qualified) union type, its padding bits
+  [[term.padding.bits]] are initialized to zero bits and the object’s
+ first non-static named data member is zero-initialized;
 - if `T` is an array type, each element is zero-initialized;
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 [*Note 4*: For every object of static storage duration, static
 initialization [[basic.start.static]] is performed at program startup
 before any other initialization takes place. In some cases, additional
 initialization is done later. — *end note*]
 If no initializer is specified for an object, the object is
 default-initialized.
 If the entity being initialized does not have class type, the
 *expression-list* in a parenthesized initializer shall be a single
 expression.
 The initialization that occurs in the `=` form of a
 *brace-or-equal-initializer* or *condition* [[stmt.select]], as well as
 in argument passing, function return, throwing an exception
 [[except.throw]], handling an exception [[except.handle]], and aggregate
+member initialization other than by a *designated-initializer-clause*
+[[dcl.init.aggr]], is called *copy-initialization*.
+[*Note 5*: Copy-initialization can invoke a move
 [[class.copy.ctor]]. — *end note*]
 The initialization that occurs
 - for an *initializer* that is a parenthesized *expression-list* or a
 - If the destination type is an array of characters, an array of
   `char8_t`, an array of `char16_t`, an array of `char32_t`, or an array
   of `wchar_t`, and the initializer is a *string-literal*, see
   [[dcl.init.string]].
 - If the initializer is `()`, the object is value-initialized.
+  \[*Note 6*:
+  Since `()` is not permitted by the syntax for *initializer*,
+  ``` cpp
+  X a();
+  ```
+  is not the declaration of an object of class `X`, but the declaration
+  of a function taking no arguments and returning an `X`. The form `()`
+  is permitted in certain other initialization contexts
+  [[expr.new]], [[expr.type.conv]], [[class.base.init]].
+  — *end note*]
 - Otherwise, if the destination type is an array, the object is
   initialized as follows. Let x₁, …, xₖ be the elements of the
   *expression-list*. If the destination type is an array of unknown
   bound, it is defined as having k elements. Let n denote the array size
   after this potential adjustment. If k is greater than n, the program
 - Otherwise, if the destination type is a (possibly cv-qualified) class
   type:
   - If the initializer expression is a prvalue and the cv-unqualified
     version of the source type is the same class as the class of the
     destination, the initializer expression is used to initialize the
+    destination object. \[*Example 2*: `T x = T(T(T()));`
+ value-initializes `x`. — *end example*]
   - Otherwise, if the initialization is direct-initialization, or if it
     is copy-initialization where the cv-unqualified version of the
     source type is the same class as, or a derived class of, the class
     of the destination, constructors are considered. The applicable
     constructors are enumerated [[over.match.ctor]], and the best one is
       \[*Note 7*:
       By contrast with direct-list-initialization, narrowing conversions
       [[dcl.init.list]] are permitted, designators are not permitted, a
       temporary object bound to a reference does not have its lifetime
       extended [[class.temporary]], and there is no brace elision.
+      \[*Example 3*:
       ``` cpp
       struct A {
         int a;
         int&& r;
       };
   int c = b;
   ```
   — *end note*]
+An immediate invocation [[expr.const]] that is not evaluated where it
+appears [[dcl.fct.default]], [[class.mem.general]] is evaluated and
+checked for whether it is a constant expression at the point where the
+enclosing *initializer* is used in a function call, a constructor
+definition, or an aggregate initialization.
 An *initializer-clause* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
+Initialization includes the evaluation of all subexpressions of each
+*initializer-clause* of the initializer (possibly nested within
+*braced-init-list*s) and the creation of any temporary objects for
+function arguments or return values [[class.temporary]].
 If the initializer is a parenthesized *expression-list*, the expressions
 are evaluated in the order specified for function calls [[expr.call]].
 The same *identifier* shall not appear in multiple *designator*s of a
 *designated-initializer-list*.
 from an explicit initializer or by default-initialization, is called the
 *initializing declaration* of that variable.
 [*Note 10*: In most cases this is the defining declaration
 [[basic.def]] of the variable, but the initializing declaration of a
+non-inline static data member [[class.static.data]] can be the
+declaration within the class definition and not the definition (if any)
+outside it. — *end note*]
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class [[class]] with
 - no user-declared or inherited constructors [[class.ctor]],
 - no private or protected direct non-static data members
   [[class.access]],
+- no private or protected direct base classes [[class.access.base]], and
+- no virtual functions [[class.virtual]] or virtual base classes
+  [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
 and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
 When an aggregate is initialized by an initializer list as specified in
 [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the elements of the aggregate. The *explicitly
 initialized elements* of the aggregate are determined as follows:
+- If the initializer list is a brace-enclosed
+ *designated-initializer-list*, the aggregate shall be of class type,
+ the *identifier* in each *designator* shall name a direct non-static
+ data member of the class, and the explicitly initialized elements of
+ the aggregate are the elements that are, or contain, those members.
+- If the initializer list is a brace-enclosed *initializer-list*, the
+ explicitly initialized elements of the aggregate are the first n
+ elements of the aggregate, where n is the number of elements in the
+  initializer list.
 - Otherwise, the initializer list must be `{}`, and there are no
   explicitly initialized elements.
 For each explicitly initialized element:
+- If the element is an anonymous union member and the initializer list
+  is a brace-enclosed *designated-initializer-list*, the element is
+  initialized by the *braced-init-list* `{ `*D*` }`, where *D* is the
+  *designated-initializer-clause* naming a member of the anonymous union
+ member. There shall be only one such *designated-initializer-clause*.
   \[*Example 1*:
   ``` cpp
   struct C {
     union {
       int a;
   *brace-or-equal-initializer* of the corresponding
   *designated-initializer-clause*. If that initializer is of the form
   *assignment-expression* or `= `*assignment-expression* and a narrowing
   conversion [[dcl.init.list]] is required to convert the expression,
   the program is ill-formed.
+  \[*Note 2*: If the initialization is by
+  *designated-initializer-clause*, its form determines whether
+  copy-initialization or direct-initialization is
+  performed. — *end note*]
+  \[*Note 3*: If an initializer is itself an initializer list, the
   element is list-initialized, which will result in a recursive
   application of the rules in this subclause if the element is an
   aggregate. — *end note*]
   \[*Example 2*:
   ``` cpp
 The destructor for each element of class type is potentially invoked
 [[class.dtor]] from the context where the aggregate initialization
 occurs.
+[*Note 4*: This provision ensures that destructors can be called for
 fully-constructed subobjects in case an exception is thrown
 [[except.ctor]]. — *end note*]
 An array of unknown bound initialized with a brace-enclosed
 *initializer-list* containing `n` *initializer-clause*s is defined as
 — *end example*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
+[*Note 5*:
 A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
 if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
 — *end example*]
 — *end note*]
+[*Note 6*:
 Static data members, non-static data members of anonymous union members,
 and unnamed bit-fields are not considered elements of the aggregate.
 [*Example 6*:
 };                  // Initialization not required for A::s3 because A::i3 is also not initialized
 ```
 — *end example*]
+When initializing a multidimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest [[dcl.array]].
 [*Example 10*:
 *assignment-expression* can initialize an element, the element is
 initialized. Otherwise, if the element is itself a subaggregate, brace
 elision is assumed and the *assignment-expression* is considered for the
 initialization of the first element of the subaggregate.
+[*Note 7*: As specified above, brace elision cannot apply to
 subaggregates with no elements; an *initializer-clause* for the entire
 subobject is required. — *end note*]
 [*Example 12*:
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
+[*Note 8*: An aggregate array or an aggregate class can contain
 elements of a class type with a user-declared constructor
 [[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
+[*Note 9*: Whether the initialization of aggregates with static storage
 duration is static or dynamic is specified in  [[basic.start.static]],
 [[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
 When a union is initialized with an initializer list, there shall not be
 more than one explicitly initialized element.
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
+[*Note 10*: As described above, the braces around the
 *initializer-clause* for a union member can be omitted if the union is a
 member of another aggregate. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 An array of ordinary character type [[basic.fundamental]], `char8_t`
+array, `char16_t` array, `char32_t` array, or `wchar_t` array may be
 initialized by an ordinary string literal, UTF-8 string literal, UTF-16
 string literal, UTF-32 string literal, or wide string literal,
 respectively, or by an appropriately-typed *string-literal* enclosed in
+braces [[lex.string]]. Additionally, an array of `char` or
+`unsigned char` may be initialized by a UTF-8 string literal, or by such
+a string literal enclosed in braces. Successive characters of the value
+of the *string-literal* initialize the elements of the array, with an
+integral conversion [[conv.integral]] if necessary for the source and
+destination value.
 [*Example 1*:
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 element not explicitly initialized shall be zero-initialized
 [[dcl.init]].
 ### References <a id="dcl.init.ref">[[dcl.init.ref]]</a>
+A variable whose declared type is “reference to `T`” [[dcl.ref]] shall
+be initialized.
 [*Example 1*:
 ``` cpp
 int g(int) noexcept;
     “*cv3* `T3`”, where “*cv1* `T1`” is reference-compatible with “*cv3*
     `T3`”[^7] (this conversion is selected by enumerating the applicable
     conversion functions [[over.match.ref]] and choosing the best one
     through overload resolution [[over.match]]),
+  then the reference binds to the initializer expression lvalue in the
+  first case and to the lvalue result of the conversion in the second
+  case (or, in either case, to the appropriate base class subobject of
+  the object).
   \[*Note 2*: The usual lvalue-to-rvalue [[conv.lval]], array-to-pointer
   [[conv.array]], and function-to-pointer [[conv.func]] standard
   conversions are not needed, and therefore are suppressed, when such
   direct bindings to lvalues are done. — *end note*]
   \[*Example 3*:
   - has a class type (i.e., `T2` is a class type), where `T1` is not
     reference-related to `T2`, and can be converted to an rvalue or
     function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
     reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
+  then the initializer expression in the first case and the converted
+ expression in the second case is called the converted initializer. If
+  the converted initializer is a prvalue, its type `T4` is adjusted to
+  type “*cv1* `T4`” [[conv.qual]] and the temporary materialization
+  conversion [[conv.rval]] is applied. In any case, the reference binds
+  to the resulting glvalue (or to an appropriate base class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
+  const A& rca2 = f();                // binds to the A subobject of the B rvalue.
   A&& rra = f();                      // same as above
   struct X {
     operator B();
     operator int&();
   } x;
+  const A& r = x;                     // binds to the A subobject of the result of the conversion
   int i2 = 42;
+  int&& rri = static_cast<int&&>(i2); // binds directly to i2
+  B&& rrb = x;                        // binds directly to the result of operator B
   ```
   — *end example*]
 - Otherwise:
   - If `T1` or `T2` is a class type and `T1` is not reference-related to
     `T2`, user-defined conversions are considered using the rules for
     copy-initialization of an object of type “*cv1* `T1`” by
+    user-defined conversion
+    [[dcl.init]], [[over.match.copy]], [[over.match.conv]]; the program
+ is ill-formed if the corresponding non-reference copy-initialization
+ would be ill-formed. The result of the call to the conversion
+ function, as described for the non-reference copy-initialization, is
+ then used to direct-initialize the reference. For this
+ direct-initialization, user-defined conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
+    prvalue of type “`T1`”. The temporary materialization conversion is
+    applied, considering the type of the prvalue to be “*cv1* `T1`”, and
+    the reference is bound to the result.
   If `T1` is reference-related to `T2`:
   - *cv1* shall be the same cv-qualification as, or greater
     cv-qualification than, *cv2*; and
   - if the reference is an rvalue reference, the initializer expression
+    shall not be an lvalue. \[*Note 3*: This can be affected by whether
+    the initializer expression is move-eligible
+    [[expr.prim.id.unqual]]. — *end note*]
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
+[*Note 4*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 - as the initializer in a *new-expression* [[expr.new]]
 - in a `return` statement [[stmt.return]]
 - as a *for-range-initializer* [[stmt.iter]]
 - as a function argument [[expr.call]]
 - as a subscript [[expr.sub]]
+- as an argument to a constructor invocation
+  [[dcl.init]], [[expr.type.conv]]
 - as an initializer for a non-static data member [[class.mem]]
 - in a *mem-initializer* [[class.base.init]]
 - on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
 `template<class T> C(T)` of a class `C` does not create an
 initializer-list constructor, because an initializer list argument
 causes the corresponding parameter to be a non-deduced context
 [[temp.deduct.call]]. — *end note*]
+The template `std::initializer_list` is not predefined; if a standard
+library declaration [[initializer.list.syn]], [[std.modules]] of
+`std::initializer_list` is not reachable from [[module.reach]] a use of
 `std::initializer_list` — even an implicit use in which the type is not
 named [[dcl.spec.auto]] — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
     int m1;
     double m2, m3;
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
+  S2 s23 { };                         // OK, default to 0,0,0
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements and `T` is a class
   type with a default constructor, the object is value-initialized.
 - Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
   the object is constructed as described below.
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
+  through overload resolution [[over.match]], [[over.match.list]]. If a
+  narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     // no initializer-list constructors
     S(int, double, double);           // #1
     S();                              // #2
     // ...
   };
+  S s1 = { 1, 2, 3.0 };               // OK, invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
+  S s3 { };                           // OK, invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
   [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
   int x2 {2.0};                       // error: narrowing
   ```
   — *end example*]
 - Otherwise, if `T` is a reference type, a prvalue is generated. The
+  prvalue initializes its result object by copy-list-initialization from
+ the initializer list. The prvalue is then used to direct-initialize
+  the reference. The type of the prvalue is the type referenced by `T`,
+ unless `T` is “reference to array of unknown bound of `U`”, in which
+ case the type of the prvalue is the type of `x` in the declaration
+ `U x[] H`, where H is the initializer list.
   \[*Note 3*: As usual, the binding will fail and the program is
   ill-formed if the reference type is an lvalue reference to a non-const
   type. — *end note*]
   \[*Example 9*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   };
+  const S& r1 = { 1, 2, 3.0 };        // OK, invoke #1
+  const S& r2 { "Spinach" };          // OK, invoke #2
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
+  const int (&iar)[2] = { 1, 2 };     // OK, iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 [*Note 6*: The implementation is free to allocate the array in
+read-only memory if an explicit array with the same initializer can be
 so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
+- from a floating-point type `T` to another floating-point type whose
+ floating-point conversion rank is neither greater than nor equal to
+  that of `T`, except where the source is a constant expression and the
   actual value after conversion is within the range of values that can
   be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where
+  - the source is a bit-field whose width w is less than that of its
+    type (or, for an enumeration type, its underlying type) and the
+    target type can represent all the values of a hypothetical extended
+    integer type with width w and with the same signedness as the
+    original type or
+  - the source is a constant expression whose value after integral
     promotions will fit into the target type, or
 - from a pointer type or a pointer-to-member type to `bool`.
 [*Note 7*: As indicated above, such conversions are not allowed at the
 top level in list-initializations. — *end note*]
 ``` cpp
 int x = 999;                    // x is not a constant expression
 const int y = 999;
 const int z = 99;
+char c1 = x;                    // OK, though it potentially narrows (in this case, it does narrow)
+char c2{x};                     // error: potentially narrows
 char c3{y};                     // error: narrows (assuming char is 8 bits)
+char c4{z};                     // OK, no narrowing needed
+unsigned char uc1 = {5};        // OK, no narrowing needed
 unsigned char uc2 = {-1};       // error: narrows
 unsigned int ui1 = {-1};        // error: narrows
 signed int si1 =
   { (unsigned int)-1 };         // error: narrows
 int ii = {2.0};                 // error: narrows
+float f1 { x };                 // error: potentially narrows
+float f2 { 7 };                 // OK, 7 can be exactly represented as a float
 bool b = {"meow"};              // error: narrows
 int f(int);
+int a[] = { 2, f(2), f(2.0) };  // OK, the double-to-int conversion is not at the top level
 ```
 — *end example*]
 ## Function definitions <a id="dcl.fct.def">[[dcl.fct.def]]</a>
 A *ctor-initializer* is used only in a constructor; see  [[class.ctor]]
 and  [[class.init]].
 [*Note 1*: A *cv-qualifier-seq* affects the type of `this` in the body
+of a member function; see  [[expr.prim.this]]. — *end note*]
 [*Note 2*:
 Unused parameters need not be named. For example,
 }
 ```
 — *end note*]
+A *function-local predefined variable* is a variable with static storage
+duration that is implicitly defined in a function parameter scope.
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
 - be a special member function or a comparison operator function
   [[over.binary]], and
 - not have default arguments.
+An explicitly defaulted special member function `F₁` is allowed to
+differ from the corresponding special member function `F₂` that would
+have been implicitly declared, as follows:
+- `F₁` and `F₂` may have differing *ref-qualifier*s;
+- if `F₂` has an implicit object parameter of type “reference to `C`”,
+ `F₁` may be an explicit object member function whose explicit object
+  parameter is of type “reference to `C`”, in which case the type of
+  `F₁` would differ from the type of `F₂` in that the type of `F₁` has
+  an additional parameter;
+- `F₁` and `F₂` may have differing exception specifications; and
+- if `F₂` has a non-object parameter of type `const C&`, the
+  corresponding non-object parameter of `F₁` may be of type `C&`.
+If the type of `F₁` differs from the type of `F₂` in a way other than as
+allowed by the preceding rules, then:
+- if `F₁` is an assignment operator, and the return type of `F₁` differs
+  from the return type of `F₂` or `F₁`’s non-object parameter type is
+ not a reference, the program is ill-formed;
+- otherwise, if `F₁` is explicitly defaulted on its first declaration,
+ it is defined as deleted;
 - otherwise, the program is ill-formed.
+A function explicitly defaulted on its first declaration is implicitly
+inline [[dcl.inline]], and is implicitly constexpr [[dcl.constexpr]] if
+it is constexpr-suitable.
 [*Example 1*:
 ``` cpp
 struct S {
   S(int a = 0) = default;               // error: default argument
   void operator=(const S&) = default;   // error: non-matching return type
   ~S() noexcept(false) = default;       // OK, despite mismatched exception specification
 private:
   int i;
+  S(S&);                                // OK, private copy constructor
 };
+S::S(S&) = default;                     // OK, defines copy constructor
 struct T {
   T();
   T(T &&) noexcept(false);
 };
 — *end example*]
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
+provide implicit definitions for them
+[[class.ctor]], [[class.dtor]], [[class.copy.ctor]], [[class.copy.assign]]
+as described below, including possibly defining them as deleted. A
+defaulted prospective destructor [[class.dtor]] that is not a destructor
+is defined as deleted. A defaulted special member function that is
+neither a prospective destructor nor an eligible special member function
+[[special]] is defined as deleted. A function is *user-provided* if it
+is user-declared and not explicitly defaulted or deleted on its first
+declaration. A user-provided explicitly-defaulted function (i.e.,
+explicitly defaulted after its first declaration) is implicitly defined
+at the point where it is explicitly defaulted; if such a function is
+implicitly defined as deleted, the program is ill-formed. A
+non-user-provided defaulted function (i.e., implicitly declared or
+explicitly defaulted in the class) that is not defined as deleted is
+implicitly defined when it is odr-used [[basic.def.odr]] or needed for
+constant evaluation [[expr.const]].
 [*Note 1*: Declaring a function as defaulted after its first
 declaration can provide efficient execution and concise definition while
 enabling a stable binary interface to an evolving code
 base. — *end note*]
 — *end example*]
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
+A *deleted definition* of a function is a function definition whose
+*function-body* is of the form `= delete ;` or an explicitly-defaulted
+definition of the function where the function is defined as deleted. A
+*deleted function* is a function with a deleted definition or a function
+that is implicitly defined as deleted.
 A program that refers to a deleted function implicitly or explicitly,
 other than to declare it, is ill-formed.
 [*Note 1*: This includes calling the function implicitly or explicitly
 and forming a pointer or pointer-to-member to the function. It applies
 even for references in expressions that are not potentially-evaluated.
+For an overload set, only the function selected by overload resolution
+is referenced. The implicit odr-use [[term.odr.use]] of a virtual
+function does not, by itself, constitute a reference. — *end note*]
 [*Example 1*:
 One can prevent default initialization and initialization by
 non-`double`s with
 — *end example*]
 The *promise type* of a coroutine is
 `std::coroutine_traits<R, P₁, …, Pₙ>::promise_type`, where `R` is the
+return type of the function, and `P₁` … `Pₙ` is the sequence of types of
+the non-object function parameters, preceded by the type of the object
+parameter [[dcl.fct]] if the coroutine is a non-static member function.
+The promise type shall be a class type.
+In the following, `pᵢ` is an lvalue of type `Pᵢ`, where `p₁` denotes the
+object parameter and `p_i+1` denotes the iᵗʰ non-object function
+parameter for a non-static member function, and `pᵢ` denotes the iᵗʰ
+function parameter otherwise. For a non-static member function, `q₁` is
+an lvalue that denotes `*this`; any other `qᵢ` is an lvalue that denotes
+the parameter copy corresponding to `pᵢ`, as described below.
 A coroutine behaves as if its *function-body* were replaced by:
 ``` bnf
 '{'
 ```
 where
 - the *await-expression* containing the call to `initial_suspend` is the
+  *initial await expression*, and
 - the *await-expression* containing the call to `final_suspend` is the
+  *final await expression*, and
 - *initial-await-resume-called* is initially `false` and is set to
   `true` immediately before the evaluation of the *await-resume*
+  expression [[expr.await]] of the initial await expression, and
 - *promise-type* denotes the promise type, and
 - the object denoted by the exposition-only name *`promise`* is the
   *promise object* of the coroutine, and
 - the label denoted by the name *`final-suspend`* is defined for
   exposition only [[stmt.return.coroutine]], and
 - *promise-constructor-arguments* is determined as follows: overload
   resolution is performed on a promise constructor call created by
+  assembling an argument list `q₁` … `qₙ`. If a viable constructor is
+  found [[over.match.viable]], then *promise-constructor-arguments* is
+  `(q₁, …, qₙ)`, otherwise *promise-constructor-arguments* is empty, and
+- a coroutine is suspended at the *initial suspend point* if it is
+  suspended at the initial await expression, and
+- a coroutine is suspended at a *final suspend point* if it is suspended
+  - at a final await expression or
+  - due to an exception exiting from `unhandled_exception()`.
+If searches for the names `return_void` and `return_value` in the scope
+of the promise type each find any declarations, the program is
 ill-formed.
+[*Note 1*: If `return_void` is found, flowing off the end of a
+coroutine is equivalent to a `co_return` with no operand. Otherwise,
+flowing off the end of a coroutine results in undefined behavior
+[[stmt.return.coroutine]]. — *end note*]
 The expression `promise.get_return_object()` is used to initialize the
+returned reference or prvalue result object of a call to a coroutine.
+The call to `get_return_object` is sequenced before the call to
 `initial_suspend` and is invoked at most once.
 A suspended coroutine can be resumed to continue execution by invoking a
 resumption member function [[coroutine.handle.resumption]] of a
 coroutine handle [[coroutine.handle]] that refers to the coroutine. The
+evaluation that invoked a resumption member function is called the
 *resumer*. Invoking a resumption member function for a coroutine that is
 not suspended results in undefined behavior.
 An implementation may need to allocate additional storage for a
 coroutine. This storage is known as the *coroutine state* and is
 obtained by calling a non-array allocation function
 [[basic.stc.dynamic.allocation]]. The allocation function’s name is
+looked up by searching for it in the scope of the promise type.
+- If the search finds any declarations, overload resolution is performed
+  on a function call created by assembling an argument list. The first
+  argument is the amount of space requested, and is a prvalue of type
+  `std::size_t`. The lvalues `p₁` … `pₙ` are the successive arguments.
+  If no viable function is found [[over.match.viable]], overload
+  resolution is performed again on a function call created by passing
+  just the amount of space required as a prvalue of type `std::size_t`.
+- If the search finds no declarations, a search is performed in the
+  global scope. Overload resolution is performed on a function call
+  created by passing the amount of space required as a prvalue of type
+  `std::size_t`.
+If a search for the name `get_return_object_on_allocation_failure` in
+the scope of the promise type [[class.member.lookup]] finds any
+declarations, then the result of a call to an allocation function used
+to obtain storage for the coroutine state is assumed to return `nullptr`
+if it fails to obtain storage, and if a global allocation function is
+selected, the `::operator new(size_t, nothrow_t)` form is used. The
+allocation function used in this case shall have a non-throwing
+*noexcept-specifier*. If the allocation function returns `nullptr`, the
+coroutine returns control to the caller of the coroutine and the return
+value is obtained by a call to
 `T::get_return_object_on_allocation_failure()`, where `T` is the promise
 type.
 [*Example 2*:
   struct promise_type {
     int current_value;
     static auto get_return_object_on_allocation_failure() { return generator{nullptr}; }
     auto get_return_object() { return generator{handle::from_promise(*this)}; }
     auto initial_suspend() { return std::suspend_always{}; }
+    auto final_suspend() noexcept { return std::suspend_always{}; }
     void unhandled_exception() { std::terminate(); }
     void return_void() {}
     auto yield_value(int value) {
       current_value = value;
       return std::suspend_always{};
 The coroutine state is destroyed when control flows off the end of the
 coroutine or the `destroy` member function
 [[coroutine.handle.resumption]] of a coroutine handle
 [[coroutine.handle]] that refers to the coroutine is invoked. In the
+latter case, control in the coroutine is considered to be transferred
+out of the function [[stmt.dcl]]. The storage for the coroutine state is
+released by calling a non-array deallocation function
+[[basic.stc.dynamic.deallocation]]. If `destroy` is called for a
+coroutine that is not suspended, the program has undefined behavior.
+The deallocation function’s name is looked up by searching for it in the
+scope of the promise type. If nothing is found, a search is performed in
+the global scope. If both a usual deallocation function with only a
+pointer parameter and a usual deallocation function with both a pointer
+parameter and a size parameter are found, then the selected deallocation
+function shall be the one with two parameters. Otherwise, the selected
+deallocation function shall be the function with one parameter. If no
+usual deallocation function is found, the program is ill-formed. The
+selected deallocation function shall be called with the address of the
+block of storage to be reclaimed as its first argument. If a
+deallocation function with a parameter of type `std::size_t` is used,
+the size of the block is passed as the corresponding argument.
 When a coroutine is invoked, after initializing its parameters
 [[expr.call]], a copy is created for each coroutine parameter. For a
 parameter of type cv `T`, the copy is a variable of type cv `T` with
 automatic storage duration that is direct-initialized from an xvalue of
 parameter has ended is likely to result in undefined
 behavior. — *end note*]
 If the evaluation of the expression `promise.unhandled_exception()`
 exits via an exception, the coroutine is considered suspended at the
+final suspend point and the exception propagates to the caller or
+resumer.
 The expression `co_await` `promise.final_suspend()` shall not be
 potentially-throwing [[except.spec]].
 ## Structured binding declarations <a id="dcl.struct.bind">[[dcl.struct.bind]]</a>
 A structured binding declaration introduces the *identifier*s `v₀`,
+`v₁`, `v₂`, … of the *identifier-list* as names of *structured
+binding*s. Let cv denote the *cv-qualifier*s in the *decl-specifier-seq*
+and *S* consist of the *storage-class-specifier*s of the
+*decl-specifier-seq* (if any). A cv that includes `volatile` is
+deprecated; see  [[depr.volatile.type]]. First, a variable with a unique
+name *`e`* is introduced. If the *assignment-expression* in the
+*initializer* has array type *cv1* `A` and no *ref-qualifier* is
+present, *`e`* is defined by
 ``` bnf
 attribute-specifier-seqₒₚₜ *S* cv 'A' e ';'
 ```
 If the *initializer* refers to one of the names introduced by the
 structured binding declaration, the program is ill-formed.
 If `E` is an array type with element type `T`, the number of elements in
 the *identifier-list* shall be equal to the number of elements of `E`.
+Each `vᵢ` is the name of an lvalue that refers to the element i of the
 array and whose type is `T`; the referenced type is `T`.
 [*Note 2*: The top-level cv-qualifiers of `T` are cv. — *end note*]
 [*Example 1*:
 Otherwise, if the *qualified-id* `std::tuple_size<E>` names a complete
 class type with a member named `value`, the expression
 `std::tuple_size<E>::value` shall be a well-formed integral constant
 expression and the number of elements in the *identifier-list* shall be
 equal to the value of that expression. Let `i` be an index prvalue of
+type `std::size_t` corresponding to `vᵢ`. If a search for the name `get`
+in the scope of `E` [[class.member.lookup]] finds at least one
+declaration that is a function template whose first template parameter
+is a non-type parameter, the initializer is `e.get<i>()`. Otherwise, the
+initializer is `get<i>(e)`, where `get` undergoes argument-dependent
+lookup [[basic.lookup.argdep]]. In either case, `get<i>` is interpreted
+as a *template-id*.
 [*Note 3*: Ordinary unqualified lookup [[basic.lookup.unqual]] is not
 performed. — *end note*]
 In either case, *`e`* is an lvalue if the type of the entity *`e`* is an
 of `E` or of the same base class of `E`, well-formed when named as
 `e.name` in the context of the structured binding, `E` shall not have an
 anonymous union member, and the number of elements in the
 *identifier-list* shall be equal to the number of non-static data
 members of `E`. Designating the non-static data members of `E` as `m₀`,
+`m₁`, `m₂`, … (in declaration order), each `vᵢ` is the name of an lvalue
+that refers to the member `m`ᵢ of *`e`* and whose type is that of `e.mᵢ`
+[[expr.ref]]; the referenced type is the declared type of `mᵢ` if that
+type is a reference type, or the type of `e.mᵢ` otherwise. The lvalue is
+a bit-field if that member is a bit-field.
 [*Example 2*:
 ``` cpp
+struct S { mutable int x1 : 2; volatile double y1; };
 S f();
 const auto [ x, y ] = f();
 ```
+The type of the *id-expression* `x` is “`int`”, the type of the
 *id-expression* `y` is “`const volatile double`”.
 — *end example*]
 ## Enumerations <a id="enum">[[enum]]</a>
 — *end example*]
 — *end note*]
+The *identifier* in an *enum-head-name* is not looked up and is
+introduced by the *enum-specifier* or *opaque-enum-declaration*. If the
+*enum-head-name* of an *opaque-enum-declaration* contains a
 *nested-name-specifier*, the declaration shall be an explicit
 specialization [[temp.expl.spec]].
 The enumeration type declared with an *enum-key* of only `enum` is an
 *unscoped enumeration*, and its *enumerator*s are *unscoped
 declaration of a scoped enumeration. The *type-specifier-seq* of an
 *enum-base* shall name an integral type; any cv-qualification is
 ignored. An *opaque-enum-declaration* declaring an unscoped enumeration
 shall not omit the *enum-base*. The identifiers in an *enumerator-list*
 are declared as constants, and can appear wherever constants are
+required. The same identifier shall not appear as the name of multiple
+enumerators in an *enumerator-list*. An *enumerator-definition* with `=`
+gives the associated *enumerator* the value indicated by the
+*constant-expression*. If the first *enumerator* has no *initializer*,
+the value of the corresponding constant is zero. An
+*enumerator-definition* without an *initializer* gives the *enumerator*
+the value obtained by increasing the value of the previous *enumerator*
+by one.
 [*Example 2*:
 ``` cpp
 enum { a, b, c=0 };
 A scoped enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
+If an *enum-head-name* contains a *nested-name-specifier*, the enclosing
+*enum-specifier* or *opaque-enum-declaration* D shall not inhabit a
+class scope and shall correspond to one or more declarations nominable
+in the class, class template, or namespace to which the
+*nested-name-specifier* refers [[basic.scope.scope]]. All those
+declarations shall have the same target scope; the target scope of D is
+that scope.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an *underlying type*. The underlying type can
 be explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
   preceding enumerator unless the incremented value is not representable
   in that type, in which case the type is an unspecified integral type
   sufficient to contain the incremented value. If no such type exists,
   the program is ill-formed.
+An enumeration whose underlying type is fixed is an incomplete type
+until immediately after its *enum-base* (if any), at which point it
+becomes a complete type. An enumeration whose underlying type is not
+fixed is an incomplete type until the closing `}` of its
+*enum-specifier*, at which point it becomes a complete type.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
 all the values of the enumeration type is M. It is possible to define an
 enumeration that has values not defined by any of its enumerators. If
 the *enumerator-list* is empty, the values of the enumeration are as if
 the enumeration had a single enumerator with value 0.[^9]
+An enumeration has the same size, value representation, and alignment
+requirements [[basic.align]] as its underlying type. Furthermore, each
+value of an enumeration has the same representation as the corresponding
+value of the underlying type.
 Two enumeration types are *layout-compatible enumerations* if they have
 the same underlying type.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion [[conv.prom]].
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
 color c = 1;                    // error: type mismatch, no conversion from int to color
+int i = yellow;                 // OK, yellow converted to integral value 1, integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
 if (y) { }                      // error: no Col to bool conversion
 ```
 — *end example*]
+The name of each unscoped enumerator is also bound in the scope that
+immediately contains the *enum-specifier*. An unnamed enumeration that
 does not have a typedef name for linkage purposes [[dcl.typedef]] and
 that has a first enumerator is denoted, for linkage purposes
 [[basic.link]], by its underlying type and its first enumerator; such an
 enumeration is said to have an enumerator as a name for linkage
+purposes.
 [*Note 3*: Each unnamed enumeration with no enumerators is a distinct
 type. — *end note*]
 [*Example 4*:
 }
 ```
 — *end example*]
 ### The `using enum` declaration <a id="enum.udecl">[[enum.udecl]]</a>
 ``` bnf
 using-enum-declaration:
+    using enum using-enum-declarator ';'
 ```
+``` bnf
+using-enum-declarator:
+    nested-name-specifierₒₚₜ identifier
+    nested-name-specifierₒₚₜ simple-template-id
+```
+A *using-enum-declarator* names the set of declarations found by lookup
+[[basic.lookup.unqual]], [[basic.lookup.qual]] for the
+*using-enum-declarator*. The *using-enum-declarator* shall designate a
+non-dependent type with a reachable *enum-specifier*.
+A *using-enum-declaration* is equivalent to a *using-declaration* for
+each enumerator.
 [*Note 1*:
+A *using-enum-declaration* in class scope makes the enumerators of the
+named enumeration available via member lookup.
 [*Example 1*:
 ``` cpp
 enum class fruit { orange, apple };
 — *end note*]
 ## Namespaces <a id="basic.namespace">[[basic.namespace]]</a>
+### General <a id="basic.namespace.general">[[basic.namespace.general]]</a>
+A namespace is an optionally-named entity whose scope can contain
+declarations of any kind of entity. The name of a namespace can be used
+to access entities that belong to that namespace; that is, the *members*
+of the namespace. Unlike other entities, the definition of a namespace
+can be split over several parts of one or more translation units and
+modules.
+[*Note 1*: A *namespace-definition* is exported if it contains any
 *export-declaration*s [[module.interface]]. A namespace is never
+attached to a named module and never has a name with module
+linkage. — *end note*]
 [*Example 1*:
 ``` cpp
 export module M;
 namespace N3 { export int n; }  // N3 is exported
 ```
 — *end example*]
+There is a *global namespace* with no declaration; see
+[[basic.scope.namespace]]. The global namespace belongs to the global
+scope; it is not an unnamed namespace [[namespace.unnamed]].
+[*Note 2*: Lacking a declaration, it cannot be found by name
+lookup. — *end note*]
 ### Namespace definition <a id="namespace.def">[[namespace.def]]</a>
+#### General <a id="namespace.def.general">[[namespace.def.general]]</a>
 ``` bnf
 namespace-name:
         identifier
         namespace-alias
 ```
 ``` bnf
 namespace-body:
         declaration-seqₒₚₜ
 ```
+Every *namespace-definition* shall inhabit a namespace scope
 [[basic.scope.namespace]].
+In a *named-namespace-definition* D, the *identifier* is the name of the
+namespace. The *identifier* is looked up by searching for it in the
+scopes of the namespace A in which D appears and of every element of the
+inline namespace set of A. If the lookup finds a *namespace-definition*
+for a namespace N, D *extends* N, and the target scope of D is the scope
+to which N belongs. If the lookup finds nothing, the *identifier* is
+introduced as a *namespace-name* into A.
 Because a *namespace-definition* contains *declaration*s in its
 *namespace-body* and a *namespace-definition* is itself a *declaration*,
 it follows that *namespace-definition*s can be nested.
 }
 ```
 — *end example*]
 If the optional initial `inline` keyword appears in a
 *namespace-definition* for a particular namespace, that namespace is
 declared to be an *inline namespace*. The `inline` keyword may be used
 on a *namespace-definition* that extends a namespace only if it was
 previously used on the *namespace-definition* that initially declared
 The optional *attribute-specifier-seq* in a *named-namespace-definition*
 appertains to the namespace being defined or extended.
 Members of an inline namespace can be used in most respects as though
+they were members of the innermost enclosing namespace. Specifically,
+the inline namespace and its enclosing namespace are both added to the
+set of associated namespaces used in argument-dependent lookup
 [[basic.lookup.argdep]] whenever one of them is, and a *using-directive*
 [[namespace.udir]] that names the inline namespace is implicitly
 inserted into the enclosing namespace as for an unnamed namespace
 [[namespace.unnamed]]. Furthermore, each member of the inline namespace
+can subsequently be partially specialized [[temp.spec.partial]],
 explicitly instantiated [[temp.explicit]], or explicitly specialized
 [[temp.expl.spec]] as though it were a member of the enclosing
 namespace. Finally, looking up a name in the enclosing namespace via
 explicit qualification [[namespace.qual]] will include members of the
+inline namespace even if there are declarations of that name in the
+enclosing namespace.
 These properties are transitive: if a namespace `N` contains an inline
 namespace `M`, which in turn contains an inline namespace `O`, then the
 members of `O` can be used as though they were members of `M` or `N`.
 The *inline namespace set* of `N` is the transitive closure of all
+inline namespaces in `N`.
 A *nested-namespace-definition* with an *enclosing-namespace-specifier*
 `E`, *identifier* `I` and *namespace-body* `B` is equivalent to
 ``` cpp
 ```
 where the optional `inline` is present if and only if the *identifier*
 `I` is preceded by `inline`.
+[*Example 2*:
 ``` cpp
 namespace A::inline B::C {
   int i;
 }
 }
 ```
 — *end example*]
 ### Namespace alias <a id="namespace.alias">[[namespace.alias]]</a>
 A *namespace-alias-definition* declares an alternate name for a
 namespace according to the following grammar:
 ``` bnf
 qualified-namespace-specifier:
     nested-name-specifierₒₚₜ namespace-name
 ```
+The *identifier* in a *namespace-alias-definition* becomes a
+*namespace-alias* and denotes the namespace denoted by the
+*qualified-namespace-specifier*.
 [*Note 1*: When looking up a *namespace-name* in a
 *namespace-alias-definition*, only namespace names are considered, see
 [[basic.lookup.udir]]. — *end note*]
 ### Using namespace directive <a id="namespace.udir">[[namespace.udir]]</a>
 ``` bnf
 using-directive:
     attribute-specifier-seqₒₚₜ using namespace nested-name-specifierₒₚₜ namespace-name ';'
 [[basic.lookup.udir]]. — *end note*]
 The optional *attribute-specifier-seq* appertains to the
 *using-directive*.
+[*Note 2*: A *using-directive* makes the names in the nominated
+namespace usable in the scope in which the *using-directive* appears
+after the *using-directive* [[basic.lookup.unqual]], [[namespace.qual]].
+During unqualified name lookup, the names appear as if they were
+declared in the nearest enclosing namespace which contains both the
+*using-directive* and the nominated namespace. — *end note*]
+[*Note 3*: A *using-directive* does not introduce any
+names. — *end note*]
 [*Example 1*:
 ``` cpp
 namespace A {
 }
 ```
 — *end example*]
+[*Note 4*: A *using-directive* is transitive: if a scope contains a
+*using-directive* that nominates a namespace that itself contains
+*using-directive*s, the namespaces nominated by those *using-directive*s
+are also eligible to be considered. — *end note*]
 [*Example 2*:
 ``` cpp
 namespace M {
 }
 ```
 — *end example*]
+[*Note 5*: Declarations in a namespace that appear after a
+*using-directive* for that namespace can be found through that
+*using-directive* after they appear. — *end note*]
+[*Note 6*:
 If name lookup finds a declaration for a name in two different
 namespaces, and the declarations do not declare the same entity and do
 not declare functions or function templates, the use of the name is
 ill-formed [[basic.lookup]]. In particular, the name of a variable,
 using namespace A;
 using namespace B;
 void f() {
   X(1);             // error: name X found in two namespaces
+  g();              // OK, name g refers to the same entity
+  h();              // OK, overload resolution selects A::h
 }
 ```
 — *end note*]
+[*Note 7*:
+The order in which namespaces are considered and the relationships among
+the namespaces implied by the *using-directive*s do not affect overload
+resolution. Neither is any function excluded because another has the
+same signature, even if one is in a namespace reachable through
+*using-directive*s in the namespace of the other.[^10]
+— *end note*]
 [*Example 3*:
 ``` cpp
 namespace D {
   int d1;
   void f(char);
 }
 using namespace D;
+int d1;             // OK, no conflict with D::d1
 namespace E {
   int e;
   void f(int);
 }
 void f() {
   d1++;             // error: ambiguous ::d1 or D::d1?
   ::d1++;           // OK
   D::d1++;          // OK
+  d2++;             // OK, D::d2
+  e++;              // OK, E::e
   f(1);             // error: ambiguous: D::f(int) or E::f(int)?
+  f('a');           // OK, D::f(char)
 }
 ```
 — *end example*]
 ``` bnf
 using-declarator:
     typenameₒₚₜ nested-name-specifier unqualified-id
 ```
+The component names of a *using-declarator* are those of its
+*nested-name-specifier* and *unqualified-id*. Each *using-declarator* in
+a *using-declaration*[^11]
+names the set of declarations found by lookup [[basic.lookup.qual]] for
+the *using-declarator*, except that class and enumeration declarations
+that would be discarded are merely ignored when checking for ambiguity
+[[basic.lookup]], conversion function templates with a dependent return
+type are ignored, and certain functions are hidden as described below.
+If the terminal name of the *using-declarator* is dependent
+[[temp.dep.type]], the *using-declarator* is considered to name a
+constructor if and only if the *nested-name-specifier* has a terminal
+name that is the same as the *unqualified-id*. If the lookup in any
+instantiation finds that a *using-declarator* that is not considered to
+name a constructor does do so, or that a *using-declarator* that is
+considered to name a constructor does not, the program is ill-formed.
 If the *using-declarator* names a constructor, it declares that the
+class *inherits* the named set of constructor declarations from the
+nominated base class.
+[*Note 1*: Otherwise, the *unqualified-id* in the *using-declarator* is
+bound to the *using-declarator*, which is replaced during name lookup
+with the declarations it names [[basic.lookup]]. If such a declaration
+is of an enumeration, the names of its enumerators are not bound. For
+the keyword `typename`, see [[temp.res]]. — *end note*]
 In a *using-declaration* used as a *member-declaration*, each
 *using-declarator* shall either name an enumerator or have a
+*nested-name-specifier* naming a base class of the current class
+[[expr.prim.this]].
+[*Example 1*:
 ``` cpp
 enum class button { up, down };
 struct S {
   using button::up;
 ```
 — *end example*]
 If a *using-declarator* names a constructor, its *nested-name-specifier*
+shall name a direct base class of the current class. If the immediate
+(class) scope is associated with a class template, it shall derive from
+the specified base class or have at least one dependent base class.
+[*Example 2*:
 ``` cpp
+struct B {
+  void f(char);
+  enum E { e };
+  union { int x; };
+};
+struct C {
+  int f();
+};
+struct D : B {
+  using B::f;                   // OK, B is a base of D
+  using B::e;                   // OK, e is an enumerator of base B
+  using B::x;                   // OK, x is a union member of base B
+  using C::f;                   // error: C isn't a base of D
+  void f(int) { f('c'); }       // calls B::f(char)
+  void g(int) { g('c'); }       // recursively calls D::g(int)
+};
 template <typename... bases>
 struct X : bases... {
+  using bases::f...;
 };
+X<B, C> x;                      // OK, B::f and C::f named
 ```
 — *end example*]
 [*Note 2*: Since destructors do not have names, a *using-declaration*
+cannot refer to a destructor for a base class. — *end note*]
 If a constructor or assignment operator brought from a base class into a
 derived class has the signature of a copy/move constructor or assignment
+operator for the derived class
+[[class.copy.ctor]], [[class.copy.assign]], the *using-declaration* does
+not by itself suppress the implicit declaration of the derived class
+member; the member from the base class is hidden or overridden by the
 implicitly-declared copy/move constructor or assignment operator of the
 derived class, as described below.
 A *using-declaration* shall not name a *template-id*.
+[*Example 3*:
 ``` cpp
 struct A {
   template <class T> void f(T);
   template <class T> struct X { };
 A *using-declaration* shall not name a namespace.
 A *using-declaration* that names a class member other than an enumerator
 shall be a *member-declaration*.
+[*Example 4*:
 ``` cpp
 struct X {
   int i;
   static int s;
 }
 ```
 — *end example*]
+If a declaration is named by two *using-declarator*s that inhabit the
+same class scope, the program is ill-formed.
+[*Note 3*: A *using-declarator* whose *nested-name-specifier* names a
+namespace does not name declarations added to the namespace after it.
+Thus, additional overloads added after the *using-declaration* are
+ignored, but default function arguments [[dcl.fct.default]], default
+template arguments [[temp.param]], and template specializations
+[[temp.spec.partial]], [[temp.expl.spec]] are considered. — *end note*]
+[*Example 5*:
 ``` cpp
 namespace A {
   void f(int);
 }
 }
 ```
 — *end example*]
+If a declaration named by a *using-declaration* that inhabits the target
+scope of another declaration potentially conflicts with it
+[[basic.scope.scope]], and either is reachable from the other, the
+program is ill-formed. If two declarations named by *using-declaration*s
+that inhabit the same scope potentially conflict, either is reachable
+from the other, and they do not both declare functions or function
+templates, the program is ill-formed.
+[*Note 4*: Overload resolution possibly cannot distinguish between
+conflicting function declarations. — *end note*]
+[*Example 6*:
 ``` cpp
 namespace A {
   int x;
+  int f(int);
+  int g;
+  void h();
 }
 namespace B {
   int i;
   struct g { };
   struct x { };
   void f(int);
   void f(double);
+  void g(char); // OK, hides struct g
 }
 void func() {
   int i;
+  using B::i; // error: conflicts
   void f(char);
+  using B::f; // OK, each f is a function
+  using A::f;                           // OK, but interferes with B::f(int)
+  f(1);                                 // error: ambiguous
+  static_cast<int(*)(int)>(f)(1);       // OK, calls A::f
   f(3.5);                               // calls B::f(double)
   using B::g;
   g('a');                               // calls B::g(char)
   struct g g1;                          // g1 has class type B::g
+  using A::g;                           // error: conflicts with B::g
+  void h();
+  using A::h;                           // error: conflicts
   using B::x;
+  using A::x; // OK, hides struct B::x
   x = 99;                               // assigns to A::x
   struct x x1;                          // x1 has class type B::x
 }
 ```
 — *end example*]
+The set of declarations named by a *using-declarator* that inhabits a
+class `C` does not include member functions and member function
+templates of a base class that correspond to (and thus would conflict
+with) a declaration of a function or function template in `C`.
+[*Example 7*:
 ``` cpp
 struct B {
   virtual void f(int);
   virtual void f(char);
   void h(int);
 };
 struct D : B {
   using B::f;
+  void f(int);      // OK, D::f(int) overrides B::f(int);
   using B::g;
   void g(char);     // OK
   using B::h;
+  void h(int);      // OK, D::h(int) hides B::h(int)
 };
 void k(D* p)
 {
   p->f(1);          // calls D::f(int)
 D1 d1(0);           // error: ambiguous
 struct D2 : B1, B2 {
   using B1::B1;
   using B2::B2;
+  D2(int);          // OK, D2::D2(int) hides B1::B1(int) and B2::B2(int)
 };
 D2 d2(0);           // calls D2::D2(int)
 ```
 — *end example*]
+[*Note 5*: For the purpose of forming a set of candidates during
+overload resolution, the functions named by a *using-declaration* in a
+derived class are treated as though they were direct members of the
+derived class. In particular, the implicit object parameter is treated
+as if it were a reference to the derived class rather than to the base
+class [[over.match.funcs]]. This has no effect on the type of the
+function, and in all other respects the function remains part of the
+base class. — *end note*]
+Constructors that are named by a *using-declaration* are treated as
 though they were constructors of the derived class when looking up the
 constructors of the derived class [[class.qual]] or forming a set of
+overload candidates
+[[over.match.ctor]], [[over.match.copy]], [[over.match.list]].
+[*Note 6*: If such a constructor is selected to perform the
 initialization of an object of class type, all subobjects other than the
 base class from which the constructor originated are implicitly
 initialized [[class.inhctor.init]]. A constructor of a derived class is
 sometimes preferred to a constructor of a base class if they would
 otherwise be ambiguous [[over.match.best]]. — *end note*]
+In a *using-declarator* that does not name a constructor, every
+declaration named shall be accessible. In a *using-declarator* that
+names a constructor, no access check is performed.
+[*Note 7*:
 Because a *using-declarator* designates a base class member (and not a
 member subobject or a member function of a base class subobject), a
 *using-declarator* cannot be used to resolve inherited member
 ambiguities.
+[*Example 8*:
 ``` cpp
 struct A { int x(); };
 struct B : A { };
 struct C : A {
 — *end example*]
 — *end note*]
+A *using-declaration* has the usual accessibility for a
+*member-declaration*. Base-class constructors considered because of a
+*using-declarator* are accessible if they would be accessible when used
+to construct an object of the base class; the accessibility of the
+*using-declaration* is ignored.
+[*Example 9*:
 ``` cpp
 class A {
 private:
     void f(char);
 };
 ```
 — *end example*]
 ## The `asm` declaration <a id="dcl.asm">[[dcl.asm]]</a>
 An `asm` declaration has the form
 ``` bnf
 [*Note 1*: Typically it is used to pass information through the
 implementation to an assembler. — *end note*]
 ## Linkage specifications <a id="dcl.link">[[dcl.link]]</a>
+All functions and variables whose names have external linkage and all
+function types have a *language linkage*.
 [*Note 1*: Some of the properties associated with an entity with
 language linkage are specific to each implementation and are not
+described here. For example, a particular language linkage might be
 associated with a particular form of representing names of objects and
 functions with external linkage, or with a particular calling
 convention, etc. — *end note*]
+The default language linkage of all function types, functions, and
+variables is C++ language linkage. Two function types with different
+language linkages are distinct types even if they are otherwise
+identical.
 Linkage [[basic.link]] between C++ and non-C++ code fragments can be
 achieved using a *linkage-specification*:
 ``` bnf
 linkage-specification:
     extern string-literal '{' declaration-seqₒₚₜ '}'
+    extern string-literal name-declaration
 ```
 The *string-literal* indicates the required language linkage. This
 document specifies the semantics for the *string-literal*s `"C"` and
 `"C++"`. Use of a *string-literal* other than `"C"` or `"C++"` is
 [*Note 2*: Therefore, a linkage-specification with a *string-literal*
 that is unknown to the implementation requires a
 diagnostic. — *end note*]
+*Recommended practice:* The spelling of the *string-literal* should be
+taken from the document defining that language. For example, `Ada` (not
+`ADA`) and `Fortran` or `FORTRAN`, depending on the vintage.
+Every implementation shall provide for linkage to the C programming
+language, `"C"`, and C++, `"C++"`.
 [*Example 1*:
 ``` cpp
+complex sqrt(complex);          // C++{} language linkage by default
 extern "C" {
+  double sqrt(double);          // C language linkage
 }
 ```
 — *end example*]
+A *module-import-declaration* appearing in a linkage specification with
+other than C++ language linkage is conditionally-supported with
+*implementation-defined* semantics.
 Linkage specifications nest. When linkage specifications nest, the
+innermost one determines the language linkage.
+[*Note 3*: A linkage specification does not establish a
+scope. — *end note*]
+A *linkage-specification* shall inhabit a namespace scope. In a
+*linkage-specification*, the specified language linkage applies to the
+function types of all function declarators and to all functions and
+variables whose names have external linkage.
 [*Example 2*:
 ``` cpp
+extern "C"                      // f1 and its function type have C language linkage;
   void f1(void(*pf)(int));      // pf is a pointer to a C function
 extern "C" typedef void FUNC();
+FUNC f2;                        // f2 has C++{} language linkage and
+                                // its  type has C language linkage
+extern "C" FUNC f3;             // f3 and its type have C language linkage
+void (*pf2)(FUNC*);             // the variable pf2 has C++{} language linkage; its type
+                                // is ``pointer to C++{} function that takes one parameter of type
                                 // pointer to C function''
 extern "C" {
+  static void f4();             // the name of the function f4 has internal linkage,
+                                // so f4 has no language linkage; its type has C language linkage
 }
 extern "C" void f5() {
+  extern void f4();             // OK, name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 }
+extern void f4();               // OK, name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 void f6() {
+  extern void f4();             // OK, name linkage (internal) and function type linkage (C language linkage)
                                 // obtained from previous declaration.
 }
 ```
 — *end example*]
 A C language linkage is ignored in determining the language linkage of
+class members, friend functions with a trailing *requires-clause*, and
+the function type of non-static class member functions.
 [*Example 3*:
 ``` cpp
 extern "C" typedef void FUNC_c();
 class C {
+  void mf1(FUNC_c*);            // the function mf1 and its type have C++{} language linkage;
+                                // the parameter has type ``pointer to C function''
+  FUNC_c mf2;                   // the function mf2 and its type have C++{} language linkage
+  static FUNC_c* q;             // the data member q has C++{} language linkage;
+                                // its type is ``pointer to C function''
 };
 extern "C" {
   class X {
+    void mf();                  // the function mf and its type have C++{} language linkage
+    void mf2(void(*)());        // the function mf2 has C++{} language linkage;
                                 // the parameter has type ``pointer to C function''
   };
 }
 ```
 — *end example*]
+If two declarations of an entity give it different language linkages,
+the program is ill-formed; no diagnostic is required if neither
+declaration is reachable from the other. A redeclaration of an entity
+without a linkage specification inherits the language linkage of the
+entity and (if applicable) its type.
+Two declarations declare the same entity if they (re)introduce the same
+name, one declares a function or variable with C language linkage, and
+the other declares such an entity or declares a variable that belongs to
+the global scope.
 [*Example 4*:
 ``` cpp
 int x;
 extern "C" static void g();         // error
 ```
 — *end example*]
+[*Note 4*: Because the language linkage is part of a function type,
 when indirecting through a pointer to C function, the function to which
 the resulting lvalue refers is considered a C function. — *end note*]
 Linkage from C++ to objects defined in other languages and to objects
 defined in C++ from other languages is *implementation-defined* and
 name lookup [[basic.lookup]] is performed on any of the identifiers
 contained in an *attribute-token*. The *attribute-token* determines
 additional requirements on the *attribute-argument-clause* (if any).
 Each *attribute-specifier-seq* is said to *appertain* to some entity or
+statement, identified by the syntactic context where it appears
+[[stmt.stmt]], [[dcl.dcl]], [[dcl.decl]]. If an
 *attribute-specifier-seq* that appertains to some entity or statement
 contains an *attribute* or *alignment-specifier* that is not allowed to
 apply to that entity or statement, the program is ill-formed. If an
 *attribute-specifier-seq* appertains to a friend declaration
 [[class.friend]], that declaration shall be a definition.
 [*Note 3*: An *attribute-specifier-seq* cannot appeartain to an
 explicit instantiation [[temp.explicit]]. — *end note*]
 For an *attribute-token* (including an *attribute-scoped-token*) not
+specified in this document, the behavior is *implementation-defined*;
+any such *attribute-token* that is not recognized by the implementation
+is ignored.
+[*Note 4*: A program is ill-formed if it contains an *attribute*
+specified in [[dcl.attr]] that violates the rules specifying to which
+entity or statement the attribute can apply or the syntax rules for the
+attribute’s *attribute-argument-clause*, if any. — *end note*]
+[*Note 5*: The *attribute*s specified in [[dcl.attr]] have optional
+semantics: given a well-formed program, removing all instances of any
+one of those *attribute*s results in a program whose set of possible
+executions [[intro.abstract]] for a given input is a subset of those of
+the original program for the same input, absent implementation-defined
+guarantees with respect to that *attribute*. — *end note*]
+An *attribute-token* is reserved for future standardization if
 - it is not an *attribute-scoped-token* and is not specified in this
   document, or
 - it is an *attribute-scoped-token* and its *attribute-namespace* is
   `std` followed by zero or more digits.
+Each implementation should choose a distinctive name for the
+*attribute-namespace* in an *attribute-scoped-token*.
 Two consecutive left square bracket tokens shall appear only when
 introducing an *attribute-specifier* or within the *balanced-token-seq*
 of an *attribute-argument-clause*.
+[*Note 6*: If two consecutive left square brackets appear where an
 *attribute-specifier* is not allowed, the program is ill-formed even if
 the brackets match an alternative grammar production. — *end note*]
 [*Example 2*:
   extern unsigned char c[sizeof(double)];           // error: different alignment in declaration
 ```
 — *end example*]
+### Assumption attribute <a id="dcl.attr.assume">[[dcl.attr.assume]]</a>
+The *attribute-token* `assume` may be applied to a null statement; such
+a statement is an *assumption*. An *attribute-argument-clause* shall be
+present and shall have the form:
+``` bnf
+'(' conditional-expression ')'
+```
+The expression is contextually converted to `bool` [[conv.general]]. The
+expression is not evaluated. If the converted expression would evaluate
+to `true` at the point where the assumption appears, the assumption has
+no effect. Otherwise, the behavior is undefined.
+[*Note 1*: The expression is potentially evaluated [[basic.def.odr]].
+The use of assumptions is intended to allow implementations to analyze
+the form of the expression and deduce information used to optimize the
+program. Implementations are not required to deduce any information from
+any particular assumption. — *end note*]
+[*Example 1*:
+``` cpp
+int divide_by_32(int x) {
+  [[assume(x >= 0)]];
+  return x/32;                  // The instructions produced for the division
+                                // may omit handling of negative values.
+}
+int f(int y) {
+  [[assume(++y == 43)]];        // y is not incremented
+  return y;                     // statement may be replaced with return 42;
+}
+```
+— *end example*]
 ### Carries dependency attribute <a id="dcl.attr.depend">[[dcl.attr.depend]]</a>
 The *attribute-token* `carries_dependency` specifies dependency
+propagation into and out of functions. No *attribute-argument-clause*
+shall be present. The attribute may be applied to a parameter of a
+function or lambda, in which case it specifies that the initialization
+of the parameter carries a dependency to [[intro.multithread]] each
+lvalue-to-rvalue conversion [[conv.lval]] of that object. The attribute
+may also be applied to a function or a lambda call operator, in which
+case it specifies that the return value, if any, carries a dependency to
+the evaluation of the function call expression.
 The first declaration of a function shall specify the
 `carries_dependency` attribute for its *declarator-id* if any
 declaration of the function specifies the `carries_dependency`
 attribute. Furthermore, the first declaration of a function shall
 parameters is declared without the `carries_dependency` attribute in its
 first declaration in another translation unit, the program is
 ill-formed, no diagnostic required.
 [*Note 1*: The `carries_dependency` attribute does not change the
+meaning of the program, but might result in generation of more efficient
 code. — *end note*]
 [*Example 1*:
 ``` cpp
 entities whose use is still allowed, but is discouraged for some reason.
 [*Note 1*: In particular, `deprecated` is appropriate for names and
 entities that are deemed obsolescent or unsafe. — *end note*]
+An *attribute-argument-clause* may be present and, if present, it shall
 have the form:
 ``` bnf
 '(' string-literal ')'
 ```
+[*Note 2*: The *string-literal* in the *attribute-argument-clause* can
+be used to explain the rationale for deprecation and/or to suggest a
+replacing entity. — *end note*]
 The attribute may be applied to the declaration of a class, a
 *typedef-name*, a variable, a non-static data member, a function, a
+namespace, an enumeration, an enumerator, a concept, or a template
+specialization.
+An entity declared without the `deprecated` attribute can later be
+redeclared with the attribute and vice-versa.
 [*Note 3*: Thus, an entity initially declared without the attribute can
 be marked as deprecated by a subsequent redeclaration. However, after an
 entity is marked as deprecated, later redeclarations do not un-deprecate
 the entity. — *end note*]
 attribute applied to the name or entity.
 ### Fallthrough attribute <a id="dcl.attr.fallthrough">[[dcl.attr.fallthrough]]</a>
 The *attribute-token* `fallthrough` may be applied to a null statement
+[[stmt.expr]]; such a statement is a fallthrough statement. No
+*attribute-argument-clause* shall be present. A fallthrough statement
+may only appear within an enclosing `switch` statement [[stmt.switch]].
+The next statement that would be executed after a fallthrough statement
+shall be a labeled statement whose label is a case label or default
+label for the same `switch` statement and, if the fallthrough statement
+is contained in an iteration statement, the next statement shall be part
+of the same execution of the substatement of the innermost enclosing
+iteration statement. The program is ill-formed if there is no such
+statement.
 *Recommended practice:* The use of a fallthrough statement should
 suppress a warning that an implementation might otherwise issue for a
 case or default label that is reachable from another case or default
 label along some path of execution. Implementations should issue a
 — *end example*]
 ### Likelihood attributes <a id="dcl.attr.likelihood">[[dcl.attr.likelihood]]</a>
 The *attribute-token*s `likely` and `unlikely` may be applied to labels
+or statements. No *attribute-argument-clause* shall be present. The
+*attribute-token* `likely` shall not appear in an
+*attribute-specifier-seq* that contains the *attribute-token*
+`unlikely`.
 *Recommended practice:* The use of the `likely` attribute is intended to
 allow implementations to optimize for the case where paths of execution
 including it are arbitrarily more likely than any alternative path of
 execution that does not include such an attribute on a statement or
 — *end example*]
 ### Maybe unused attribute <a id="dcl.attr.unused">[[dcl.attr.unused]]</a>
 The *attribute-token* `maybe_unused` indicates that a name or entity is
+possibly intentionally unused. No *attribute-argument-clause* shall be
+present.
 The attribute may be applied to the declaration of a class, a
 *typedef-name*, a variable (including a structured binding declaration),
 a non-static data member, a function, an enumeration, or an enumerator.
 — *end example*]
 ### Nodiscard attribute <a id="dcl.attr.nodiscard">[[dcl.attr.nodiscard]]</a>
+The *attribute-token* `nodiscard` may be applied to a function or a
+lambda call operator or to the declaration of a class or enumeration. An
 *attribute-argument-clause* may be present and, if present, shall have
 the form:
 ``` bnf
 '(' string-literal ')'
 is either
 - a function call expression [[expr.call]] that calls a function
   declared `nodiscard` in a reachable declaration or whose return type
   is a nodiscard type, or
+- an explicit type conversion
+  [[expr.type.conv]], [[expr.static.cast]], [[expr.cast]] that
+ constructs an object through a constructor declared `nodiscard` in a
+ reachable declaration, or that initializes an object of a nodiscard
+  type.
 *Recommended practice:* Appearance of a nodiscard call as a
 potentially-evaluated discarded-value expression [[expr.prop]] is
 discouraged unless explicitly cast to `void`. Implementations should
 issue a warning in such cases.
 — *end example*]
 ### Noreturn attribute <a id="dcl.attr.noreturn">[[dcl.attr.noreturn]]</a>
 The *attribute-token* `noreturn` specifies that a function does not
+return. No *attribute-argument-clause* shall be present. The attribute
+may be applied to a function or a lambda call operator. The first
 declaration of a function shall specify the `noreturn` attribute if any
 declaration of that function specifies the `noreturn` attribute. If a
 function is declared with the `noreturn` attribute in one translation
 unit and the same function is declared without the `noreturn` attribute
 in another translation unit, the program is ill-formed, no diagnostic
 — *end example*]
 ### No unique address attribute <a id="dcl.attr.nouniqueaddr">[[dcl.attr.nouniqueaddr]]</a>
 The *attribute-token* `no_unique_address` specifies that a non-static
+data member is a potentially-overlapping subobject [[intro.object]]. No
 *attribute-argument-clause* shall be present. The attribute may
 appertain to a non-static data member other than a bit-field.
 [*Note 1*: The non-static data member can share the address of another
 non-static data member or that of a base class, and any padding that
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.lookup.elab]: basic.md#basic.lookup.elab
+[basic.lookup.general]: basic.md#basic.lookup.general
 [basic.lookup.qual]: basic.md#basic.lookup.qual
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.namespace]: #basic.namespace
+[basic.namespace.general]: #basic.namespace.general
 [basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.scope.scope]: basic.md#basic.scope.scope
 [basic.start]: basic.md#basic.start
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.static]: basic.md#basic.start.static
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.static]: basic.md#basic.stc.static
 [basic.stc.thread]: basic.md#basic.stc.thread
 [basic.type.qualifier]: basic.md#basic.type.qualifier
 [class]: class.md#class
 [class.access]: class.md#class.access
+[class.access.base]: class.md#class.access.base
 [class.base.init]: class.md#class.base.init
 [class.bit]: class.md#class.bit
 [class.conv.ctor]: class.md#class.conv.ctor
 [class.conv.fct]: class.md#class.conv.fct
 [class.copy.assign]: class.md#class.copy.assign
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.copy.elision]: class.md#class.copy.elision
 [class.expl.init]: class.md#class.expl.init
 [class.friend]: class.md#class.friend
 [class.inhctor.init]: class.md#class.inhctor.init
 [class.init]: class.md#class.init
 [class.mem]: class.md#class.mem
+[class.mem.general]: class.md#class.mem.general
+[class.member.lookup]: basic.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.mi]: class.md#class.mi
 [class.name]: class.md#class.name
 [class.pre]: class.md#class.pre
 [class.qual]: basic.md#class.qual
 [class.union.anon]: class.md#class.union.anon
 [class.virtual]: class.md#class.virtual
 [conv]: expr.md#conv
 [conv.array]: expr.md#conv.array
 [conv.func]: expr.md#conv.func
+[conv.general]: expr.md#conv.general
+[conv.integral]: expr.md#conv.integral
 [conv.lval]: expr.md#conv.lval
 [conv.prom]: expr.md#conv.prom
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [conv.rval]: expr.md#conv.rval
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
+[dcl.attr.assume]: #dcl.attr.assume
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.fallthrough]: #dcl.attr.fallthrough
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.likelihood]: #dcl.attr.likelihood
 [dcl.attr.unused]: #dcl.attr.unused
 [dcl.constexpr]: #dcl.constexpr
 [dcl.constinit]: #dcl.constinit
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
+[dcl.decl.general]: #dcl.decl.general
 [dcl.enum]: #dcl.enum
 [dcl.fct]: #dcl.fct
 [dcl.fct.def]: #dcl.fct.def
 [dcl.fct.def.coroutine]: #dcl.fct.def.coroutine
 [dcl.fct.def.default]: #dcl.fct.def.default
 [dcl.fct.default]: #dcl.fct.default
 [dcl.fct.spec]: #dcl.fct.spec
 [dcl.friend]: #dcl.friend
 [dcl.init]: #dcl.init
 [dcl.init.aggr]: #dcl.init.aggr
+[dcl.init.general]: #dcl.init.general
 [dcl.init.list]: #dcl.init.list
 [dcl.init.ref]: #dcl.init.ref
 [dcl.init.string]: #dcl.init.string
 [dcl.inline]: #dcl.inline
 [dcl.link]: #dcl.link
 [dcl.meaning]: #dcl.meaning
+[dcl.meaning.general]: #dcl.meaning.general
 [dcl.mptr]: #dcl.mptr
 [dcl.name]: #dcl.name
 [dcl.pre]: #dcl.pre
 [dcl.ptr]: #dcl.ptr
 [dcl.ref]: #dcl.ref
 [dcl.spec]: #dcl.spec
 [dcl.spec.auto]: #dcl.spec.auto
+[dcl.spec.auto.general]: #dcl.spec.auto.general
+[dcl.spec.general]: #dcl.spec.general
 [dcl.stc]: #dcl.stc
 [dcl.struct.bind]: #dcl.struct.bind
 [dcl.type]: #dcl.type
 [dcl.type.auto.deduct]: #dcl.type.auto.deduct
 [dcl.type.class.deduct]: #dcl.type.class.deduct
 [dcl.type.cv]: #dcl.type.cv
 [dcl.type.decltype]: #dcl.type.decltype
 [dcl.type.elab]: #dcl.type.elab
+[dcl.type.general]: #dcl.type.general
 [dcl.type.simple]: #dcl.type.simple
 [dcl.typedef]: #dcl.typedef
 [depr.volatile.type]: future.md#depr.volatile.type
 [enum]: #enum
 [enum.udecl]: #enum.udecl
 [except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
+[except.pre]: except.md#except.pre
 [except.spec]: except.md#except.spec
 [except.throw]: except.md#except.throw
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [expr.await]: expr.md#expr.await
 [expr.call]: expr.md#expr.call
 [expr.cast]: expr.md#expr.cast
+[expr.comma]: expr.md#expr.comma
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
 [expr.post.incr]: expr.md#expr.post.incr
 [expr.pre.incr]: expr.md#expr.pre.incr
+[expr.prim.id.unqual]: expr.md#expr.prim.id.unqual
 [expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.prim.this]: expr.md#expr.prim.this
 [expr.prop]: expr.md#expr.prop
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [expr.unary.op]: expr.md#expr.unary.op
 [expr.yield]: expr.md#expr.yield
+[initializer.list.syn]: support.md#initializer.list.syn
+[intro.abstract]: intro.md#intro.abstract
 [intro.compliance]: intro.md#intro.compliance
 [intro.execution]: basic.md#intro.execution
 [intro.multithread]: basic.md#intro.multithread
 [intro.object]: basic.md#intro.object
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [lex.string]: lex.md#lex.string
 [module.interface]: module.md#module.interface
+[module.reach]: module.md#module.reach
+[module.unit]: module.md#module.unit
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
+[namespace.def.general]: #namespace.def.general
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.binary]: over.md#over.binary
+[over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.match.best]: over.md#over.match.best
 [over.match.class.deduct]: over.md#over.match.class.deduct
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ref]: over.md#over.match.ref
 [over.match.viable]: over.md#over.match.viable
 [over.oper]: over.md#over.oper
 [over.sub]: over.md#over.sub
 [special]: class.md#special
+[std.modules]: library.md#std.modules
 [stmt.ambig]: stmt.md#stmt.ambig
 [stmt.dcl]: stmt.md#stmt.dcl
 [stmt.expr]: stmt.md#stmt.expr
 [stmt.if]: stmt.md#stmt.if
 [stmt.iter]: stmt.md#stmt.iter
 [stmt.return]: stmt.md#stmt.return
 [stmt.return.coroutine]: stmt.md#stmt.return.coroutine
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [stmt.switch]: stmt.md#stmt.switch
 [support.runtime]: support.md#support.runtime
 [temp.arg.type]: temp.md#temp.arg.type
+[temp.decls]: temp.md#temp.decls
 [temp.deduct]: temp.md#temp.deduct
 [temp.deduct.call]: temp.md#temp.deduct.call
+[temp.deduct.decl]: temp.md#temp.deduct.decl
 [temp.deduct.guide]: temp.md#temp.deduct.guide
+[temp.dep.type]: temp.md#temp.dep.type
 [temp.expl.spec]: temp.md#temp.expl.spec
 [temp.explicit]: temp.md#temp.explicit
 [temp.fct]: temp.md#temp.fct
 [temp.inst]: temp.md#temp.inst
 [temp.local]: temp.md#temp.local
 [temp.names]: temp.md#temp.names
 [temp.param]: temp.md#temp.param
 [temp.pre]: temp.md#temp.pre
 [temp.res]: temp.md#temp.res
+[temp.spec.partial]: temp.md#temp.spec.partial
 [temp.variadic]: temp.md#temp.variadic
+[term.odr.use]: basic.md#term.odr.use
+[term.padding.bits]: basic.md#term.padding.bits
+[term.scalar.type]: basic.md#term.scalar.type
+[term.unevaluated.operand]: expr.md#term.unevaluated.operand
 [^1]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
     reference type.
 [^8]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation
     [[lex.name]]. If a predefined variable is not odr-used
+    [[term.odr.use]], its string value need not be present in the
     program image.
 [^9]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
+[^10]: During name lookup in a class hierarchy, some ambiguities can be
     resolved by considering whether one member hides the other along
+    some paths [[class.member.lookup]]. There is no such
+ disambiguation when considering the set of names found as a result
+ of following \*using-directive\*s.
+[^11]: A *using-declaration* with more than one *using-declarator* is
     equivalent to a corresponding sequence of *using-declaration*s with
     one *using-declarator* each.

Diff to HTML by rtfpessoa