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

Files changed (1) hide show

tmp/tmpu_7iaep2/{from.md → to.md} +588 -326

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

@@ -3,15 +3,16 @@
 The specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
-    type-specifier
     function-specifier
     'friend'
     'typedef'
     'constexpr'
 ```
 ``` bnf
 decl-specifier-seq:
     decl-specifier attribute-specifier-seqₒₚₜ
@@ -22,15 +23,20 @@ The optional *attribute-specifier-seq* in a *decl-specifier-seq*
 appertains to the type determined by the preceding *decl-specifier*s (
 [[dcl.meaning]]). The *attribute-specifier-seq* affects the type only
 for the declaration it appears in, not other declarations involving the
 same type.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
-is no previous *type-specifier* other than a *cv-qualifier* in the
-*decl-specifier-seq*. The sequence shall be self-consistent as described
-below.
 ``` cpp
 typedef char* Pc;
 static Pc;                      // error: name missing
 ```
@@ -45,26 +51,35 @@ For another example,
 ``` cpp
 void f(const Pc);               // void f(char* const) (not const char*)
 void g(const int Pc);           // void g(const int)
 ```
 Since `signed`, `unsigned`, `long`, and `short` by default imply `int`,
 a *type-name* appearing after one of those specifiers is treated as the
 name being (re)declared.
 ``` cpp
 void h(unsigned Pc);            // void h(unsigned int)
 void k(unsigned int Pc);        // void k(unsigned int)
 ```
 ### Storage class specifiers <a id="dcl.stc">[[dcl.stc]]</a>
 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
-    'register'
     'static'
     'thread_local'
     'extern'
     'mutable'
 ```
@@ -73,70 +88,68 @@ At most one *storage-class-specifier* shall appear in a given
 *decl-specifier-seq*, except that `thread_local` may appear with
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
-*init-declarator-list* of the declaration shall not be empty (except for
-an anonymous union declared in a named namespace or in the global
-namespace, which shall be declared `static` ([[class.union]])). The
-*storage-class-specifier* applies to the name declared by each
-*init-declarator* in the list and not to any names declared by other
-specifiers. A *storage-class-specifier* shall not be specified in an
-explicit specialization ([[temp.expl.spec]]) or an explicit
-instantiation ([[temp.explicit]]) directive.
-The `register` specifier shall be applied only to names of variables
-declared in a block ([[stmt.block]]) or to function parameters (
-[[dcl.fct.def]]). It specifies that the named variable has automatic
-storage duration ([[basic.stc.auto]]). A variable declared without a
-*storage-class-specifier* at block scope or declared as a function
-parameter has automatic storage duration by default.
-A `register` specifier is a hint to the implementation that the variable
-so declared will be heavily used. The hint can be ignored and in most
-implementations it will be ignored if the address of the variable is
-taken. This use is deprecated (see  [[depr.register]]).
 The `thread_local` specifier indicates that the named entity has thread
 storage duration ([[basic.stc.thread]]). It shall be applied only to
 the names of variables of namespace or block scope and to the names of
 static data members. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
 The `static` specifier can be applied only to names of variables and
-functions and to anonymous unions ([[class.union]]). There can be no
-`static` function declarations within a block, nor any `static` function
-parameters. A `static` specifier used in the declaration of a variable
-declares the variable to have static storage duration (
 [[basic.stc.static]]), unless accompanied by the `thread_local`
 specifier, which declares the variable to have thread storage duration (
 [[basic.stc.thread]]). A `static` specifier can be used in declarations
 of class members;  [[class.static]] describes its effect. For the
 linkage of a name declared with a `static` specifier, see
 [[basic.link]].
 The `extern` specifier can be applied only to the names of variables and
 functions. The `extern` specifier cannot be used in the declaration of
 class members or function parameters. For the linkage of a name declared
-with an `extern` specifier, see  [[basic.link]]. The `extern` keyword
-can also be used in s and s, but it is not a in such contexts.
 The linkages implied by successive declarations for a given entity shall
 agree. That is, within a given scope, each declaration declaring the
 same variable name or the same overloading of a function name shall
 imply the same linkage. Each function in a given set of overloaded
 functions can have a different linkage, however.
 ``` cpp
 static char* f();               // f() has internal linkage
 char* f()                       // f() still has internal linkage
-  { /* ... */ }
 char* g();                      // g() has external linkage
 static char* g()                // error: inconsistent linkage
-  { /* ... */ }
 void h();
 inline void h();                // external linkage
 inline void l();
