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

Files changed (1) hide show

tmp/tmpbod9_l3r/{from.md → to.md} +372 -304

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

@@ -29,14 +29,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
@@ -51,16 +51,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
@@ -74,48 +74,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
@@ -128,14 +127,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
@@ -157,126 +156,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();
@@ -289,29 +388,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
@@ -326,149 +426,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
@@ -478,25 +503,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
 ```
@@ -511,53 +539,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; }
@@ -567,49 +602,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
@@ -622,45 +669,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
@@ -668,11 +716,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;
 ```
@@ -683,16 +731,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
@@ -702,36 +750,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);
@@ -740,10 +808,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*]

   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