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

Files changed (1) hide show

tmp/tmpdzqdi1xo/{from.md → to.md} +346 -190

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

@@ -2,17 +2,10 @@
 The type-specifiers are
 ``` bnf
 type-specifier:
-    trailing-type-specifier
-    class-specifier
-    enum-specifier
-```
-``` bnf
-trailing-type-specifier:
   simple-type-specifier
   elaborated-type-specifier
   typename-specifier
   cv-qualifier
 ```
@@ -22,74 +15,91 @@ type-specifier-seq:
     type-specifier attribute-specifier-seqₒₚₜ
     type-specifier type-specifier-seq
 ```
 ``` bnf
-trailing-type-specifier-seq:
-  trailing-type-specifier attribute-specifier-seqₒₚₜ
-  trailing-type-specifier trailing-type-specifier-seq
 ```
 The optional *attribute-specifier-seq* in a *type-specifier-seq* or a
-*trailing-type-specifier-seq* appertains to the type denoted by the
-preceding *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 *type-specifier* is allowed in the
-complete *decl-specifier-seq* of a *declaration* or in a
-*type-specifier-seq* or *trailing-type-specifier-seq*. The only
-exceptions to this rule are the following:
 - `const` can be combined with any type specifier except itself.
 - `volatile` can be combined with any type specifier except itself.
 - `signed` or `unsigned` can be combined with `char`, `long`, `short`,
   or `int`.
 - `short` or `long` can be combined with `int`.
 - `long` can be combined with `double`.
 - `long` can be combined with `long`.
 Except in a declaration of a constructor, destructor, or conversion
-function, at least one *type-specifier* that is not a *cv-qualifier*
-shall appear in a complete *type-specifier-seq* or a complete
-*decl-specifier-seq*.[^3] A *type-specifier-seq* shall not define a
-class or enumeration unless it appears in the *type-id* of an
-*alias-declaration* ([[dcl.typedef]]) that is not the *declaration* of
-a *template-declaration*.
-*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.
-#### The *cv-qualifiers* <a id="dcl.type.cv">[[dcl.type.cv]]</a>
-There are two *cv-qualifiers*, `const` and `volatile`. Each
 *cv-qualifier* shall appear at most once in a *cv-qualifier-seq*. If a
 *cv-qualifier* appears in a *decl-specifier-seq*, the
-*init-declarator-list* of the declaration shall not be empty.
-[[basic.type.qualifier]] and [[dcl.fct]] describe how cv-qualifiers
-affect object and function types. Redundant cv-qualifications are
-ignored. For example, these could be introduced by typedefs.
-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.
 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. Cv-qualifiers are supported by the type system
-so that they cannot be subverted without casting ([[expr.const.cast]]).
 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.
 ``` cpp
 const int ci = 3;                       // cv-qualified (initialized as required)
 ci = 4;                                 // ill-formed: attempt to modify const
 int i = 2;                              // not cv-qualified
