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

Files changed (1) hide show

tmp/tmpfj61gxc4/{from.md → to.md} +624 -474

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

@@ -5,30 +5,34 @@ The specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
     defining-type-specifier
     function-specifier
- 'friend'
- 'typedef'
- 'constexpr'
- 'inline'
 ```
 ``` bnf
 decl-specifier-seq:
     decl-specifier attribute-specifier-seqₒₚₜ
     decl-specifier decl-specifier-seq
 ```
 The optional *attribute-specifier-seq* in a *decl-specifier-seq*
-appertains to the type determined by the preceding *decl-specifier*s (
-[[dcl.meaning]]). The *attribute-specifier-seq* affects the type only
-for the declaration it appears in, not other declarations involving the
-same type.
 Each *decl-specifier* shall appear at most once in a complete
-*decl-specifier-seq*, except that `long` may appear twice.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
 is no previous *defining-type-specifier* other than a *cv-qualifier* in
 the *decl-specifier-seq*. The sequence shall be self-consistent as
@@ -76,69 +80,71 @@ void k(unsigned int Pc);        // void k(unsigned int)
 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
- 'static'
- 'thread_local'
- 'extern'
- 'mutable'
 ```
 At most one *storage-class-specifier* shall appear in a given
 *decl-specifier-seq*, except that `thread_local` may appear with
 `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. A *storage-class-specifier* other than
-`thread_local` shall not be specified in an explicit specialization (
-[[temp.expl.spec]]) or an explicit instantiation ([[temp.explicit]])
-directive.
-[*Note 1*: A variable declared without a *storage-class-specifier* at
 block scope or declared as a function parameter has automatic storage
-duration by default ([[basic.stc.auto]]). — *end note*]
 The `thread_local` specifier indicates that the named entity has thread
-storage duration ([[basic.stc.thread]]). It shall be applied only to
-the names of variables of namespace or block scope and to the names of
-static data members. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
-The `static` specifier can be applied only to names of variables and
-functions and to anonymous unions ([[class.union.anon]]). There can be
-no `static` function declarations within a block, nor any `static`
-function parameters. A `static` specifier used in the declaration of a
-variable declares the variable to have static storage duration (
-[[basic.stc.static]]), unless accompanied by the `thread_local`
-specifier, which declares the variable to have thread storage duration (
-[[basic.stc.thread]]). A `static` specifier can be used in declarations
-of class members;  [[class.static]] describes its effect. For the
-linkage of a name declared with a `static` specifier, see
-[[basic.link]].
-The `extern` specifier can be applied only to the names of variables and
-functions. The `extern` specifier cannot be used in the declaration of
-class members or function parameters. For the linkage of a name declared
-with an `extern` specifier, see  [[basic.link]].
-[*Note 2*: 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. Each function in a given set of overloaded
-functions can have a different linkage, however.
 [*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
@@ -195,71 +201,86 @@ void h() {
 ```
 — *end example*]
 The `mutable` specifier shall appear only in the declaration of a
-non-static data member ([[class.mem]]) whose type is neither
 const-qualified nor a reference type.
 [*Example 3*:
 ``` cpp
 class X {
   mutable const int* p;         // OK
-  mutable int* const q;         // ill-formed
 };
 ```
 — *end example*]
-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` ([[dcl.type.cv]]).
 ### Function specifiers <a id="dcl.fct.spec">[[dcl.fct.spec]]</a>
-can be used only in function declarations.
 ``` bnf
 function-specifier:
- 'virtual'
- 'explicit'
 ```
 The `virtual` specifier shall be used only in the initial declaration of
 a non-static class member function; see  [[class.virtual]].
-The `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]].
 ### 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
 `typedef` specifier shall not be combined in a *decl-specifier-seq* with
 any other kind of specifier except a *defining-type-specifier*, and it
 shall not be used in the *decl-specifier-seq* of a
-*parameter-declaration* ([[dcl.fct]]) nor in the *decl-specifier-seq*
-of a *function-definition* ([[dcl.fct.def]]). If a `typedef` specifier
-appears in a declaration without a *declarator*, the program is
-ill-formed.
 ``` bnf
 typedef-name:
     identifier
 ```
-A name declared with the `typedef` specifier becomes a *typedef-name*.
-Within the scope of its declaration, a *typedef-name* is syntactically
-equivalent to a keyword and names the type associated with the
-identifier in the way described in Clause  [[dcl.decl]]. A
-*typedef-name* is thus a synonym for another type. A *typedef-name* does
-not introduce a new type the way a class declaration ([[class.name]])
-or enum declaration does.
 [*Example 1*:
 After
@@ -290,21 +311,21 @@ particular, it does not define a new type.
 ``` cpp
 using handler_t = void (*)(int);
 extern handler_t ignore;
 extern void (*ignore)(int);         // redeclare ignore
-using cell = pair<void*, cell*>;    // ill-formed
 ```
 — *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
-redefine the name of any type declared in that scope to refer to the
 type to which it already refers.
 [*Example 3*:
 ``` cpp
@@ -314,11 +335,11 @@ typedef int I;
 typedef I I;
 ```
 — *end example*]
-In a given class scope, a `typedef` specifier can be used to redefine
 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*:
@@ -330,11 +351,11 @@ struct S {
 };
 ```
 — *end example*]
-If a `typedef` specifier is used to redefine 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.
@@ -349,11 +370,11 @@ int main() {
 struct S { };                   // OK
 ```
 — *end example*]