@@ -159,14 +172,18 @@ static int c;                   // error: inconsistent linkage
 extern int d;                   // d has external linkage
 static int d;                   // error: inconsistent linkage
 ```
 The name of a declared but undefined class can be used in an `extern`
 declaration. Such a declaration can only be used in ways that do not
 require a complete class type.
 ``` cpp
 struct S;
 extern S a;
 extern S f();
 extern void g(S);
@@ -175,21 +192,27 @@ void h() {
   g(a);                         // error: S is incomplete
   f();                          // error: S is incomplete
 }
 ```
-The `mutable` specifier can be applied only to names of class data
-members ([[class.mem]]) and cannot be applied to names declared `const`
-or `static`, and cannot be applied to reference members.
 ``` cpp
 class X {
   mutable const int* p;         // OK
   mutable int* const q;         // ill-formed
 };
 ```
 The `mutable` specifier on a class data member nullifies a `const`
 specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
 object is `const` ([[dcl.type.cv]]).
@@ -197,48 +220,14 @@ object is `const` ([[dcl.type.cv]]).
 can be used only in function declarations.
 ``` bnf
 function-specifier:
-    'inline'
     'virtual'
     'explicit'
 ```
-A function declaration ([[dcl.fct]],  [[class.mfct]], [[class.friend]])
-with an `inline` specifier declares an *inline function*. The inline
-specifier indicates to the implementation that inline substitution of
-the function body at the point of call is to be preferred to the usual
-function call mechanism. An implementation is not required to perform
-this inline substitution at the point of call; however, even if this
-inline substitution is omitted, the other rules for inline functions
-defined by  [[dcl.fct.spec]] shall still be respected.
-A function defined within a class definition is an inline function. The
-`inline` specifier shall not appear on a block scope function
-declaration.[^2] If the `inline` specifier is used in a friend
-declaration, that declaration shall be a definition or the function
-shall have previously been declared inline.
-An inline function shall be defined in every translation unit in which
-it is odr-used and shall have exactly the same definition in every
-case ([[basic.def.odr]]). A call to the inline function may be
-encountered before its definition appears in the translation unit. If
-the definition of a function appears in a translation unit before its
-first declaration as inline, the program is ill-formed. If a function
-with external linkage is declared inline in one translation unit, it
-shall be declared inline in all translation units in which it appears;
-no diagnostic is required. An `inline` function with external linkage
-shall have the same address in all translation units. A `static` local
-variable in an `extern` `inline` function always refers to the same
-object. A string literal in the body of an `extern` `inline` function is
-the same object in different translation units. A string literal
-appearing in a default argument is not in the body of an inline function
-merely because the expression is used in a function call from that
-inline function. A type defined within the body of an `extern inline`
-function is the same type in every translation unit.
 The `virtual` specifier shall be used only in the initial declaration of
 a non-static class member function; see  [[class.virtual]].
 The `explicit` specifier shall be used only in the declaration of a
 constructor or conversion function within its class definition; see
@@ -248,14 +237,16 @@ constructor or conversion function within its class definition; see
 Declarations containing the *decl-specifier* `typedef` declare
 identifiers that can be used later for naming fundamental (
 [[basic.fundamental]]) or compound ([[basic.compound]]) types. The
 `typedef` specifier shall not be combined in a *decl-specifier-seq* with
-any other kind of specifier except a *type-specifier,* and it shall not
-be used in the *decl-specifier-seq* of a *parameter-declaration* (
-[[dcl.fct]]) nor in the *decl-specifier-seq* of a
-*function-definition* ([[dcl.fct.def]]).
 ``` bnf
 typedef-name:
     identifier
 ```
@@ -264,11 +255,15 @@ A name declared with the `typedef` specifier becomes a *typedef-name*.
 Within the scope of its declaration, a *typedef-name* is syntactically
 equivalent to a keyword and names the type associated with the
 identifier in the way described in Clause  [[dcl.decl]]. A
 *typedef-name* is thus a synonym for another type. A *typedef-name* does
 not introduce a new type the way a class declaration ([[class.name]])
-or enum declaration does. after
 ``` cpp
 typedef int MILES, *KLICKSP;
 ```
@@ -278,88 +273,121 @@ the constructions
 MILES distance;
 extern KLICKSP metricp;
 ```
 are all correct declarations; the type of `distance` is `int` and that
-of `metricp` is “pointer to `int`.”
 A *typedef-name* can also be introduced by an *alias-declaration*. The
 *identifier* following the `using` keyword becomes a *typedef-name* and
 the optional *attribute-specifier-seq* following the *identifier*