@@ -104,11 +114,11 @@ ip = const_cast<int*>(cip);     // cast needed to convert const int* to int*
 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
 struct X {
   mutable int i;
   int j;
@@ -124,31 +134,35 @@ 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
 ```
-What constitutes an access to an object that has volatile-qualified type
-is implementation-defined. If an attempt is made to refer to an object
-defined with a volatile-qualified type through the use of a glvalue with
-a non-volatile-qualified type, the program behavior is undefined.
-`volatile` is a hint to the implementation to avoid aggressive
-optimization involving the object because the value of the object might
-be changed by means undetectable by an implementation. Furthermore, for
-some implementations, `volatile` might indicate that special hardware
-instructions are required to access the object. See  [[intro.execution]]
-for detailed semantics. In general, the semantics of `volatile` are
-intended to be the same in C++as they are in C.
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 The simple type specifiers are
 ``` bnf
 simple-type-specifier:
     nested-name-specifierₒₚₜ type-name
     nested-name-specifier 'template' simple-template-id
     'char'
     'char16_t'
     'char32_t'
     'wchar_t'
     'bool'
@@ -176,23 +190,28 @@ type-name:
 decltype-specifier:
   'decltype' '(' expression ')'
   'decltype' '(' 'auto' ')'
 ```
-The `auto` specifier is a placeholder for a type to be deduced (
-[[dcl.spec.auto]]). 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>
-| | |
 | ---------------------- | -------------------------------------- |
 | *type-name*            | the type named                         |
 | *simple-template-id*   | the type as defined in~ [[temp.names]] |
 | char                   | ``char''                               |
 | unsigned char          | ``unsigned char''                      |
 | signed char            | ``signed char''                        |
 | char16_t               | ``char16_t''                           |
 | char32_t               | ``char32_t''                           |
@@ -224,90 +243,109 @@ of the fundamental types ([[basic.fundamental]]). Table
 | float                  | ``float''                              |
 | double                 | ``double''                             |
 | long double            | ``long double''                        |
 | void                   | ``void''                               |
 | auto                   | placeholder for a type to be deduced   |
 | decltype(*expression*) | the type as defined below              |
-When multiple *simple-type-specifiers* are allowed, they can be freely
-intermixed with other *decl-specifiers* in any order. 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.
 For an expression `e`, the type denoted by `decltype(e)` is defined as
 follows:
-- 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]]).
 ``` cpp
 const int&& foo();
 int i;
 struct A { double x; };
 const A* a = new A();
-decltype(foo()) x1 = 0; // type is const int&&
 decltype(i) x2;                 // type is int
 decltype(a->x) x3;              // type is double
 decltype((a->x)) x4 = x3;       // type is const double&
 ```
-The rules for determining types involving `decltype(auto)` are specified
-in  [[dcl.spec.auto]].
-in the case where the operand of a *decltype-specifier* is a function
-call and the return type of the function is a class type, a special
-rule ([[expr.call]]) ensures that the return type is not required to be
-complete (as it would be if the call appeared in a sub-expression or
-outside of a *decltype-specifier*). 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.
 ``` cpp
 template<class T> struct A { ~A() = delete; };
 template<class T> auto h()
   -> A<T>;
 template<class T> auto i(T)     // identity
   -> T;
 template<class T> auto f(T)     // #1
-  -> decltype(i(h<T>()));       // forces completion of A<T> and implicitly uses
-                                // A<T>::~A() for the temporary introduced by the
-                                // use of h(). (A temporary is not introduced
-                                // as a result of the use of i().)
 template<class T> auto f(T)     // #2
   -> void;
 auto g() -> void {
-  f(42);                        // OK: calls #2. (#1 is not a viable candidate: type
-                                // deduction fails~([temp.deduct]) because A<int>::~{A()}
-                                // is implicitly used in its decltype-specifier)
 }
 template<class T> auto q(T)
-  -> decltype((h<T>()));        // does not force completion of A<T>; A<T>::~A() is
-                                // not implicitly 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.
 }
 ```
 #### 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
@@ -341,20 +379,26 @@ class whenever it is named.
 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. 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]]).
 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
@@ -363,164 +407,130 @@ 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*.
 ``` cpp
 enum class E { a, b };
 enum E x = E::a;                // OK
 ```
-#### `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` and `decltype(auto)` *type-specifier*s designate a
-placeholder type that will be replaced later, either by deduction from
-an initializer or by explicit specification with a
-*trailing-return-type*. The `auto` *type-specifier* is also used to
-signify that a lambda is a generic lambda.
 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 specifies the declared return type of the function.
-If the declared return type of the function contains a placeholder type,
-the return type of the function is deduced from `return` statements in
-the body of the function, if any.
 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]]).
 ``` cpp
 auto glambda = [](int i, auto a) { return i; };     // OK: a generic lambda
 ```
 The type of a variable declared using `auto` or `decltype(auto)` is
-deduced from its initializer. This use is allowed when declaring
-variables in a block ([[stmt.block]]), in namespace scope (
-[[basic.scope.namespace]]), and in a  ([[stmt.for]]). `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 *init-declarator*s, each of which shall have a non-empty
 *initializer*. In an *initializer* of the form
 ``` cpp
 ( expression-list )
 ```
 the *expression-list* shall be a single *assignment-expression*.
 ``` cpp
 auto x = 5;                     // OK: x has type int
 const auto *v = &x, u = 6;      // OK: v has type const int*, u has type const int
 static auto y = 0.0;            // OK: y has type double
 auto int r;                     // error: auto is not a storage-class-specifier
 auto f() -> int;                // OK: f returns int
 auto g() { return 0.0; }        // OK: g returns double
 auto h();                       // OK: h's return type will be deduced when it is defined
 ```