-In a given scope, a `typedef` specifier shall not be used to redefine
 the name of any type declared in that scope to refer to a different
 type.
 [*Example 6*:
@@ -375,17 +396,19 @@ typedef int complex;
 class complex { ... };    // error: redefinition
 ```
 — *end example*]
-[*Note 1*:  A *typedef-name* that names a class type, or a cv-qualified
-version thereof, is also 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
-(Clause  [[class]]), a constructor declaration ([[class.ctor]]), or a
-destructor declaration ([[class.dtor]]), the program is
-ill-formed. — *end note*]
 [*Example 8*:
 ``` cpp
 struct S {
@@ -399,40 +422,67 @@ S a = T();                      // OK
 struct T * p;                   // error
 ```
 — *end example*]
-If the typedef declaration defines an unnamed class (or enum), the first
-*typedef-name* declared by the declaration to be that class type (or
-enum type) is used to denote the class type (or enum type) for linkage
-purposes only ([[basic.link]]).
 [*Example 9*:
 ``` cpp
 typedef struct { } *ps, S;      // S is the class name for linkage purposes
 ```
 — *end example*]
 ### The `friend` specifier <a id="dcl.friend">[[dcl.friend]]</a>
 The `friend` specifier is used to specify access to class members; see
 [[class.friend]].
-### The `constexpr` specifier <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
 variable or variable template or the declaration of a function or
-function template. A function or static data member declared with the
-`constexpr` specifier is implicitly an inline function or variable (
-[[dcl.inline]]). If any declaration of a function or function template
-has a `constexpr` specifier, then all its declarations shall contain the
-`constexpr` specifier.
 [*Note 1*: An explicit specialization can differ from the template
-declaration with respect to the `constexpr` specifier. — *end note*]
 [*Note 2*: Function parameters cannot be declared
 `constexpr`. — *end note*]
 [*Example 1*:
@@ -447,11 +497,11 @@ constexpr struct pixel {        // error: pixel is a type
 };
 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
@@ -461,29 +511,33 @@ int next(constexpr int x) {     // error: not for parameters
 extern constexpr int memsz;     // error: not a definition
 ```
 — *end example*]
-A `constexpr` specifier used in the declaration of a function that is
-not a constructor declares that function to be a *constexpr function*.
-Similarly, a `constexpr` specifier used in a constructor declaration
-declares that constructor to be a *constexpr constructor*.
 The definition of a constexpr function shall satisfy the following
 requirements:
-- it shall not be virtual ([[class.virtual]]);
-- its return type shall be a literal type;
 - each of its parameter types shall be a literal type;
-- its *function-body* shall be `= delete`, `= default`, or a
-  *compound-statement* that does not contain
- - an *asm-definition*,
   - a `goto` statement,
-  - an identifier label ([[stmt.label]]),
-  - a *try-block*, or
   - a definition of a variable of non-literal type or of static or
-    thread storage duration or for which no initialization is performed.
 [*Example 2*:
 ``` cpp
 constexpr int square(int x)
@@ -498,12 +552,12 @@ constexpr int abs(int x) {
 constexpr int first(int n) {
   static int value = n;         // error: variable has static storage duration
   return value;
 }
 constexpr int uninit() {
-  int a;                        // error: variable is uninitialized
-  return a;
 }
 constexpr int prev(int x)
   { return --x; }               // OK
 constexpr int g(int x, int n) { // OK
   int r = 1;
@@ -512,30 +566,13 @@ constexpr int g(int x, int n) { // OK
 }
 ```
 — *end example*]
-The definition of a constexpr constructor shall satisfy the following
-requirements:
-- the class shall not have any virtual base classes;
-- each of the parameter types shall be a literal type;
-- its *function-body* shall not be a *function-try-block*.
-In addition, either its *function-body* shall be `= delete`, or it shall
-satisfy the following requirements:
-- either its *function-body* shall be `= default`, or the
-  *compound-statement* of its *function-body* shall satisfy the
-  requirements for a *function-body* of a constexpr function;
-- every non-variant non-static data member and base class subobject
-  shall be initialized ([[class.base.init]]);
-- if the class is a union having variant members ([[class.union]]),
-  exactly one of them shall be initialized;
-- if the class is a union-like class, but is not a union, for each of
-  its anonymous union members having variant members, exactly one of
-  them shall be initialized;
 - 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.
@@ -550,16 +587,23 @@ private:
 };
 ```
 — *end example*]
 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, a constant initializer for some object (
-[[basic.start.static]]), the program is ill-formed, no diagnostic
 required.
 [*Example 4*:
 ``` cpp