-appertains to that *typedef-name*. It has the same semantics as if it
-were introduced by the `typedef` specifier. In particular, it does not
-define a new type and it shall not appear in the *type-id*.
 ``` cpp
 using handler_t = void (*)(int);
 extern handler_t ignore;
 extern void (*ignore)(int);         // redeclare ignore
 using cell = pair<void*, cell*>;    // ill-formed
 ```
 In a given non-class scope, a `typedef` specifier can be used to
 redefine the name of any type declared in that scope to refer to the
 type to which it already refers.
 ``` cpp
-typedef struct s { /* ... */ } s;
 typedef int I;
 typedef int I;
 typedef I I;
 ```
 In a given class scope, a `typedef` specifier can be used to redefine
 any *class-name* declared in that scope that is not also a
 *typedef-name* to refer to the type to which it already refers.
 ``` cpp
 struct S {
   typedef struct A { } A;       // OK
   typedef struct B B;           // OK
   typedef A A;                  // error
 };
 ```
 If a `typedef` specifier is used to redefine in a given scope an entity
 that can be referenced using an *elaborated-type-specifier*, the entity
 can continue to be referenced by an *elaborated-type-specifier* or as an
 enumeration or class name in an enumeration or class definition
 respectively.
 ``` cpp
 struct S;
 typedef struct S S;
 int main() {
   struct S* p;                  // OK
 }
 struct S { };                   // OK
 ```
 In a given scope, a `typedef` specifier shall not be used to redefine
 the name of any type declared in that scope to refer to a different
 type.
 ``` cpp
-class complex { /* ... */ };
 typedef int complex;            // error: redefinition
 ```
 Similarly, in a given scope, a class or enumeration shall not be
 declared with the same name as a *typedef-name* that is declared in that
 scope and refers to a type other than the class or enumeration itself.
 ``` cpp
 typedef int complex;
-class complex { /* ... */ }; // error: redefinition
 ```
-A *typedef-name* that names a class type, or a cv-qualified version
-thereof, is also a *class-name* ([[class.name]]). If a *typedef-name*
-is used to identify the subject of an *elaborated-type-specifier* (
-[[dcl.type.elab]]), a class definition (Clause  [[class]]), a
-constructor declaration ([[class.ctor]]), or a destructor declaration (
-[[class.dtor]]), the program is ill-formed.
 ``` cpp
 struct S {
   S();
   ~S();
@@ -369,35 +397,47 @@ typedef struct S T;
 S a = T();                      // OK
 struct T * p;                   // error
 ```
 If the typedef declaration defines an unnamed class (or enum), the first
 *typedef-name* declared by the declaration to be that class type (or
 enum type) is used to denote the class type (or enum type) for linkage
 purposes only ([[basic.link]]).
 ``` cpp
 typedef struct { } *ps, S;      // S is the class name for linkage purposes
 ```
 ### The `friend` specifier <a id="dcl.friend">[[dcl.friend]]</a>
 The `friend` specifier is used to specify access to class members; see
 [[class.friend]].
 ### The `constexpr` specifier <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
-variable or variable template, the declaration of a function or function
-template, or the declaration of a static data member of a literal type (
-[[basic.types]]). If any declaration of a function, function template,
-or variable template has a `constexpr` specifier, then all its
-declarations shall contain the `constexpr` specifier. An explicit
-specialization can differ from the template declaration with respect to
-the `constexpr` specifier. Function parameters cannot be declared
-`constexpr`.
 ``` cpp
 constexpr void square(int &x);  // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
@@ -419,31 +459,34 @@ int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
 extern constexpr int memsz;     // error: not a definition
 ```
 A `constexpr` specifier used in the declaration of a function that is
 not a constructor declares that function to be a *constexpr function*.
 Similarly, a `constexpr` specifier used in a constructor declaration
-declares that constructor to be a *constexpr constructor*. `constexpr`
-functions and `constexpr` constructors are implicitly `inline` (
-[[dcl.fct.spec]]).
-The definition of a `constexpr` function shall satisfy the following
-constraints:
 - it shall not be virtual ([[class.virtual]]);
 - its return type shall be a literal type;
 - each of its parameter types shall be a literal type;
 - its *function-body* shall be `= delete`, `= default`, or a
   *compound-statement* that does not contain
   - an *asm-definition*,
   - a `goto` statement,
   - a *try-block*, or
   - a definition of a variable of non-literal type or of static or
     thread storage duration or for which no initialization is performed.
 ``` cpp
 constexpr int square(int x)
   { return x * x; }             // OK
 constexpr long long_max()
   { return 2147483647; }        // OK
@@ -467,51 +510,60 @@ constexpr int g(int x, int n) { // OK
   while (--n > 0) r *= x;
   return r;
 }
 ```
