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

Files changed (1) hide show

tmp/tmpjsy99id6/{from.md → to.md} +292 -182

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

@@ -98,12 +98,12 @@ 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 it does
-not appear explicitly.
 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
@@ -119,16 +119,10 @@ 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.
-A name declared in a namespace scope without a *storage-class-specifier*
-has external linkage unless it has internal linkage because of a
-previous declaration and provided it is not declared `const`. Objects
-declared `const` and not explicitly declared `extern` have internal
-linkage.
 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.
@@ -392,34 +386,35 @@ 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, 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 or function template
-has `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 int square(int x); // OK: declaration
 constexpr int bufsz = 1024;     // OK: definition
 constexpr struct pixel {        // error: pixel is a type
   int x;
   int y;
   constexpr pixel(int);         // OK: declaration
 };
 constexpr pixel::pixel(int a)
-  : x(square(a)), y(square(a))  // OK: definition
-  { }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant~([expr.const]) so constexpr not satisfied
-constexpr int square(int x) { // OK: definition
- return x * x;
 }
 constexpr pixel large(4);       // OK: square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
@@ -438,122 +433,89 @@ 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 contains only
-  - null statements,
-  -
-  - `typedef` declarations and *alias-declaration*s that do not define
-    classes or enumerations,
-  - *using-declaration*s,
-  - *using-directive*s,
-  - and exactly one return statement;
-- every constructor call and implicit conversion used in initializing
-  the return value ([[stmt.return]],  [[dcl.init]]) shall be one of
-  those allowed in a constant expression ([[expr.const]]).
 ``` cpp
 constexpr int square(int x)
   { return x * x; }             // OK
 constexpr long long_max()
   { return 2147483647; }        // OK
-constexpr int abs(int x)
- { return x < 0 ? -x : x; }    // OK
-constexpr void f(int x)         // error: return type is void
- { /* ... */ }
 constexpr int prev(int x)
-  { return --x; }               // error: use of decrement
-constexpr int g(int x, int n) { // error: body not just ``return expr''
   int r = 1;
   while (--n > 0) r *= x;
   return r;
 }
 ```
-In a definition of a `constexpr` constructor, each of the parameter
-types shall be a literal type. In addition, either its *function-body*
-shall be `= delete` or `= default` or it shall satisfy the following
 constraints:
 - the class shall not have any virtual base classes;
 - its *function-body* shall not be a *function-try-block*;
-- the *compound-statement* of its *function-body* shall contain only
-  - null statements,
- -
- - `typedef` declarations and *alias-declaration*s that do not define
-    classes or enumerations,
- - *using-declaration*s,
- - and *using-directive*s;
-- every non-static data member and base class sub-object shall be
-  initialized ([[class.base.init]]);
-- every constructor involved in initializing non-static data members and
- base class sub-objects shall be a `constexpr` constructor;
-- every *assignment-expression* that is an *initializer-clause*
- appearing directly or indirectly within a *brace-or-equal-initializer*
- for a non-static data member that is not named by a
-  *mem-initializer-id* shall be a constant expression; and
-- every implicit conversion used in converting a constructor argument to
-  the corresponding parameter type and converting a full-expression to
-  the corresponding member type shall be one of those allowed in a
-  constant expression.
 ``` cpp
 struct Length {
- explicit constexpr Length(int i = 0) : val(i) { }
 private:
   int val;
 };
 ```
-*Function invocation substitution* for a call of a `constexpr` function
-or of a `constexpr` constructor means implicitly converting each
-argument to the corresponding parameter type as if by
-copy-initialization,[^3] substituting that converted expression for each
-use of the corresponding parameter in the *function-body*, and, for
-`constexpr` functions, implicitly converting the resulting returned
-expression or *braced-init-list* to the return type of the function as
-if by copy-initialization. Such substitution does not change the
-meaning.
-``` cpp
-constexpr int f(void *) { return 0; }
-constexpr int f(...) { return 1; }
-constexpr int g1() { return f(0); }         // calls f(void *)
-constexpr int g2(int n) { return f(n); }    // calls f(...) even for n == 0
-constexpr int g3(int n) { return f(n*0); }  // calls f(...)
-namespace N {
-  constexpr int c = 5;
-  constexpr int h() { return c; }
-}
-constexpr int c = 0;
-constexpr int g4() { return N::h(); }       // value is 5, c is not looked up again after the substitution
-```
-For a `constexpr` function, if no function argument values exist such
-that the function invocation substitution would produce a constant
 expression ([[expr.const]]), the program is ill-formed; no diagnostic
-required. For a `constexpr` constructor, if no argument values exist
-such that after function invocation substitution, every constructor call
-and full-expression in the *mem-initializer*s would be a constant
-expression (including conversions), the program is ill-formed; no
-diagnostic required.
 ``` cpp
 constexpr int f(bool b)
   { return b ? throw 0 : 0; }               // OK