@@ -582,27 +626,33 @@ struct D : B {
 — *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 or constexpr constructor, that
-specialization is still a constexpr function or constexpr constructor,
-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 or constexpr constructor when
-considered as a non-template function or constructor, the template is
-ill-formed, no diagnostic required.
-A call to a constexpr function produces the same result as a call to an
-equivalent non-constexpr function in all respects except that
-- a call to a constexpr function can appear in a constant expression (
-  [[expr.const]]) and
-- copy elision is mandatory in a constant expression ([[class.copy]]).
-The `constexpr` specifier has no effect on the type of a constexpr
-function or a constexpr constructor.
 [*Example 5*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
@@ -613,14 +663,14 @@ int bar(int x, int y)                   // error: redefinition of bar
 ```
 — *end example*]
 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]]).
 [*Example 6*:
 ``` cpp
 struct pixel {
@@ -630,54 +680,86 @@ constexpr pixel ur = { 1294, 1024 };    // OK
 constexpr pixel origin;                 // error: initializer missing
 ```
 — *end example*]
 ### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
-The `inline` specifier can be applied only to the declaration or
-definition 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
 inline substitution is omitted, the other rules for inline functions
-specified in this section shall still be respected.
-A variable declaration with an `inline` specifier declares an *inline
-variable*.
-A function defined within a class definition is an inline function.
-The `inline` specifier shall not appear on a block scope
-declaration.[^2] If the `inline` specifier is used in a friend function
-declaration, that declaration shall be a definition or the function
-shall have previously been declared inline.
-An inline function or variable shall be defined in every translation
-unit in which it is odr-used and shall have exactly the same definition
-in every case ([[basic.def.odr]]).
-[*Note 1*: A call to the inline function or a use of the inline
-variable may be encountered before its definition appears in the
 translation unit. — *end note*]
-If the definition of a function or variable appears in a translation
-unit before its first declaration as inline, the program is ill-formed.
-If a function or variable with external linkage is declared inline in
-one translation unit, it shall be declared inline in all translation
-units in which it appears; no diagnostic is required. An inline function
-or variable with external linkage shall have the same address in all
-translation units.
-[*Note 2*: A `static` local variable in an inline function with
-external linkage always refers to the same object. A type defined within
-the body of an inline function with external linkage is the same type in
-every translation unit. — *end note*]
 ### Type specifiers <a id="dcl.type">[[dcl.type]]</a>
 The type-specifiers are
@@ -708,14 +790,14 @@ defining-type-specifier-seq:
   defining-type-specifier defining-type-specifier-seq
 ```
 The optional *attribute-specifier-seq* in a *type-specifier-seq* or a
 *defining-type-specifier-seq* appertains to the type denoted by the
-preceding *type-specifier*s or *defining-type-specifier*s (
-[[dcl.meaning]]). The *attribute-specifier-seq* affects the type only
-for the declaration it appears in, not other declarations involving the
-same type.
 As a general rule, at most one *defining-type-specifier* is allowed in
 the complete *decl-specifier-seq* of a *declaration* or in a
 *defining-type-specifier-seq*, and at most one *type-specifier* is
 allowed in a *type-specifier-seq*. The only exceptions to this rule are
@@ -730,16 +812,16 @@ the following:
 - `long` can be combined with `long`.
 Except in a declaration of a constructor, destructor, or conversion
 function, at least one *defining-type-specifier* that is not a
 *cv-qualifier* shall appear in a complete *type-specifier-seq* or a
-complete *decl-specifier-seq*.[^3]
 [*Note 1*: *enum-specifier*s, *class-specifier*s, and
-*typename-specifier*s are discussed in [[dcl.enum]], Clause  [[class]],
-and [[temp.res]], respectively. The remaining *type-specifier*s are
-discussed in the rest of this section. — *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
@@ -753,48 +835,47 @@ cv-qualifiers affect object and function types. — *end note*]
 Redundant cv-qualifications are ignored.
 [*Note 2*: For example, these could be introduced by
 typedefs. — *end note*]
-[*Note 3*: Declaring a variable `const` can affect its linkage (
-[[dcl.stc]]) and its usability in constant expressions (
-[[expr.const]]). As described in  [[dcl.init]], the definition of an
-object or subobject of const-qualified type must specify an initializer
-or be subject to default-initialization. — *end note*]
 A pointer or reference to a cv-qualified type need not actually point or
 refer to a cv-qualified object, but it is treated as if it does; a
 const-qualified access path cannot be used to modify an object even if
 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*]
-Except that any class member declared `mutable` ([[dcl.stc]]) can be
-modified, any attempt to modify a `const` object during its lifetime (
-[[basic.life]]) results in undefined behavior.
 [*Example 1*:
 ``` cpp
 const int ci = 3;                       // cv-qualified (initialized as required)
-ci = 4;                                 // ill-formed: 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;                               // ill-formed: 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
 const int* ciq = new const int (3);     // initialized as required
 int* iq = const_cast<int*>(ciq);        // cast required
-*iq = 4;                                // undefined: modifies a const object
 ```
 For another example,
 ``` cpp
@@ -807,14 +888,14 @@ struct Y {
   Y();
 };
 const Y y;
 y.x.i++;                                // well-formed: mutable member can be modified
-y.x.j++;                                // ill-formed: const-qualified member modified
 Y* p = const_cast<Y*>(&y);              // cast away const-ness of y
 p->x.i = 99;                            // well-formed: mutable member can be modified
-p->x.j = 99;                            // undefined: modifies a const member
 ```
 — *end example*]
 The semantics of an access through a volatile glvalue are
@@ -836,126 +917,226 @@ C. — *end note*]
 The simple type specifiers are
 ``` bnf
 simple-type-specifier:
     nested-name-specifierₒₚₜ type-name
-    nested-name-specifier 'template' simple-template-id
-    nested-name-specifierₒₚₜ template-name
-    'char'
-    'char16_t'
-    'char32_t'
-    'wchar_t'
-    'bool'
-    'short'
-    'int'
-    'long'
-    'signed'
-    'unsigned'
-    'float'
-    'double'
-    'void'
-    'auto'
     decltype-specifier
 ```
 ``` bnf
 type-name:
     class-name
     enum-name
     typedef-name
-    simple-template-id
 ```
 ``` bnf
-decltype-specifier:
-  'decltype' '(' expression ')'
-  'decltype' '(' 'auto' ')'
 ```
-The *simple-type-specifier* `auto` 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
-*template-name* shall name a class template that is not an
-injected-class-name. The other *simple-type-specifier*s specify either a
-previously-declared type, a type determined from an expression, or one
-of the fundamental types ([[basic.fundamental]]). Table
-[[tab:simple.type.specifiers]] summarizes the valid combinations of
-*simple-type-specifier*s and the types they specify.
-**Table: *simple-type-specifier*{s} and the types they specify** <a id="tab:simple.type.specifiers">[tab:simple.type.specifiers]</a>
 | Specifier(s)                 | Type                                              |
-| ---------------------- | -------------------------------------- |
 | *type-name*                  | the type named                                    |
 | *simple-template-id*         | the type as defined in~ [[temp.names]]            |
-| *template-name* | placeholder for a type to be deduced   |
-| char                   | ``char''                               |
-| unsigned char          | ``unsigned char''                      |
-| signed char | ``signed char'' |
-| char16_t               | ``char16_t'' |
-| char32_t               | ``char32_t'' |
-| bool                   | ``bool'' |
-| unsigned               | ``unsigned int'' |
-| unsigned int           | ``unsigned int'' |
-| signed                 | ``int'' |
-| signed int             | ``int''                                |
-| int | ``int''                                |
-| unsigned short int     | ``unsigned short int'' |
-| unsigned short         | ``unsigned short int'' |
-| unsigned long int | ``unsigned long int'' |
-| unsigned long          | ``unsigned long int'' |
-| unsigned long long int | ``unsigned long long int'' |
-| unsigned long long     | ``unsigned long long int'' |
-| signed long int        | ``long int''                           |
-| signed long | ``long int'' |
-| signed long long int   | ``long long int''                      |
-| signed long long       | ``long long int'' |
-| long long int          | ``long long int'' |
-| long long | ``long long int'' |
-| long int               | ``long int'' |
-| long | ``long int'' |
-| signed short int       | ``short int'' |
-| signed short           | ``short int'' |
-| short int              | ``short int'' |
-| short | ``short int'' |
-| wchar_t                | ``wchar_t'' |
-| float                  | ``float'' |
-| double                 | ``double'' |
-| long double            | ``long double'' |
-| void                   | ``void'' |
-| auto                   | placeholder for a type to be deduced   |
-| decltype(auto)         | placeholder for a type to be deduced   |
-| decltype(*expression*) | the type as defined below              |
 When multiple *simple-type-specifier*s are allowed, they can be freely
 intermixed with other *decl-specifier*s in any order.
-[*Note 1*: It is *implementation-defined* whether objects of `char`
 type are represented as signed or unsigned quantities. The `signed`
 specifier forces `char` objects to be signed; it is redundant in other
 contexts. — *end note*]
-For an expression `e`, the type denoted by `decltype(e)` is defined as
 follows:
-- if `e` is an unparenthesized *id-expression* naming a structured
- binding ([[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* 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
-(Clause  [[expr]]).
 [*Example 1*:
 ``` cpp
 const int&& foo();
@@ -968,29 +1149,30 @@ decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
 — *end example*]
-[*Note 2*: The rules for determining types involving `decltype(auto)`
 are specified in  [[dcl.spec.auto]]. — *end note*]
-If the operand of a *decltype-specifier* is a prvalue, the temporary
-materialization conversion is not applied ([[conv.rval]]) and no result
-object is provided for the prvalue. The type of the prvalue may be
-incomplete.
-[*Note 3*: As a result, storage is not allocated for the prvalue and it
 is not destroyed. Thus, a class type is not instantiated as a result of
 being the type of a function call in this context. In this context, the
 common purpose of writing the expression is merely to refer to its type.
 In that sense, a *decltype-specifier* is analogous to a use of a
 *typedef-name*, so the usual reasons for requiring a complete type do
 not apply. In particular, it is not necessary to allocate storage for a
 temporary object or to enforce the semantic constraints associated with
 invoking the type’s destructor. — *end note*]
-[*Note 4*: Unlike the preceding rule, parentheses have no special
 meaning in this context. — *end note*]
 [*Example 2*:
 ``` cpp
@@ -1005,149 +1187,74 @@ template<class T> auto f(T)     // #1
                                 // (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
                                 // used within the context of this decltype-specifier
 void r() {
-  q(42);                        // Error: deduction against q succeeds, so overload resolution selects
-                                // the specialization ``q(T) -> decltype((h<T>())) [with T=int]''.
-                                // The return type is A<int>, so a temporary is introduced and its
-                                // destructor is used, so the program is ill-formed.
 }
 ```
 — *end example*]
-#### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` 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
 ```
-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.
-[[basic.lookup.elab]] describes how name lookup proceeds for the
-*identifier* in an *elaborated-type-specifier*. If the *identifier*
-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*. If the
-*identifier* resolves to a *typedef-name* or the *simple-template-id*
-resolves to an alias template specialization, the
-*elaborated-type-specifier* is ill-formed.
-[*Note 1*:
-This implies that, within a class template with a template
-*type-parameter* `T`, the declaration
-``` cpp
-friend class T;
-```
-is ill-formed. However, the similar declaration `friend T;` is allowed (
-[[class.friend]]).
-— *end note*]
-The *class-key* or `enum` keyword present in the
-*elaborated-type-specifier* shall agree in kind with the declaration to
-which the name in the *elaborated-type-specifier* refers. This rule also
-applies to the form of *elaborated-type-specifier* that declares a
-*class-name* or `friend` class since it can be construed as referring to
-the definition of the class. Thus, in any *elaborated-type-specifier*,
-the `enum` keyword shall be used to refer to an enumeration (
-[[dcl.enum]]), the `union` *class-key* shall be used to refer to a union
-(Clause  [[class]]), and either the `class` or `struct` *class-key*
-shall be used to refer to a class (Clause  [[class]]) declared using the
-`class` or `struct` *class-key*.
-[*Example 1*:
-``` cpp
-enum class E { a, b };
-enum E x = E::a;                // OK
-```
-— *end example*]
-#### The `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` and `decltype(auto)` *type-specifier*s are used to designate
-a placeholder type that will be replaced later by deduction from an
-initializer. The `auto` *type-specifier* is also used to introduce a
-function type having a *trailing-return-type* or to signify that a
-lambda is a generic lambda ([[expr.prim.lambda.closure]]). The `auto`
-*type-specifier* is also used to introduce a structured binding
-declaration ([[dcl.struct.bind]]).
 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
 function. If the declared return type of the function contains a
 placeholder type, the return type of the function is deduced from
-non-discarded `return` statements, if any, in the body of the function (
-[[stmt.if]]).
-If the `auto` *type-specifier* appears as one of the *decl-specifier*s
-in the *decl-specifier-seq* of a *parameter-declaration* of a
-*lambda-expression*, the lambda is a *generic lambda* (
-[[expr.prim.lambda.closure]]).
-[*Example 1*:
-``` cpp
-auto glambda = [](int i, auto a) { return i; };     // OK: a generic lambda
-```
-— *end example*]
-The type of a variable declared using `auto` or `decltype(auto)` is
-deduced from its initializer. This use is allowed in an initializing
-declaration ([[dcl.init]]) of a variable. `auto` or `decltype(auto)`
-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 2*:
 ``` 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
@@ -1157,25 +1264,28 @@ 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*]
 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 `auto` or `decltype(auto)` in a context not
-explicitly allowed in this section 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 3*:
 ``` cpp
 auto x = 5, *y = &x;            // OK: auto is int
 auto a = 5, b = { 1, 2 };       // error: different types for auto
 ```
@@ -1190,53 +1300,60 @@ same in each deduction, the program is ill-formed.
 If a function with a declared return type that uses a placeholder type
 has no non-discarded `return` statements, the return type is deduced as
 though from a `return` statement with no operand at the closing brace of
 the function body.
-[*Example 4*:
 ``` cpp
 auto  f() { }                   // OK, return type is void
-auto* g() { }                   // error, cannot deduce auto* from void()
 ```
 — *end example*]
-If the type of an entity with an undeduced placeholder type is needed to
-determine the type of 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 5*:
 ``` cpp
-auto n = n;                     // error, n's type is unknown
 auto f();
-void g() { &f; }                // error, f's return type is unknown
 auto sum(int i) {
   if (i == 1)
     return i;                   // sum's return type is int
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 — *end example*]
-Return type deduction for a 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 1*: 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 (
-[[temp.deduct]]). — *end note*]
-[*Example 6*:
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
@@ -1246,49 +1363,61 @@ void g() { int (*p)(int*) = &f; }               // instantiates both fs to deter
 — *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.
-[*Example 7*:
 ``` 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
 template<> auto g(double);                      // OK, forward declaration with unknown return type
 template <class T> T g(T t) { return t; }       // OK, not functionally equivalent to #1
 template char g(char);                          // OK, now there is a matching template
 template auto g(float);                         // still matches #1
-void h() { return g(42); }                      // error, ambiguous
 template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
 ```
 — *end example*]
 A function declared with a return type that uses a placeholder type
-shall not be `virtual` ([[class.virtual]]).
-An explicit instantiation declaration ([[temp.explicit]]) does not
-cause the instantiation of an entity declared using a placeholder type,
-but it also does not prevent that entity from being instantiated as
-needed to determine its type.
-[*Example 8*:
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
@@ -1301,45 +1430,46 @@ 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 `decltype(auto)` or cv `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 is the `auto` *type-specifier*, the deduced type T'
-replacing `T` is determined using the rules for template argument
-deduction. Obtain `P` from `T` by replacing the occurrences of `auto`
-with either 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 9*:
 ``` cpp
 auto x1 = { 1, 2 };             // decltype(x1) is std::initializer_list<int>
 auto x2 = { 1, 2.0 };           // error: cannot deduce element type
 auto x3{ 1, 2 };                // error: not a single element
@@ -1347,11 +1477,11 @@ auto x4 = { 3 };                // decltype(x4) is std::initializer_list<int>
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
-[*Example 10*:
 ``` cpp
 const auto &i = expr;
 ```
@@ -1362,16 +1492,16 @@ The type of `i` is the deduced type of the parameter `u` in the call
 template <class U> void f(const U& u);
 ```
 — *end example*]
-If the placeholder is the `decltype(auto)` *type-specifier*, `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 11*:
 ``` cpp
 int i;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
@@ -1381,36 +1511,56 @@ decltype(auto) x3d = i;         // decltype(x3d) is int
 auto           x4a = (i);       // decltype(x4a) is int
 decltype(auto) x4d = (i);       // decltype(x4d) is int&
 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*]
 #### Deduced class template specialization types <a id="dcl.type.class.deduct">[[dcl.type.class.deduct]]</a>
 If a placeholder for a deduced class type appears as a *decl-specifier*
-in the *decl-specifier-seq* of an initializing declaration (
-[[dcl.init]]) of a variable, the placeholder is replaced by the return
-type of the function selected by overload resolution for class template
-deduction ([[over.match.class.deduct]]). If the *decl-specifier-seq* is
-followed by an *init-declarator-list* or *member-declarator-list*
-containing more than one *declarator*, the type that replaces the
-placeholder shall be the same in each deduction.
 A placeholder for a deduced class type can also be used in the
 *type-specifier-seq* in the *new-type-id* or *type-id* of a
-*new-expression* ([[expr.new]]), or as the *simple-type-specifier* in
-an explicit type conversion (functional notation) ([[expr.type.conv]]).
-A placeholder for a deduced class type shall not appear in any other
-context.
-[*Example 1*:
 ``` cpp
 template<class T> struct container {
     container(T t) {}
     template<class Iter> container(Iter beg, Iter end);
@@ -1419,10 +1569,10 @@ template<class Iter>
 container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;
 std::vector<double> v = { ... };
 container c(7);                         // OK, deduces int for T
 auto d = container(v.begin(), v.end()); // OK, deduces double for T
-container e{5, 6};                      // error, int is not an iterator
 ```
 — *end example*]

 ``` bnf
 decl-specifier:
     storage-class-specifier
     defining-type-specifier
     function-specifier
+    friend
+    typedef
+    constexpr
+ consteval
+    constinit
+    inline
 ```
 ``` bnf
 decl-specifier-seq:
     decl-specifier attribute-specifier-seqₒₚₜ
     decl-specifier decl-specifier-seq
 ```
 The optional *attribute-specifier-seq* in a *decl-specifier-seq*
+appertains to the type determined by the preceding *decl-specifier*s
+[[dcl.meaning]]. The *attribute-specifier-seq* affects the type only for
+the declaration it appears in, not other declarations involving the same
+type.
 Each *decl-specifier* shall appear at most once in a complete
+*decl-specifier-seq*, except that `long` may appear twice. At most one
+of the `constexpr`, `consteval`, and `constinit` keywords shall appear
+in a *decl-specifier-seq*.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
 is no previous *defining-type-specifier* other than a *cv-qualifier* in
 the *decl-specifier-seq*. The sequence shall be self-consistent as
 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
+    static
+    thread_local
+    extern
+    mutable
 ```
 At most one *storage-class-specifier* shall appear in a given
 *decl-specifier-seq*, except that `thread_local` may appear with
 `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*]
+[*Note 2*: A variable declared without a *storage-class-specifier* at
 block scope or declared as a function parameter has automatic storage
+duration by default [[basic.stc.auto]]. — *end note*]
 The `thread_local` specifier indicates that the named entity has thread
+storage duration [[basic.stc.thread]]. It shall be applied only to the
+declaration of a variable of namespace or block scope, to a structured
+binding declaration [[dcl.struct.bind]], or to the declaration of a
+static data member. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
+The `static` specifier shall be applied only to the declaration of a
+variable or function, to a structured binding declaration
+[[dcl.struct.bind]], or to the declaration of an anonymous union
+[[class.union.anon]]. There can be no `static` function declarations
+within a block, nor any `static` function parameters. A `static`
+specifier used in the declaration of a variable declares the variable to
+have static storage duration [[basic.stc.static]], unless accompanied by
+the `thread_local` specifier, which declares the variable to have thread
+storage duration [[basic.stc.thread]]. A `static` specifier can be used
+in declarations of class members;  [[class.static]] describes its
+effect. For the linkage of a name declared with a `static` specifier,
+see  [[basic.link]].
+The `extern` specifier shall be applied only to the declaration of a
+variable or function. The `extern` specifier shall not be used in the
+declaration of a class member or function parameter. For the linkage of
+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
 ```
 — *end example*]
 The `mutable` specifier shall appear only in the declaration of a
+non-static data member [[class.mem]] whose type is neither
 const-qualified nor a reference type.
 [*Example 3*:
 ``` cpp
 class X {
   mutable const int* p;         // OK
+  mutable int* const q;         // error
 };
 ```
 — *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.
 ``` bnf
 function-specifier:
+    virtual
+    explicit-specifier
+```
+``` bnf
+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]].
+In an *explicit-specifier*, the *constant-expression*, if supplied,
+shall be a contextually converted constant expression of type `bool`
+[[expr.const]]. The *explicit-specifier* `explicit` without a
+*constant-expression* is equivalent to the *explicit-specifier*
+`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
 `typedef` specifier shall not be combined in a *decl-specifier-seq* with
 any other kind of specifier except a *defining-type-specifier*, and it
 shall not be used in the *decl-specifier-seq* of a
+*parameter-declaration* [[dcl.fct]] nor in the *decl-specifier-seq* of a
+*function-definition* [[dcl.fct.def]]. If a `typedef` specifier appears
+in a declaration without a *declarator*, the program is ill-formed.
 ``` bnf
 typedef-name:
     identifier