-The definition of a `constexpr` constructor shall satisfy the following
-constraints:
 - the class shall not have any virtual base classes;
 - each of the parameter types shall be a literal type;
-- its *function-body* shall not be a *function-try-block*;
 In addition, either its *function-body* shall be `= delete`, or it shall
-satisfy the following constraints:
 - either its *function-body* shall be `= default`, or the
   *compound-statement* of its *function-body* shall satisfy the
- constraints for a *function-body* of a `constexpr` function;
-- every non-variant non-static data member and base class sub-object
   shall be initialized ([[class.base.init]]);
 - if the class is a union having variant members ([[class.union]]),
   exactly one of them shall be initialized;
 - if the class is a union-like class, but is not a union, for each of
   its anonymous union members having variant members, exactly one of
   them shall be initialized;
 - for a non-delegating constructor, every constructor selected to
-  initialize non-static data members and base class sub-objects shall be
-  a `constexpr` constructor;
 - for a delegating constructor, the target constructor shall be a
- `constexpr` constructor.
 ``` cpp
 struct Length {
   constexpr explicit Length(int i = 0) : val(i) { }
 private:
   int val;
 };
 ```
-For a non-template, non-defaulted `constexpr` function or a
-non-template, non-defaulted, non-inheriting `constexpr` constructor, if
-no argument values exist such that an invocation of the function or
-constructor could be an evaluated subexpression of a core constant
-expression ([[expr.const]]), the program is ill-formed; no diagnostic
 required.
 ``` cpp
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }           // OK
 constexpr int f() { return f(true); }   // ill-formed, no diagnostic required
@@ -526,66 +578,113 @@ struct D : B {
   constexpr D() : B(global) { }         // ill-formed, no diagnostic required
                                         // lvalue-to-rvalue conversion on non-constant global
 };
 ```
-If the instantiated template specialization of a `constexpr` function
 template or member function of a class template would fail to satisfy
-the requirements for a `constexpr` function or `constexpr` constructor,
-that specialization is still a `constexpr` function or `constexpr`
-constructor, even though a call to such a function cannot appear in a
-constant expression. If no specialization of the template would satisfy
-the requirements for a `constexpr` function or `constexpr` constructor
-when considered as a non-template function or constructor, the template
-is ill-formed; no diagnostic required.
-A call to a `constexpr` function produces the same result as a call to
-an equivalent non-`constexpr` function in all respects except that a
-call to a `constexpr` function can appear in a constant expression.
-The `constexpr` specifier has no effect on the type of a `constexpr`
-function or a `constexpr` constructor.
 ``` cpp
 constexpr int bar(int x, int y)         // OK
     { return x + y + x*y; }
 // ...
 int bar(int x, int y)                   // error: redefinition of bar
     { return x * 2 + 3 * y; }
 ```
 A `constexpr` specifier used in an object declaration declares the
 object as `const`. Such an object shall have literal type and shall be
-initialized. If it is initialized by a constructor call, that call shall
-be a constant expression ([[expr.const]]). Otherwise, or if a
-`constexpr` specifier is used in a reference declaration, every
-full-expression that appears in its initializer shall be a constant
-expression. Each implicit conversion used in converting the initializer
-expressions and each constructor call used for the initialization is
-part of such a full-expression.
 ``` cpp
 struct pixel {
   int x, y;
 };
 constexpr pixel ur = { 1294, 1024 };    // OK
 constexpr pixel origin;                 // error: initializer missing
 ```
 ### Type specifiers <a id="dcl.type">[[dcl.type]]</a>
 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
 ```
@@ -595,74 +694,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
@@ -677,11 +793,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;
@@ -697,31 +813,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'
@@ -749,23 +869,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''                           |
@@ -797,90 +922,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
@@ -914,20 +1058,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
@@ -936,164 +1086,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
@@ -1103,30 +1219,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()
@@ -1147,20 +1274,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 specifiers that can be used in a declaration are
 ``` bnf
 decl-specifier:
     storage-class-specifier
+ defining-type-specifier
     function-specifier
     'friend'
     'typedef'
     'constexpr'