-constexpr int f() { throw 0; } // ill-formed, no diagnostic required
 struct B {
   constexpr B(int x) : i(0) { }             // x is unused
   int i;
 };
@@ -567,37 +529,25 @@ struct D : B {
 ```
 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 not a `constexpr` function or `constexpr`
-constructor. If the function is a member function it will still be
-`const` as described below. If no specialization of the template would
-yield a `constexpr` function or `constexpr` constructor, the program 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.
-A `constexpr` specifier for a non-static member function that is not a
-constructor declares that member function to be `const` (
-[[class.mfct.non-static]]). The `constexpr` specifier has no other
-effect on the function type. The keyword `const` is ignored if it
-appears in the *cv-qualifier-seq* of the function declarator of the
-declaration of such a member function. The class of which that function
-is a member shall be a literal type ([[basic.types]]).
 ``` cpp
-class debug_flag {
-public:
-  explicit debug_flag(bool);
-  constexpr bool is_on();       // error: debug_flag not
-                                // literal type
-private:
-  bool flag;
-};
 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; }
@@ -608,12 +558,12 @@ 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 shall
-be one of those allowed in a constant expression ([[expr.const]]).
 ``` cpp
 struct pixel {
   int x, y;
 };
@@ -669,25 +619,27 @@ exceptions to this rule are the following:
   or `int`.
 - `short` or `long` can be combined with `int`.
 - `long` can be combined with `double`.
 - `long` can be combined with `long`.
-At least one *type-specifier* that is not a *cv-qualifier* is required
-in a declaration unless it declares a constructor, destructor or
-conversion function.[^4] 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]], [[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`. 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.
@@ -745,19 +697,22 @@ 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
 ```
-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. 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
@@ -791,18 +746,19 @@ type-name:
 ```
 ``` bnf
 decltype-specifier:
   'decltype' '(' expression ')'
 ```
 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 user-defined type 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>
 |                        |                                        |
 | ---------------------- | -------------------------------------- |
@@ -846,16 +802,16 @@ specify.
 | 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 and certain
-bit-fields ([[class.bit]]) are represented as signed or unsigned
-quantities. The `signed` specifier forces `char` objects and bit-fields
-to be signed; it is redundant in other contexts.
-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;
@@ -871,16 +827,19 @@ The operand of the `decltype` specifier is an unevaluated operand
 ``` cpp
 const int&& foo();
 int i;
 struct A { double x; };
 const A* a = new A();
-decltype(foo()) x1 = i;         // 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&
 ```
 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