+    simple-template-id
 ```
+A name declared with the `typedef` specifier becomes a *typedef-name*. A
+*typedef-name* names the type associated with the *identifier*
+[[dcl.decl]] or *simple-template-id* [[temp.pre]]; a *typedef-name* is
+thus a synonym for another type. A *typedef-name* does not introduce a
+new type the way a class declaration [[class.name]] or enum declaration
+[[dcl.enum]] does.
 [*Example 1*:
 After
 ``` 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 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*:
 };
 ```
 — *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.
 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*:
 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 {
 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
+- declare any members other than non-static data members, member
+  enumerations, or member classes,
+- have any base classes or default member initializers, or
+- 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
 ```
 — *end example*]
 ### The `friend` specifier <a id="dcl.friend">[[dcl.friend]]</a>
 The `friend` specifier is used to specify access to class members; see
 [[class.friend]].
+### The `constexpr` and `consteval` specifiers <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
 variable or variable template or the declaration of a function or
+function template. The `consteval` specifier shall be applied only to
+the declaration of a function or function template. A function or static
+data member declared with the `constexpr` or `consteval` specifier is
+implicitly an inline function or variable [[dcl.inline]]. If any
+declaration of a function or function template has a `constexpr` or
+`consteval` specifier, then all its declarations shall contain the same
+specifier.
 [*Note 1*: An explicit specialization can differ from the template
+declaration with respect to the `constexpr` or `consteval`
+specifier. — *end note*]
 [*Note 2*: Function parameters cannot be declared
 `constexpr`. — *end note*]
 [*Example 1*:
 };
 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
 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)
 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)
   { return --x; }               // OK
 constexpr int g(int x, int n) { // OK
   int r = 1;
 }
 ```
 — *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.
 };
 ```
 — *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
 — *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