+    'inline'
 ```
 ``` bnf
 decl-specifier-seq:
     decl-specifier attribute-specifier-seqₒₚₜ
 appertains to the type determined by the preceding *decl-specifier*s (
 [[dcl.meaning]]). The *attribute-specifier-seq* affects the type only
 for the declaration it appears in, not other declarations involving the
 same type.
+Each *decl-specifier* shall appear at most once in a complete
+*decl-specifier-seq*, except that `long` may appear twice.
 If a *type-name* is encountered while parsing a *decl-specifier-seq*, it
 is interpreted as part of the *decl-specifier-seq* if and only if there
+is no previous *defining-type-specifier* other than a *cv-qualifier* in
+the *decl-specifier-seq*. The sequence shall be self-consistent as
+described below.
+[*Example 1*:
 ``` cpp
 typedef char* Pc;
 static Pc;                      // error: name missing
 ```
 ``` cpp
 void f(const Pc);               // void f(char* const) (not const char*)
 void g(const int Pc);           // void g(const int)
 ```
+— *end example*]
+[*Note 1*:
 Since `signed`, `unsigned`, `long`, and `short` by default imply `int`,
 a *type-name* appearing after one of those specifiers is treated as the
 name being (re)declared.
+[*Example 2*:
 ``` cpp
 void h(unsigned Pc);            // void h(unsigned int)
 void k(unsigned int Pc);        // void k(unsigned int)
 ```
+— *end example*]
+— *end note*]
 ### Storage class specifiers <a id="dcl.stc">[[dcl.stc]]</a>
 The storage class specifiers are
 ``` bnf
 storage-class-specifier:
     'static'
     'thread_local'
     'extern'
     'mutable'
 ```
 *decl-specifier-seq*, except that `thread_local` may appear with
 `static` or `extern`. If `thread_local` appears in any declaration of a
 variable it shall be present in all declarations of that entity. If a
 *storage-class-specifier* appears in a *decl-specifier-seq*, there can
 be no `typedef` specifier in the same *decl-specifier-seq* and the
+*init-declarator-list* or *member-declarator-list* of the declaration
+shall not be empty (except for an anonymous union declared in a named
+namespace or in the global namespace, which shall be declared `static` (
+[[class.union.anon]])). The *storage-class-specifier* applies to the
+name declared by each *init-declarator* in the list and not to any names
+declared by other specifiers. A *storage-class-specifier* other than
+`thread_local` shall not be specified in an explicit specialization (
+[[temp.expl.spec]]) or an explicit instantiation ([[temp.explicit]])
+directive.
+[*Note 1*: A variable declared without a *storage-class-specifier* at
+block scope or declared as a function parameter has automatic storage
+duration by default ([[basic.stc.auto]]). — *end note*]
 The `thread_local` specifier indicates that the named entity has thread
 storage duration ([[basic.stc.thread]]). It shall be applied only to
 the names of variables of namespace or block scope and to the names of
 static data members. When `thread_local` is applied to a variable of
 block scope the *storage-class-specifier* `static` is implied if no
 other *storage-class-specifier* appears in the *decl-specifier-seq*.
 The `static` specifier can be applied only to names of variables and
+functions and to anonymous unions ([[class.union.anon]]). There can be
+no `static` function declarations within a block, nor any `static`
+function parameters. A `static` specifier used in the declaration of a
+variable declares the variable to have static storage duration (
 [[basic.stc.static]]), unless accompanied by the `thread_local`
 specifier, which declares the variable to have thread storage duration (
 [[basic.stc.thread]]). A `static` specifier can be used in declarations
 of class members;  [[class.static]] describes its effect. For the
 linkage of a name declared with a `static` specifier, see
 [[basic.link]].
 The `extern` specifier can be applied only to the names of variables and
 functions. The `extern` specifier cannot be used in the declaration of
 class members or function parameters. For the linkage of a name declared
+with an `extern` specifier, see  [[basic.link]].
+[*Note 2*: The `extern` keyword can also be used in
+*explicit-instantiation*s and *linkage-specification*s, but it is not a
+*storage-class-specifier* in such contexts. — *end note*]
 The linkages implied by successive declarations for a given entity shall
 agree. That is, within a given scope, each declaration declaring the
 same variable name or the same overloading of a function name shall
 imply the same linkage. Each function in a given set of overloaded
 functions can have a different linkage, however.