-A placeholder type can also be used in declaring a variable in the of a
-selection statement ([[stmt.select]]) or an iteration statement (
-[[stmt.iter]]), in the in the or of a  ([[expr.new]]), in a
-*for-range-declaration*, and in declaring a static data member with a
-*brace-or-equal-initializer* that appears within the of a class
-definition ([[class.static.data]]).
 A program that uses `auto` or `decltype(auto)` in a context not
 explicitly allowed in this section is ill-formed.
-When a variable declared using a placeholder type is initialized, or a
-`return` statement occurs in a function declared with a return type that
-contains a placeholder type, the deduced return type or variable type is
-determined from the type of its initializer. In the case of a `return`
-with no operand, the initializer is considered to be `void()`. Let `T`
-be the declared type of the variable or return type of the function. If
-the placeholder is the `auto` *type-specifier*, the deduced type is
-determined using the rules for template argument deduction. If the
-deduction is for a `return` statement and the initializer is a
-*braced-init-list* ([[dcl.init.list]]), the program is ill-formed.
-Otherwise, obtain `P` from `T` by replacing the occurrences of `auto`
-with either a new invented type template parameter `U` or, if the
-initializer is a *braced-init-list*, 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 initializer is the corresponding
-argument. If the deduction fails, the declaration is ill-formed.
-Otherwise, the type deduced for the variable or return type is obtained
-by substituting the deduced `U` into `P`.
-``` cpp
-auto x1 = { 1, 2 };         // decltype(x1) is std::initializer_list<int>
-auto x2 = { 1, 2.0 };       // error: cannot deduce element type
-```
-``` cpp
-const auto &i = expr;
-```
-The type of `i` is the deduced type of the parameter `u` in the call
-`f(expr)` of the following invented function template:
-``` cpp
-template <class U> void f(const U& u);
-```
-If the placeholder is the `decltype(auto)` *type-specifier*, the
-declared type of the variable or return type of the function shall be
-the placeholder alone. The type deduced for the variable or return type
-is determined as described in  [[dcl.type.simple]], as though the
-initializer had been the operand of the `decltype`.
-``` cpp
-int i;
-int&& f();
-auto           x3a = i;        // decltype(x3a) is int
-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)
-```
 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 as described above, and if the type that replaces
-the placeholder type is not the same in each deduction, the program is
-ill-formed.
 ``` 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 contains a placeholder
-type has multiple `return` statements, the return type is deduced for
-each `return` statement. If the type deduced is not the same in each
-deduction, the program is ill-formed.
 If a function with a declared return type that uses a placeholder type
-has no `return` statements, the return type is deduced as though from a
-`return` statement with no operand at the closing brace of the function
-body.
 ``` cpp
 auto  f() { }                   // OK, return type is void
 auto* g() { }                   // error, cannot deduce auto* from void()
 ```
 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
-`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.
 ``` cpp
 auto n = n;                     // error, n's type is unknown
 auto f();
 void g() { &f; }                // error, f's return type is unknown
@@ -530,30 +540,41 @@ auto sum(int i) {
   else
     return sum(i-1)+i;          // OK, sum's return type has been deduced
 }
 ```
 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. 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.
 ``` 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; }
 void g() { int (*p)(int*) = &f; }               // instantiates both fs to determine return types,
                                                 // chooses second
 ```
 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.
 ``` cpp
 auto f();
 auto f() { return 42; }                         // return type is int
 auto f();                                       // OK
 int f();                                        // error, cannot be overloaded with auto f()
@@ -574,20 +595,155 @@ template <typename T> struct A {
   friend T frf(T);
 };
 auto frf(int i) { return i; }                   // not a friend of A<int>
 ```
 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.
 ``` 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
                                 // instantiation definition is still required somewhere in the program
 ```

 The type-specifiers are
 ``` bnf
 type-specifier:
   simple-type-specifier
   elaborated-type-specifier
   typename-specifier
   cv-qualifier
 ```
     type-specifier attribute-specifier-seqₒₚₜ
     type-specifier type-specifier-seq
 ```
 ``` bnf