+ expression [[expr.const]] and
+- copy elision is not performed in a constant expression
+  [[class.copy.elision]].
+[*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
 ```
 — *end example*]
 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 {
 constexpr pixel origin;                 // error: initializer missing
 ```
 — *end example*]
+### The `constinit` specifier <a id="dcl.constinit">[[dcl.constinit]]</a>
+The `constinit` specifier shall be applied only to a declaration of a
+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"; }
+constexpr const char * f(bool p) { return p ? "constant initializer" : g(); }
+constinit const char * c = f(true);     // OK
+constinit const char * d = f(false);    // error
+```
+— *end example*]
 ### 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
 inline substitution is omitted, the other rules for inline functions
+specified in this subclause shall still be respected.
+[*Note 1*: The `inline` keyword has no effect on the linkage of a
+function. In certain cases, an inline function cannot use names with
+internal linkage; see  [[basic.link]]. — *end note*]
+A variable declaration with an `inline` specifier declares an
+*inline variable*.
+The `inline` specifier shall not appear on a block scope declaration or
+on the declaration of a function parameter. If the `inline` specifier is
+used in a friend function declaration, that declaration shall be a
+definition or the function shall have previously been declared inline.
+If a definition of a function or variable is reachable at the point of
+its first declaration as inline, the program is ill-formed. If a
+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
   defining-type-specifier defining-type-specifier-seq
 ```
 The optional *attribute-specifier-seq* in a *type-specifier-seq* or a
 *defining-type-specifier-seq* appertains to the type denoted by the