@@ -923,11 +882,12 @@ void r() {
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
-    class-key nested-name-specifierₒₚₜ 'template'ₒₚₜ simple-template-id
     'enum' nested-name-specifierₒₚₜ identifier
 ```
 An *attribute-specifier-seq* shall not appear in an
 *elaborated-type-specifier* unless the latter is the sole constituent of
@@ -983,68 +943,94 @@ enum class E { a, b };
 enum E x = E::a;                // OK
 ```
 #### `auto` specifier <a id="dcl.spec.auto">[[dcl.spec.auto]]</a>
-The `auto` *type-specifier* signifies that the type of a variable being
-declared shall be deduced from its initializer or that a function
-declarator shall include a *trailing-return-type*.
-The `auto` *type-specifier* may appear with a function declarator with a
-*trailing-return-type* ([[dcl.fct]]) in any context where such a
-declarator is valid.
-Otherwise, the type of the variable is deduced from its initializer. The
-name of the variable being declared shall not appear in the initializer
-expression. This use of `auto` is allowed when declaring variables in a
-block ([[stmt.block]]), in namespace scope (
-[[basic.scope.namespace]]), and in a  ([[stmt.for]]). `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*.
 ``` 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
 ```
-The `auto` 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` in a context not explicitly allowed in this
-section is ill-formed.
-Once the type of a has been determined according to  [[dcl.meaning]],
-the type of the declared variable using the is determined from the type
-of its initializer using the rules for template argument deduction. Let
-`T` be the type that has been determined for a variable identifier `d`.
-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* ([[dcl.init.list]]), with
-`std::initializer_list<U>`. The type deduced for the variable `d` is
-then the deduced `A` determined 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 for `d` is the
-corresponding argument. If the deduction fails, the declaration is
-ill-formed.
 ``` cpp
 auto x1 = { 1, 2 };         // decltype(x1) is std::initializer_list<int>
 auto x2 = { 1, 2.0 };       // error: cannot deduce element type
 ```
-If the list of declarators contains more than one declarator, the type
-of each declared variable is determined as described above. If the type
-deduced for the template parameter `U` is not the same in each
-deduction, the program is ill-formed.
 ``` cpp
 const auto &i = expr;
 ```
 The type of `i` is the deduced type of the parameter `u` in the call
@@ -1052,5 +1038,129 @@ The type of `i` is the deduced type of the parameter `u` in the call
 ``` cpp
 template <class U> void f(const U& u);
 ```

 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
 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.
 [[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
   int x;
   int y;
   constexpr pixel(int);         // OK: declaration
 };
 constexpr pixel::pixel(int a)
+  : x(a), y(x) // OK: definition
+  { square(x); }
 constexpr pixel small(2);       // error: square not defined, so small(2)
                                 // not constant~([expr.const]) so constexpr not satisfied
+constexpr void square(int &x) { // OK: definition
+  x *= x;
 }
 constexpr pixel large(4);       // OK: square defined
 int next(constexpr int x) {     // error: not for parameters
      return x + 1;
 }
 - 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
+constexpr int abs(int x) {
+ if (x < 0)
+ x = -x;
+ return x;                     // OK
+}
+constexpr int first(int n) {
+  static int value = n;         // error: variable has static storage duration
+  return value;
+}
+constexpr int uninit() {
+  int a;                        // error: variable is uninitialized
+  return a;
+}
 constexpr int prev(int x)
+  { return --x; }               // OK
+constexpr int g(int x, int n) { // OK
   int r = 1;
   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
 struct B {
   constexpr B(int x) : i(0) { }             // x is unused
   int i;
 };
 ```
 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; }
 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;
 };
   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.
 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
 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>
 |                        |                                        |
 | ---------------------- | -------------------------------------- |
 | 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;
 ``` 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
 #### Elaborated type specifiers <a id="dcl.type.elab">[[dcl.type.elab]]</a>
 ``` bnf
 elaborated-type-specifier:
     class-key attribute-specifier-seqₒₚₜ nested-name-specifierₒₚₜ identifier
+    class-key simple-template-id
+    class-key nested-name-specifier 'template'ₒₚₜ simple-template-id
     'enum' nested-name-specifierₒₚₜ identifier
 ```
 An *attribute-specifier-seq* shall not appear in an
 *elaborated-type-specifier* unless the latter is the sole constituent of
 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
 ``` 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
+auto sum(int i) {
+  if (i == 1)
+    return i;          // sum's return type is int
+  else
+    return sum(i-1)+i; // OK, sum's return type has been deduced
+}
+```
+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()
+decltype(auto) f();     // error, auto and decltype(auto) don't match
+template <typename T> auto g(T t) { return t; } // #1
+template auto g(int);                           // OK, return type is int
+template char g(char);                          // error, no matching template
+template<> auto g(double);                      // OK, forward declaration with unknown return type
+template <class T> T g(T t) { return t; } // OK, not functionally equivalent to #1
+template char g(char);                    // OK, now there is a matching template
+template auto g(float);                   // still matches #1
+void h() { return g(42); } // error, ambiguous
+template <typename T> struct A {
+  friend T frf(T);
+};
+auto frf(int i) { return i; } // not a friend of A<int>
+```
+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
+```

Diff to HTML by rtfpessoa