+defining-type-specifier:
+ type-specifier
+    class-specifier
+    enum-specifier
+```
+``` bnf
+defining-type-specifier-seq:
+  defining-type-specifier attribute-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
+the following:
 - `const` can be combined with any type specifier except itself.
 - `volatile` can be combined with any type specifier except itself.
 - `signed` or `unsigned` can be combined with `char`, `long`, `short`,
   or `int`.
 - `short` or `long` can be combined with `int`.
 - `long` can be combined with `double`.
 - `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
 *cv-qualifier* appears in a *decl-specifier-seq*, the
+*init-declarator-list* or *member-declarator-list* of the declaration
+shall not be empty.
+[*Note 1*:  [[basic.type.qualifier]] and [[dcl.fct]] describe how
+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* 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
 struct X {
   mutable int i;
   int j;
 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
+*implementation-defined*. If an attempt is made to access an object
+defined with a volatile-qualified type through the use of a non-volatile
+glvalue, the behavior is undefined.
+[*Note 5*: `volatile` is a hint to the implementation to avoid
+aggressive optimization involving the object because the value of the
+object might be changed by means undetectable by an implementation.
+Furthermore, for some implementations, `volatile` might indicate that
+special hardware instructions are required to access the object. See
+[[intro.execution]] for detailed semantics. In general, the semantics of
+`volatile` are intended to be the same in C++as they are in
+C. — *end note*]
 #### Simple type specifiers <a id="dcl.type.simple">[[dcl.type.simple]]</a>
 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'
 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''                           |
 | 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();
 int i;
 struct A { double x; };
 const A* a = new A();
+decltype(foo()) x1 = 17; // type is const int&&
 decltype(i) x2;                 // type is int
 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
 template<class T> struct A { ~A() = delete; };
 template<class T> auto h()
   -> A<T>;
 template<class T> auto i(T)     // identity
   -> T;
 template<class T> auto f(T)     // #1
+  -> decltype(i(h<T>()));       // forces completion of A<T> and implicitly uses A<T>::~A()
+                                // for the temporary introduced by the use of h().
+                                // (A temporary is not introduced as a result of the use of i().)
 template<class T> auto f(T)     // #2
   -> void;
 auto g() -> void {
+  f(42);                        // OK: calls #2. (#1 is not a viable candidate: type deduction
+                                // fails~([temp.deduct]) because A<int>::~{A()} is implicitly used in its
+                                // decltype-specifier)
 }
 template<class T> auto q(T)
+  -> decltype((h<T>()));        // does not force completion of A<T>; A<T>::~A() is not implicitly
+                                // 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
 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
 [[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
 auto int r;                     // error: auto is not a storage-class-specifier
 auto f() -> int;                // OK: f returns int
 auto g() { return 0.0; }        // OK: g returns double
 auto h();                       // OK: h's return type will be deduced when it is defined
 ```
+— *end example*]
+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
 ```
+— *end example*]
 If a function with a declared return type that contains a placeholder
+type has multiple non-discarded `return` statements, the return type is
+deduced for each such `return` statement. If the type deduced is not the
+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
   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; }
 void g() { int (*p)(int*) = &f; }               // instantiates both fs to determine return types,
                                                 // chooses second
 ```
+— *end example*]
 Redeclarations or specializations of a function or function template
 with a declared return type that uses a placeholder type shall also use
 that placeholder, not a deduced type.
+[*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()
   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
                                 // instantiation definition is still required somewhere in the program
 ```
+— *end example*]
+##### Placeholder type deduction <a id="dcl.type.auto.deduct">[[dcl.type.auto.deduct]]</a>
+*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
+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;
+```
+The type of `i` is the deduced type of the parameter `u` in the call
+`f(expr)` of the following invented function template:
+``` cpp
+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
+decltype(auto) x2d(i);          // decltype(x2d) is int
+auto           x3a = i;         // decltype(x3a) is int
+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);
+};
+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*]

Diff to HTML by rtfpessoa