+[*Example 1*:
 ``` cpp
 static char* f();               // f() has internal linkage
 char* f()                       // f() still has internal linkage
+  { ... }
 char* g();                      // g() has external linkage
 static char* g()                // error: inconsistent linkage
+  { ... }
 void h();
 inline void h();                // external linkage
 inline void l();
 extern int d;                   // d has external linkage
 static int d;                   // error: inconsistent linkage
 ```
+— *end example*]
 The name of a declared but undefined class can be used in an `extern`
 declaration. Such a declaration can only be used in ways that do not
 require a complete class type.
+[*Example 2*:
 ``` cpp
 struct S;
 extern S a;
 extern S f();
 extern void g(S);
   g(a);                         // error: S is incomplete
   f();                          // error: S is incomplete
 }
 ```
+— *end example*]
+The `mutable` specifier shall appear only in the declaration of a
+non-static data member ([[class.mem]]) whose type is neither
+const-qualified nor a reference type.
+[*Example 3*:
 ``` cpp
 class X {
   mutable const int* p;         // OK
   mutable int* const q;         // ill-formed
 };
 ```
+— *end example*]
 The `mutable` specifier on a class data member nullifies a `const`
 specifier applied to the containing class object and permits
 modification of the mutable class member even though the rest of the
 object is `const` ([[dcl.type.cv]]).
 can be used only in function declarations.
 ``` bnf
 function-specifier:
     'virtual'
     'explicit'
 ```
 The `virtual` specifier shall be used only in the initial declaration of
 a non-static class member function; see  [[class.virtual]].
 The `explicit` specifier shall be used only in the declaration of a
 constructor or conversion function within its class definition; see
 Declarations containing the *decl-specifier* `typedef` declare
 identifiers that can be used later for naming fundamental (
 [[basic.fundamental]]) or compound ([[basic.compound]]) types. The
 `typedef` specifier shall not be combined in a *decl-specifier-seq* with
+any other kind of specifier except a *defining-type-specifier*, and it
+shall not be used in the *decl-specifier-seq* of a
+*parameter-declaration* ([[dcl.fct]]) nor in the *decl-specifier-seq*
+of a *function-definition* ([[dcl.fct.def]]). If a `typedef` specifier
+appears in a declaration without a *declarator*, the program is
+ill-formed.
 ``` bnf
 typedef-name:
     identifier
 ```
 Within the scope of its declaration, a *typedef-name* is syntactically
 equivalent to a keyword and names the type associated with the
 identifier in the way described in Clause  [[dcl.decl]]. A
 *typedef-name* is thus a synonym for another type. A *typedef-name* does
 not introduce a new type the way a class declaration ([[class.name]])
