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

Files changed (1) hide show

tmp/tmpn3fxb8gh/{from.md → to.md} +227 -305

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

@@ -1,7 +1,9 @@
 ## Specifiers <a id="dcl.spec">[[dcl.spec]]</a>
 The specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
@@ -93,15 +95,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*]
@@ -137,14 +138,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
@@ -215,15 +217,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.
@@ -238,11 +240,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]].
@@ -253,10 +255,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
@@ -299,118 +312,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();
@@ -422,23 +360,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
@@ -449,11 +387,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
@@ -486,58 +424,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)
@@ -547,14 +479,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)
@@ -566,77 +501,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
@@ -647,14 +515,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; }
 // ...
@@ -666,13 +538,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;
 };
@@ -689,15 +563,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"; }
@@ -711,11 +586,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
@@ -740,29 +615,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
@@ -817,11 +693,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
@@ -850,23 +726,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
@@ -944,10 +821,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
@@ -1030,49 +913,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
@@ -1120,23 +1026,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();
@@ -1186,11 +1092,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
@@ -1205,10 +1111,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 ')'
 ```
@@ -1225,11 +1133,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
@@ -1241,54 +1149,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*]
@@ -1316,15 +1219,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
@@ -1338,14 +1241,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
@@ -1361,24 +1264,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
@@ -1430,44 +1331,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>
@@ -1494,12 +1414,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;
@@ -1514,10 +1434,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

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

Diff to HTML by rtfpessoa