+preceding *type-specifier*s or *defining-type-specifier*s
+[[dcl.meaning]]. The *attribute-specifier-seq* affects the type only for
+the declaration it appears in, not other declarations involving the same
+type.
 As a general rule, at most one *defining-type-specifier* is allowed in
 the complete *decl-specifier-seq* of a *declaration* or in a
 *defining-type-specifier-seq*, and at most one *type-specifier* is
 allowed in a *type-specifier-seq*. The only exceptions to this rule are
 - `long` can be combined with `long`.
 Except in a declaration of a constructor, destructor, or conversion
 function, at least one *defining-type-specifier* that is not a
 *cv-qualifier* shall appear in a complete *type-specifier-seq* or 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
 Redundant cv-qualifications are ignored.
 [*Note 2*: For example, these could be introduced by
 typedefs. — *end note*]
+[*Note 3*: Declaring a variable `const` can affect its linkage
+[[dcl.stc]] and its usability in constant expressions [[expr.const]]. As
+described in  [[dcl.init]], the definition of an object or subobject of
+const-qualified type must specify an initializer or be subject to
+default-initialization. — *end note*]
 A pointer or reference to a cv-qualified type need not actually point or
 refer to a cv-qualified object, but it is treated as if it does; a
 const-qualified access path cannot be used to modify an object even if
 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
 const int* ciq = new const int (3);     // initialized as required
 int* iq = const_cast<int*>(ciq);        // cast required
+*iq = 4;                                // undefined behavior: modifies a const object
 ```
 For another example,
 ``` cpp
   Y();
 };
 const Y y;
 y.x.i++;                                // well-formed: mutable member can be modified