+or enum declaration does.
+[*Example 1*:
+After
 ``` cpp
 typedef int MILES, *KLICKSP;
 ```
 MILES distance;
 extern KLICKSP metricp;
 ```
 are all correct declarations; the type of `distance` is `int` and that
+of `metricp` is “pointer to `int`”.
+— *end example*]
 A *typedef-name* can also be introduced by an *alias-declaration*. The
 *identifier* following the `using` keyword becomes a *typedef-name* and
 the optional *attribute-specifier-seq* following the *identifier*
+appertains to that *typedef-name*. Such a *typedef-name* has the same
+semantics as if it were introduced by the `typedef` specifier. In
+particular, it does not define a new type.
+[*Example 2*:
 ``` cpp
 using handler_t = void (*)(int);
 extern handler_t ignore;
 extern void (*ignore)(int);         // redeclare ignore
 using cell = pair<void*, cell*>;    // ill-formed
 ```
+— *end example*]
+The *defining-type-specifier-seq* of the *defining-type-id* shall not
+define a class or enumeration if the *alias-declaration* is the
+*declaration* of a *template-declaration*.
 In a given non-class scope, a `typedef` specifier can be used to
 redefine the name of any type declared in that scope to refer to the
 type to which it already refers.
+[*Example 3*:
 ``` cpp
+typedef struct s { ... } s;
 typedef int I;
 typedef int I;
 typedef I I;
 ```
+— *end example*]
 In a given class scope, a `typedef` specifier can be used to redefine
 any *class-name* declared in that scope that is not also a
 *typedef-name* to refer to the type to which it already refers.
+[*Example 4*:
 ``` cpp
 struct S {
   typedef struct A { } A;       // OK
   typedef struct B B;           // OK
   typedef A A;                  // error
 };
 ```
+— *end example*]
 If a `typedef` specifier is used to redefine in a given scope an entity
 that can be referenced using an *elaborated-type-specifier*, the entity
 can continue to be referenced by an *elaborated-type-specifier* or as an
 enumeration or class name in an enumeration or class definition
 respectively.
+[*Example 5*:
 ``` cpp
 struct S;
 typedef struct S S;
 int main() {
   struct S* p;                  // OK
 }
 struct S { };                   // OK
 ```
+— *end example*]
 In a given scope, a `typedef` specifier shall not be used to redefine
 the name of any type declared in that scope to refer to a different
 type.
+[*Example 6*:
 ``` cpp
+class complex { ... };
 typedef int complex;            // error: redefinition
 ```
+— *end example*]
 Similarly, in a given scope, a class or enumeration shall not be
 declared with the same name as a *typedef-name* that is declared in that
 scope and refers to a type other than the class or enumeration itself.
+[*Example 7*:
 ``` cpp
 typedef int complex;
+class complex { ... }; // error: redefinition
 ```
+— *end example*]
+[*Note 1*:  A *typedef-name* that names a class type, or a cv-qualified
+version thereof, is also a *class-name* ([[class.name]]). If a
+*typedef-name* is used to identify the subject of an
+*elaborated-type-specifier* ([[dcl.type.elab]]), a class definition
+(Clause  [[class]]), a constructor declaration ([[class.ctor]]), or a
+destructor declaration ([[class.dtor]]), the program is
+ill-formed. — *end note*]
+[*Example 8*:
 ``` cpp
 struct S {
   S();
   ~S();
 S a = T();                      // OK
 struct T * p;                   // error
 ```
+— *end example*]
 If the typedef declaration defines an unnamed class (or enum), the first
 *typedef-name* declared by the declaration to be that class type (or
 enum type) is used to denote the class type (or enum type) for linkage
 purposes only ([[basic.link]]).
+[*Example 9*:
 ``` cpp
 typedef struct { } *ps, S;      // S is the class name for linkage purposes
 ```
+— *end example*]
 ### The `friend` specifier <a id="dcl.friend">[[dcl.friend]]</a>
 The `friend` specifier is used to specify access to class members; see
 [[class.friend]].
 ### The `constexpr` specifier <a id="dcl.constexpr">[[dcl.constexpr]]</a>
 The `constexpr` specifier shall be applied only to the definition of a
+variable or variable template or the declaration of a function or
+function template. A function or static data member declared with the
+`constexpr` specifier is implicitly an inline function or variable (
+[[dcl.inline]]). If any declaration of a function or function template
+has a `constexpr` specifier, then all its declarations shall contain the
+`constexpr` specifier.
+[*Note 1*: An explicit specialization can differ from the template
+declaration with respect to the `constexpr` specifier. — *end note*]
+[*Note 2*: Function parameters cannot be declared
+`constexpr`. — *end note*]
+[*Example 1*:
 ``` cpp
 constexpr void square(int &x);  // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
      return x + 1;
 }
 extern constexpr int memsz;     // error: not a definition
 ```
+— *end example*]
 A `constexpr` specifier used in the declaration of a function that is
 not a constructor declares that function to be a *constexpr function*.
 Similarly, a `constexpr` specifier used in a constructor declaration
+declares that constructor to be a *constexpr constructor*.
+The definition of a constexpr function shall satisfy the following
+requirements:
 - it shall not be virtual ([[class.virtual]]);
 - its return type shall be a literal type;
 - each of its parameter types shall be a literal type;
 - its *function-body* shall be `= delete`, `= default`, or a
   *compound-statement* that does not contain
   - an *asm-definition*,
   - a `goto` statement,
+  - an identifier label ([[stmt.label]]),
   - a *try-block*, or
   - a definition of a variable of non-literal type or of static or
     thread storage duration or for which no initialization is performed.
+[*Example 2*:
 ``` cpp
 constexpr int square(int x)
   { return x * x; }             // OK
 constexpr long long_max()
   { return 2147483647; }        // OK
   while (--n > 0) r *= x;
   return r;
 }
 ```
+— *end example*]
+The definition of a constexpr constructor shall satisfy the following
+requirements:
 - the class shall not have any virtual base classes;
 - each of the parameter types shall be a literal type;
+- its *function-body* shall not be a *function-try-block*.
 In addition, either its *function-body* shall be `= delete`, or it shall
+satisfy the following requirements:
 - either its *function-body* shall be `= default`, or the
   *compound-statement* of its *function-body* shall satisfy the
+ requirements for a *function-body* of a constexpr function;
+- every non-variant non-static data member and base class subobject
   shall be initialized ([[class.base.init]]);
 - if the class is a union having variant members ([[class.union]]),
   exactly one of them shall be initialized;
 - if the class is a union-like class, but is not a union, for each of
   its anonymous union members having variant members, exactly one of
   them shall be initialized;
 - for a non-delegating constructor, every constructor selected to
+  initialize non-static data members and base class subobjects shall be
+  a constexpr constructor;
 - for a delegating constructor, the target constructor shall be a
+  constexpr constructor.
+[*Example 3*:
 ``` cpp
 struct Length {
   constexpr explicit Length(int i = 0) : val(i) { }
 private:
   int val;
 };
 ```
+— *end example*]
+For a constexpr function or constexpr constructor that is neither
+defaulted nor a template, if no argument values exist such that an
+invocation of the function or constructor could be an evaluated
+subexpression of a core constant expression ([[expr.const]]), or, for a
+constructor, a constant initializer for some object (
+[[basic.start.static]]), the program is ill-formed, no diagnostic
 required.
+[*Example 4*:
 ``` cpp
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }           // OK
 constexpr int f() { return f(true); }   // ill-formed, no diagnostic required
   constexpr D() : B(global) { }         // ill-formed, no diagnostic required
                                         // lvalue-to-rvalue conversion on non-constant global
 };
 ```
+— *end example*]
+If the instantiated template specialization of a constexpr function
 template or member function of a class template would fail to satisfy
+the requirements for a constexpr function or constexpr constructor, that
+specialization is still a constexpr function or constexpr constructor,
+even though a call to such a function cannot appear in a constant
+expression. If no specialization of the template would satisfy the
+requirements for a constexpr function or constexpr constructor when
+considered as a non-template function or constructor, the template is
+ill-formed, no diagnostic required.
+A call to a constexpr function produces the same result as a call to an
+equivalent non-constexpr function in all respects except that
+- a call to a constexpr function can appear in a constant expression (
+  [[expr.const]]) and
+- copy elision is mandatory in a constant expression ([[class.copy]]).
+The `constexpr` specifier has no effect on the type of a constexpr
+function or a constexpr constructor.
+[*Example 5*:
 ``` cpp
 constexpr int bar(int x, int y)         // OK
     { return x + y + x*y; }
 // ...
 int bar(int x, int y)                   // error: redefinition of bar
     { return x * 2 + 3 * y; }
 ```
+— *end example*]
 A `constexpr` specifier used in an object declaration declares the
 object as `const`. Such an object shall have literal type and shall be
+initialized. In any `constexpr` variable declaration, the
+full-expression of the initialization shall be a constant expression (
+[[expr.const]]).
+[*Example 6*:
 ``` cpp
 struct pixel {
   int x, y;
 };
 constexpr pixel ur = { 1294, 1024 };    // OK
 constexpr pixel origin;                 // error: initializer missing
 ```
+— *end example*]
+### The `inline` specifier <a id="dcl.inline">[[dcl.inline]]</a>
+The `inline` specifier can be applied only to the declaration or
+definition of a variable or function.
+A function declaration ([[dcl.fct]],  [[class.mfct]], [[class.friend]])
+with an `inline` specifier declares an *inline function*. The inline
+specifier indicates to the implementation that inline substitution of
+the function body at the point of call is to be preferred to the usual
+function call mechanism. An implementation is not required to perform
+this inline substitution at the point of call; however, even if this
+inline substitution is omitted, the other rules for inline functions
+specified in this section shall still be respected.
+A variable declaration with an `inline` specifier declares an *inline
+variable*.
+A function defined within a class definition is an inline function.
+The `inline` specifier shall not appear on a block scope
+declaration.[^2] If the `inline` specifier is used in a friend function
+declaration, that declaration shall be a definition or the function
+shall have previously been declared inline.
+An inline function or variable shall be defined in every translation
+unit in which it is odr-used and shall have exactly the same definition
+in every case ([[basic.def.odr]]).
+[*Note 1*: A call to the inline function or a use of the inline
+variable may be encountered before its definition appears in the
+translation unit. — *end note*]
+If the definition of a function or variable appears in a translation
+unit before its first declaration as inline, the program is ill-formed.
+If a function or variable with external linkage is declared inline in
+one translation unit, it shall be declared inline in all translation
+units in which it appears; no diagnostic is required. An inline function
+or variable with external linkage shall have the same address in all
+translation units.
+[*Note 2*: A `static` local variable in an inline function with
+external linkage always refers to the same object. A type defined within
+the body of an inline function with external linkage is the same type in
+every translation unit. — *end note*]
 ### Type specifiers <a id="dcl.type">[[dcl.type]]</a>
 The type-specifiers are
 ``` 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