+y.x.j++;                                // error: const-qualified member modified
 Y* p = const_cast<Y*>(&y);              // cast away const-ness of y
 p->x.i = 99;                            // well-formed: mutable member can be modified
+p->x.j = 99;                            // undefined behavior: modifies a const subobject
 ```
 — *end example*]
 The semantics of an access through a volatile glvalue are
 The simple type specifiers are
 ``` bnf
 simple-type-specifier:
     nested-name-specifierₒₚₜ type-name
+    nested-name-specifier template simple-template-id
     decltype-specifier
+    placeholder-type-specifier
+    nested-name-specifierₒₚₜ template-name
+    char
+    char8_t
+    char16_t
+    char32_t
+    wchar_t
+    bool
+    short
+    int
+    long
+    signed
+    unsigned
+    float
+    double
+    void
 ```
 ``` bnf
 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
+*template-name* shall name a deducible template. A *deducible template*
+is either a class template or is an alias template whose
+*defining-type-id* is of the form
 ``` bnf
+typenameₒₚₜ nested-name-specifierₒₚₜ templateₒₚₜ simple-template-id
 ```
+where the *nested-name-specifier* (if any) is non-dependent and the
+*template-name* of the *simple-template-id* names a deducible template.
+[*Note 1*: An injected-class-name is never interpreted as a
+*template-name* in contexts where class template argument deduction
+would be performed [[temp.local]]. — *end note*]
+The other *simple-type-specifier*s specify either a previously-declared
+type, a type determined from an expression, or one of the fundamental
+types [[basic.fundamental]]. [[dcl.type.simple]] summarizes the valid
+combinations of *simple-type-specifier*s and the types they specify.
+**Table: *simple-type-specifier*{s} and the types they specify** <a id="dcl.type.simple">[dcl.type.simple]</a>
 | Specifier(s)                 | Type                                              |
+| ---------------------------- | ------------------------------------------------- |
 | *type-name*                  | the type named                                    |
 | *simple-template-id*         | the type as defined in~ [[temp.names]]            |
+| *decltype-specifier* | the type as defined in~ [[dcl.type.decltype]]     |
+| *placeholder-type-specifier* | the type as defined in~ [[dcl.spec.auto]]         |
+| *template-name*              | the type as defined in~ [[dcl.type.class.deduct]] |
+| `char`                       | ```char`'' |
+| `unsigned char`              | ```unsigned char`'' |
+| `signed char`                | ```signed char`'' |
+| `char8_t`                    | ```char8_t`'' |
+| `char16_t`                   | ```char16_t`'' |
+| `char32_t`                   | ```char32_t`'' |
+| `bool`                       | ```bool`'' |
+| `unsigned`                   | ```unsigned int`''                                |
+| `unsigned int`               | ```unsigned int`''                                |
+| `signed`                     | ```int`'' |
+| `signed int`                 | ```int`'' |
+| `int`                        | ```int`'' |
+| `unsigned short int`         | ```unsigned short int`'' |
+| `unsigned short`             | ```unsigned short int`'' |
+| `unsigned long int`          | ```unsigned long int`'' |
+| `unsigned long`              | ```unsigned long int`''                           |
+| `unsigned long long int`     | ```unsigned long long int`'' |
+| `unsigned long long`         | ```unsigned long long int`''                      |
+| `signed long int`            | ```long int`'' |
+| `signed long`                | ```long int`'' |
+| `signed long long int`       | ```long long int`'' |
+| `signed long long`           | ```long long int`'' |
+| `long long int`              | ```long long int`'' |
+| `long long`                  | ```long long int`'' |
+| `long int`                   | ```long int`'' |
+| `long`                       | ```long int`'' |
+| `signed short int`           | ```short int`'' |
+| `signed short`               | ```short int`'' |
+| `short int`                  | ```short int`'' |
+| `short`                      | ```short int`'' |
+| `wchar_t`                    | ```wchar_t`'' |
+| `float`                      | ```float`'' |
+| `double`                     | ```double`''                                      |
+| `long double`                | ```long double`''                                 |
+| `void`                       | ```void`''                                        |
 When multiple *simple-type-specifier*s are allowed, they can be freely
 intermixed with other *decl-specifier*s in any order.
+[*Note 2*: It is *implementation-defined* whether objects of `char`
 type are represented as signed or unsigned quantities. The `signed`
 specifier forces `char` objects to be signed; it is redundant in other
 contexts. — *end note*]
+#### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
+``` 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
+friend class T;
+```
+is ill-formed. However, the similar declaration `friend T;` is allowed
+[[class.friend]].
+— *end note*]
+The *class-key* or `enum` keyword present in the
+*elaborated-type-specifier* shall agree in kind with the declaration to
+which the name in the *elaborated-type-specifier* refers. This rule also
+applies to the form of *elaborated-type-specifier* that declares a
+*class-name* or friend class since it can be construed as referring to
+the definition of the class. Thus, in any *elaborated-type-specifier*,
+the `enum` keyword shall be used to refer to an enumeration
+[[dcl.enum]], the `union` *class-key* shall be used to refer to a union
+[[class.union]], and either the `class` or `struct` *class-key* shall be
+used to refer to a non-union class [[class.pre]].
+[*Example 1*:
+``` cpp
+enum class E { a, b };
+enum E x = E::a;                // OK
+struct S { } s;
+class S* p = &s;                // OK
+```
+— *end example*]
+#### Decltype specifiers <a id="dcl.type.decltype">[[dcl.type.decltype]]</a>
+``` bnf
+decltype-specifier:
+  decltype '(' expression ')'
+```
+For an expression E, the type denoted by `decltype(E)` is defined as
 follows:
+- if E is an unparenthesized *id-expression* naming a structured binding
+  [[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();
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
 — *end example*]
+[*Note 1*: The rules for determining types involving `decltype(auto)`
 are specified in  [[dcl.spec.auto]]. — *end note*]
+If the operand of a *decltype-specifier* is a prvalue and is not a
+(possibly parenthesized) immediate invocation [[expr.const]], the
+temporary materialization conversion is not applied [[conv.rval]] and no
+result object is provided for the prvalue. The type of the prvalue may
+be incomplete or an abstract class type.
+[*Note 2*: As a result, storage is not allocated for the prvalue and it
 is not destroyed. Thus, a class type is not instantiated as a result of
 being the type of a function call in this context. In this context, the
 common purpose of writing the expression is merely to refer to its type.
 In that sense, a *decltype-specifier* is analogous to a use of a
 *typedef-name*, so the usual reasons for requiring a complete type do
 not apply. In particular, it is not necessary to allocate storage for a
 temporary object or to enforce the semantic constraints associated with
 invoking the type’s destructor. — *end note*]
+[*Note 3*: Unlike the preceding rule, parentheses have no special
 meaning in this context. — *end note*]
 [*Example 2*:
 ``` cpp
                                 // (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
                                 // used within the context of this decltype-specifier
 void r() {
+  q(42);                        // error: deduction against q succeeds, so overload resolution selects
+                                // the specialization ``q(T) -> decltype((h<T>()))'' with T=int;
+                                // the return type is A<int>, so a temporary is introduced and its
+                                // destructor is used, so the program is ill-formed
 }
 ```
 — *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 ')'
 ```
+A *placeholder-type-specifier* designates a placeholder type that will
+be replaced later by deduction from an initializer.
+A *placeholder-type-specifier* of the form *type-constraint*ₒₚₜ  `auto`
+can be used as a *decl-specifier* of the *decl-specifier-seq* of a
+*parameter-declaration* of a function declaration or *lambda-expression*
+and, if it is not the `auto` *type-specifier* introducing a
+*trailing-return-type* (see below), is a *generic parameter type
+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
 function. If the declared return type of the function contains a
 placeholder type, the return type of the function is deduced from
+non-discarded `return` statements, if any, in the body of the function
+[[stmt.if]].
+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 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
 ```
 If a function with a declared return type that uses a placeholder type
 has no non-discarded `return` statements, the return type is deduced as
 though from a `return` statement with no operand at the closing brace of
 the function body.
+[*Example 3*:
 ``` cpp
 auto  f() { }                   // OK, return type is void
+auto* g() { }                   // error: cannot deduce auto* from void()
 ```
 — *end example*]
+An exported function with a declared return type that uses a placeholder
+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
 auto f();
+void g() { &f; }                // error: f's return type is unknown
 auto sum(int i) {
   if (i == 1)
     return i;                   // sum's return type is int
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 — *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
+[[temp.deduct]]. — *end note*]
+[*Example 5*:
 ``` cpp
 template <class T> auto f(T t) { return t; }    // return type deduced at instantiation time
 typedef decltype(f(1)) fint_t;                  // instantiates f<int> to deduce return type
 template<class T> auto f(T* t) { return *t; }
 — *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
 template<> auto g(double);                      // OK, forward declaration with unknown return type
 template <class T> T g(T t) { return t; }       // OK, not functionally equivalent to #1
 template char g(char);                          // OK, now there is a matching template
 template auto g(float);                         // still matches #1
+void h() { return g(42); }                      // error: ambiguous
 template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
+extern int v;
+auto v = 17;                                    // OK, redeclares v
+struct S {
+  static int i;
+};
+auto S::i = 23;                                 // OK
 ```
 — *end example*]
 A function declared with a return type that uses a placeholder type
+shall not be `virtual` [[class.virtual]].
+A function declared with a return type that uses a placeholder type
+shall not be a coroutine [[dcl.fct.def.coroutine]].
+An explicit instantiation declaration [[temp.explicit]] does not cause
+the instantiation of an entity declared using a placeholder type, but it
+also does not prevent that entity from being instantiated as needed to
+determine its type.
+[*Example 7*:
 ``` cpp
 template <typename T> auto f(T t) { return t; }
 extern template auto f(int);    // does not instantiate f<int>
 int (*p)(int) = f;              // instantiates f<int> to determine its return type, but an explicit
 *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>
 auto x2 = { 1, 2.0 };           // error: cannot deduce element type
 auto x3{ 1, 2 };                // error: not a single element
 auto x5{ 3 };                   // decltype(x5) is int
 ```
 — *end example*]
+[*Example 9*:
 ``` cpp
 const auto &i = expr;
 ```
 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;
 int&& f();
 auto           x2a(i);          // decltype(x2a) is int
 auto           x4a = (i);       // decltype(x4a) is int
 decltype(auto) x4d = (i);       // decltype(x4d) is int&
 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
+immediately-declared constraint [[temp.param]] of the *type-constraint*
+for the type deduced for the placeholder shall be satisfied.
 #### Deduced class template specialization types <a id="dcl.type.class.deduct">[[dcl.type.class.deduct]]</a>
 If a placeholder for a deduced class type appears as a *decl-specifier*
+in the *decl-specifier-seq* of an initializing declaration [[dcl.init]]
+of a variable, the declared type of the variable shall be cv `T`, where
+`T` is the placeholder.
+[*Example 1*:
+``` cpp
+template <class ...T> struct A {
+  A(T...) {}
+};
+A x[29]{};          // error: no declarator operators allowed
+const A& y{};       // error: no declarator operators allowed
+```
+— *end example*]
+The placeholder is replaced by the return type of the function selected
+by overload resolution for class template deduction
+[[over.match.class.deduct]]. If the *decl-specifier-seq* is followed by
+an *init-declarator-list* or *member-declarator-list* containing more
+than one *declarator*, the type that replaces the placeholder shall be
+the same in each deduction.
 A placeholder for a deduced class type can also be used in the
 *type-specifier-seq* in the *new-type-id* or *type-id* of a
+*new-expression* [[expr.new]], as the *simple-type-specifier* in an
+explicit type conversion (functional notation) [[expr.type.conv]], or as
+the *type-specifier* in the *parameter-declaration* of a
+*template-parameter* [[temp.param]]. A placeholder for a deduced class
+type shall not appear in any other context.
+[*Example 2*:
 ``` cpp
 template<class T> struct container {
     container(T t) {}
     template<class Iter> container(Iter beg, Iter end);
 container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;
 std::vector<double> v = { ... };
 container c(7);                         // OK, deduces int for T
 auto d = container(v.begin(), v.end()); // OK, deduces double for T
+container e{5, 6};                      // error: int is not an iterator
 ```
 — *end example*]

Diff to HTML by rtfpessoa