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

Files changed (1) hide show

tmp/tmpunrgxckk/{from.md → to.md} +442 -268

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

@@ -34,11 +34,11 @@ block-declaration:
     opaque-enum-declaration
 ```
 ``` bnf
 alias-declaration:
-    'using' identifier attribute-specifier-seqₒₚₜ = type-id ';'
 ```
 ``` bnf
 simple-declaration:
     decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
@@ -106,13 +106,12 @@ omitted only when declaring a class (Clause  [[class]]) or enumeration (
 [[dcl.enum]]), that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key* (
 [[class.name]]), or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
 *decl-specifier-seq*, the identifiers in these specifiers are among the
-names being declared by the declaration (as *class-names*, *enum-names*,
-or *enumerators*, depending on the syntax). In such cases, and except
-for the declaration of an unnamed bit-field ([[class.bit]]), the
 *decl-specifier-seq* shall introduce one or more names into the program,
 or shall redeclare a name introduced by a previous declaration.
 ``` cpp
 enum { };           // ill-formed
@@ -261,12 +260,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
@@ -282,16 +281,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.
@@ -555,34 +548,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;
 }
@@ -601,122 +595,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;
 };
@@ -730,37 +691,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; }
@@ -771,12 +720,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;
 };
@@ -832,25 +781,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.
@@ -908,19 +859,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
@@ -954,18 +908,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>
 |                        |                                        |
 | ---------------------- | -------------------------------------- |
@@ -1009,16 +964,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;
@@ -1034,16 +989,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
@@ -1086,11 +1044,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
@@ -1146,68 +1105,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
@@ -1215,10 +1200,134 @@ The type of `i` is the deduced type of the parameter `u` in the call
 ``` cpp
 template <class U> void f(const U& u);
 ```
 ## Enumeration declarations <a id="dcl.enum">[[dcl.enum]]</a>
 An enumeration is a distinct type ([[basic.compound]]) with named
 constants. Its name becomes an *enum-name*, within its scope.
@@ -1275,11 +1384,22 @@ enumerator:
 ```
 The optional *attribute-specifier-seq* in the *enum-head* and the
 *opaque-enum-declaration* appertains to the enumeration; the attributes
 in that *attribute-specifier-seq* are thereafter considered attributes
-of the enumeration whenever it is named.
 The enumeration type declared with an *enum-key* of only `enum` is an
 unscoped enumeration, and its *enumerator*s are *unscoped enumerators*.
 The *enum-key*s `enum class` and `enum struct` are semantically
 equivalent; an enumeration type declared with one of these is a *scoped
@@ -1322,33 +1442,40 @@ declared directly in the class or namespace to which the
 by a *using-declaration*), and the *enum-specifier* shall appear in a
 namespace enclosing the previous declaration.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an underlying type. The underlying type can be
-explicitly specified using *enum-base*; if not explicitly specified, the
-underlying type of a scoped enumeration type is `int`. In these cases,
-the underlying type is said to be *fixed*. Following the closing brace
-of an *enum-specifier*, each enumerator has the type of its enumeration.
-If the underlying type is fixed, the type of each *enumerator* prior to
-the closing brace is the underlying type and the *constant-expression*
-in the *enumerator-definition* shall be a converted constant expression
-of the underlying type ([[expr.const]]); if the initializing value of
-an *enumerator* cannot be represented by the underlying type, the
-program is ill-formed. If the underlying type is not fixed, the type of
-each enumerator is the type of its initializing value:
-- If an initializer is specified for an enumerator, the initializing
-  value has the same type as the expression and the
   *constant-expression* shall be an integral constant expression (
-  [[expr.const]]).
-- If no initializer is specified for the first enumerator, the
- initializing value has an unspecified integral type.
-- Otherwise the type of the initializing value is the same as the type
- of the initializing value of the preceding enumerator unless the
-  incremented value is not representable in that type, in which case the
- type is an unspecified integral type sufficient to contain the
- incremented value. If no such type exists, the program is ill-formed.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
@@ -1370,13 +1497,13 @@ integer. bₘᵢₙ is zero if eₘᵢₙ is non-negative and -(bₘₐₓ+K) ot
 The size of the smallest bit-field large enough to hold all the values
 of the enumeration type is max(M,1) if bₘᵢₙ is zero and M+1 otherwise.
 It is possible to define an enumeration that has values not defined by
 any of its enumerators. If the *enumerator-list* is empty, the values of
 the enumeration are as if the enumeration had a single enumerator with
-value 0.[^5]
-Two enumeration types are layout-compatible if they have the same
 *underlying type*.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion ([[conv.prom]]).
@@ -1605,11 +1732,11 @@ An *unnamed-namespace-definition* behaves as if it were replaced by
 ```
 where `inline` appears if and only if it appears in the
 *unnamed-namespace-definition*, all occurrences of *unique* in a
 translation unit are replaced by the same identifier, and this
-identifier differs from all other identifiers in the entire program.[^6]
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
@@ -1663,29 +1790,31 @@ namespace R {
   void Q::V::g() { /* ... */ }  // error: R doesn't enclose Q
 }
 ```
 Every name first declared in a namespace is a member of that namespace.
-If a `friend` declaration in a non-local class first declares a class or
-function[^7] the friend class or function is a member of the innermost
-enclosing namespace. The name of the friend is not found by unqualified
-lookup ([[basic.lookup.unqual]]) or by qualified lookup (
-[[basic.lookup.qual]]) until a matching declaration is provided in that
-namespace scope (either before or after the class definition granting
-friendship). If a friend function is called, its name may be found by
-the name lookup that considers functions from namespaces and classes
-associated with the types of the function arguments (
-[[basic.lookup.argdep]]). If the name in a `friend` declaration is
-neither qualified nor a *template-id* and the declaration is a function
-or an *elaborated-type-specifier*, the lookup to determine whether the
-entity has been previously declared shall not consider any scopes
-outside the innermost enclosing namespace. The other forms of `friend`
-declarations cannot declare a new member of the innermost enclosing
-namespace and thus follow the usual lookup rules.
 ``` cpp
-// Assume f and g have not yet been defined.
 void h(int);
 template <class T> void f2(T);
 namespace A {
   class X {
     friend void f(X);           // A::f(X) is a friend
@@ -1776,12 +1905,12 @@ specified name is so declared; specifying an enumeration name in a
 *using-declaration* does not declare its enumerators in the
 *using-declaration*’s declarative region. If a *using-declaration* names
 a constructor ([[class.qual]]), it implicitly declares a set of
 constructors in the class in which the *using-declaration* appears (
 [[class.inhctor]]); otherwise the name specified in a
-*using-declaration* is a synonym for the name of some entity declared
-elsewhere.
 Every *using-declaration* is a *declaration* and a *member-declaration*
 and so can be used in a class definition.
 ``` cpp
@@ -1915,14 +2044,16 @@ struct X : B {
   using B::i;
   using B::i;       // error: double member declaration
 };
 ```
-The entity declared by a *using-declaration* shall be known in the
-context using it according to its definition at the point of the
-*using-declaration*. Definitions added to the namespace after the
-*using-declaration* are not considered when a use of the name is made.
 ``` cpp
 namespace A {
   void f(int);
 }
@@ -1984,17 +2115,20 @@ void func() {
   struct x x1;      // x1 has class type B::x
 }
 ```
 If a function declaration in namespace scope or block scope has the same
-name and the same parameter types as a function introduced by a
-*using-declaration*, and the declarations do not declare the same
-function, the program is ill-formed. Two *using-declaration*s may
-introduce functions with the same name and the same parameter types. If,
-for a call to an unqualified function name, function overload resolution
-selects the functions introduced by such *using-declaration*s, the
-function call is ill-formed.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
@@ -2017,11 +2151,11 @@ void h() {
 When a *using-declaration* brings names from a base class into a derived
 class scope, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
-than conflicting). For *using-declarations* that name a constructor,
 see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
@@ -2252,11 +2386,11 @@ transitive search is unordered. In particular, the order in which
 namespaces were considered and the relationships among the namespaces
 implied by the *using-directive*s do not cause preference to be given to
 any of the declarations found by the search. An ambiguity exists if the
 best match finds two functions with the same signature, even if one is
 in a namespace reachable through *using-directive*s in the namespace of
-the other.[^8]
 ``` cpp
 namespace D {
   int d1;
   void f(char);
@@ -2353,16 +2487,16 @@ with external linkage declared within the *linkage-specification*.
 ``` cpp
 extern "C" void f1(void(*pf)(int));
                                 // the name f1 and its function type have C language
                                 // linkage; pf is a pointer to a C function
 extern "C" typedef void FUNC();
-FUNC f2;                        // the name f2 has \Cpp language linkage and the
                                 // function's type has C language linkage
 extern "C" FUNC f3;             // the name of function f3 and the function's type
                                 // have C language linkage
-void (*pf2)(FUNC*);             // the name of the variable pf2 has \Cpp linkage and
-                                // the type of pf2 is pointer to \Cpp function that
                                 // takes one parameter of type pointer to C function
 extern "C" {
   static void f4();             // the name of the function f4 has
                                 // internal linkage (not C language
                                 // linkage) and the function's type
@@ -2370,24 +2504,23 @@ extern "C" {
 }
 extern "C" void f5() {
   extern void f4();             // OK: Name linkage (internal)
                                 // and function type linkage (C
-                                // language linkage) gotten from
                                 // previous declaration.
 }
 extern void f4();               // OK: Name linkage (internal)
                                 // and function type linkage (C
-                                // language linkage) gotten from
                                 // previous declaration.
-}
 void f6() {
   extern void f4();             // OK: Name linkage (internal)
                                 // and function type linkage (C
-                                // language linkage) gotten from
                                 // previous declaration.
 }
 ```
 A C language linkage is ignored in determining the language linkage of
@@ -2482,13 +2615,13 @@ extern "C" {
   int i;                            // definition
 }
 extern "C" static void g();         // error
 ```
-Because the language linkage is part of a function type, when a pointer
-to C function (for example) is dereferenced, the function to which it
-refers is considered a C function.
 Linkage from C++to objects defined in other languages and to objects
 defined in C++from other languages is implementation-defined and
 language-dependent. Only where the object layout strategies of two
 language implementations are similar enough can such linkage be
@@ -2513,11 +2646,11 @@ attribute-specifier:
 ```
 ``` bnf
 alignment-specifier:
   'alignas (' type-id '...'ₒₚₜ ')'
-  'alignas (' alignment-expression '...'ₒₚₜ ')'
 ```
 ``` bnf
 attribute-list:
   attributeₒₚₜ
@@ -2600,18 +2733,18 @@ For an *attribute-token* not specified in this International Standard,
 the behavior is *implementation-defined*.
 Two consecutive left square bracket tokens shall appear only when
 introducing an *attribute-specifier*. If two consecutive left square
 brackets appear where an *attribute-specifier* is not allowed, the
-program is ill formed even if the brackets match an alternative grammar
 production.
 ``` cpp
 int p[10];
 void f() {
   int x = 42, y[5];
-  int(p[[x] { return x; }()]);  // error: malformed attribute on a nested
                                 // declarator-id and not a function-style cast of
                                 // an element of p.
   y[[] { return 2; }()] = 2;    // error even though attributes are not allowed
                                 // in this context.
 }
@@ -2619,20 +2752,24 @@ void f() {
 ### Alignment specifier <a id="dcl.align">[[dcl.align]]</a>
 An *alignment-specifier* may be applied to a variable or to a class data
 member, but it shall not be applied to a bit-field, a function
-parameter, the formal parameter of a catch clause ([[except.handle]]),
-or a variable declared with the `register` storage class specifier. An
-*alignment-specifier* may also be applied to the declaration of a class
-or enumeration type. An *alignment-specifier* with an ellipsis is a pack
-expansion ([[temp.variadic]]).
 When the *alignment-specifier* is of the form `alignas(`
-*assignment-expression* `)`:
-- the *assignment-expression* shall be an integral constant expression
 - if the constant expression evaluates to a fundamental alignment, the
   alignment requirement of the declared entity shall be the specified
   fundamental alignment
 - if the constant expression evaluates to an extended alignment and the
   implementation supports that alignment in the context of the
@@ -2764,18 +2901,18 @@ int foo_array[10][10];
 [[carries_dependency]] struct foo* f(int i) {
   return foo_head[i].load(memory_order_consume);
 }
-[[carries_dependency]] int g(int* x, int* y) {
   return kill_dependency(foo_array[*x][*y]);
 }
 /* Translation unit B. */
 [[carries_dependency]] struct foo* f(int i);
-[[carries_dependency]] int* g(int* x, int* y);
 int c = 3;
 void h(int i) {
   struct foo* p;
@@ -2790,11 +2927,48 @@ The `carries_dependency` attribute on function `f` means that the return
 value carries a dependency out of `f`, so that the implementation need
 not constrain ordering upon return from `f`. Implementations of `f` and
 its caller may choose to preserve dependencies instead of emitting
 hardware memory ordering instructions (a.k.a. fences).
-Function `g`’s second argument has a `carries_dependency` attribute, but
-its first argument does not. Therefore, function `h`’s first call to `g`
-carries a dependency into `g`, but its second call does not. The
 implementation might need to insert a fence prior to the second call to
 `g`.

     opaque-enum-declaration
 ```
 ``` bnf
 alias-declaration:
+    'using' identifier attribute-specifier-seqₒₚₜ '=' type-id ';'
 ```
 ``` bnf
 simple-declaration:
     decl-specifier-seqₒₚₜ init-declarator-listₒₚₜ ';'
 [[dcl.enum]]), that is, when the *decl-specifier-seq* contains either a
 *class-specifier*, an *elaborated-type-specifier* with a *class-key* (
 [[class.name]]), or an *enum-specifier*. In these cases and whenever a
 *class-specifier* or *enum-specifier* is present in the
 *decl-specifier-seq*, the identifiers in these specifiers are among the
+names being declared by the declaration (as *class-name*s, *enum-name*s,
+or *enumerator*s, depending on the syntax). In such cases, the
 *decl-specifier-seq* shall introduce one or more names into the program,
 or shall redeclare a name introduced by a previous declaration.
 ``` cpp
 enum { };           // ill-formed
 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
+```
 ## Enumeration declarations <a id="dcl.enum">[[dcl.enum]]</a>
 An enumeration is a distinct type ([[basic.compound]]) with named
 constants. Its name becomes an *enum-name*, within its scope.
 ```
 The optional *attribute-specifier-seq* in the *enum-head* and the
 *opaque-enum-declaration* appertains to the enumeration; the attributes
 in that *attribute-specifier-seq* are thereafter considered attributes
+of the enumeration whenever it is named. A `:` following “`enum`
+*identifier*” is parsed as part of an *enum-base*. This resolves a
+potential ambiguity between the declaration of an enumeration with an
+*enum-base* and the declaration of an unnamed bit-field of enumeration
+type.
+``` cpp
+struct S {
+     enum E : int {};
+     enum E : int {};  // error: redeclaration of enumeration
+   };
+```
 The enumeration type declared with an *enum-key* of only `enum` is an
 unscoped enumeration, and its *enumerator*s are *unscoped enumerators*.
 The *enum-key*s `enum class` and `enum struct` are semantically
 equivalent; an enumeration type declared with one of these is a *scoped
 by a *using-declaration*), and the *enum-specifier* shall appear in a
 namespace enclosing the previous declaration.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an underlying type. The underlying type can be
+explicitly specified using an *enum-base*. For a scoped enumeration
+type, the underlying type is `int` if it is not explicitly specified. In
+both of these cases, the underlying type is said to be *fixed*.
+Following the closing brace of an *enum-specifier*, each enumerator has
+the type of its enumeration. If the underlying type is fixed, the type
+of each enumerator prior to the closing brace is the underlying type and
+the *constant-expression* in the *enumerator-definition* shall be a
+converted constant expression of the underlying type ([[expr.const]]).
+If the underlying type is not fixed, the type of each enumerator prior
+to the closing brace is determined as follows:
+- If an initializer is specified for an enumerator, the
   *constant-expression* shall be an integral constant expression (
+  [[expr.const]]). If the expression has unscoped enumeration type, the
+  enumerator has the underlying type of that enumeration type, otherwise
+ it has the same type as the expression.
+- If no initializer is specified for the first enumerator, its type is
+ an unspecified signed integral type.
+- Otherwise the type of the enumerator is the same as that of the
+ preceding enumerator unless the incremented value is not representable
+ in that type, in which case the type is an unspecified integral type
+  sufficient to contain the incremented value. If no such type exists,
+  the program is ill-formed.
+An enumeration whose underlying type is fixed is an incomplete type from
+its point of declaration ([[basic.scope.pdecl]]) to immediately after
+its *enum-base* (if any), at which point it becomes a complete type. An
+enumeration whose underlying type is not fixed is an incomplete type
+from its point of declaration to immediately after the closing `}` of
+its *enum-specifier*, at which point it becomes a complete type.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
 The size of the smallest bit-field large enough to hold all the values
 of the enumeration type is max(M,1) if bₘᵢₙ is zero and M+1 otherwise.
 It is possible to define an enumeration that has values not defined by
 any of its enumerators. If the *enumerator-list* is empty, the values of
 the enumeration are as if the enumeration had a single enumerator with
+value 0.[^4]
+Two enumeration types are *layout-compatible* if they have the same
 *underlying type*.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion ([[conv.prom]]).
 ```
 where `inline` appears if and only if it appears in the
 *unnamed-namespace-definition*, all occurrences of *unique* in a
 translation unit are replaced by the same identifier, and this
+identifier differs from all other identifiers in the entire program.[^5]
 ``` cpp
 namespace { int i; }            // unique ::i
 void f() { i++; }               // unique ::i++
   void Q::V::g() { /* ... */ }  // error: R doesn't enclose Q
 }
 ```
 Every name first declared in a namespace is a member of that namespace.
+If a `friend` declaration in a non-local class first declares a class,
+function, class template or function template[^6] the friend is a member
+of the innermost enclosing namespace. The `friend` declaration does not
+by itself make the name visible to unqualified lookup (
+[[basic.lookup.unqual]]) or qualified lookup ([[basic.lookup.qual]]).
+The name of the friend will be visible in its namespace if a matching
+declaration is provided at namespace scope (either before or after the
+class definition granting friendship). If a friend function or function
+template is called, its name may be found by the name lookup that
+considers functions from namespaces and classes associated with the
+types of the function arguments ([[basic.lookup.argdep]]). If the name
+in a `friend` declaration is neither qualified nor a *template-id* and
+the declaration is a function or an *elaborated-type-specifier*, the
+lookup to determine whether the entity has been previously declared
+shall not consider any scopes outside the innermost enclosing namespace.
+The other forms of `friend` declarations cannot declare a new member of
+the innermost enclosing namespace and thus follow the usual lookup
+rules.
 ``` cpp
+// Assume f and g have not yet been declared.
 void h(int);
 template <class T> void f2(T);
 namespace A {
   class X {
     friend void f(X);           // A::f(X) is a friend
 *using-declaration* does not declare its enumerators in the
 *using-declaration*’s declarative region. If a *using-declaration* names
 a constructor ([[class.qual]]), it implicitly declares a set of
 constructors in the class in which the *using-declaration* appears (
 [[class.inhctor]]); otherwise the name specified in a
+*using-declaration* is a synonym for a set of declarations in another
+namespace or class.
 Every *using-declaration* is a *declaration* and a *member-declaration*
 and so can be used in a class definition.
 ``` cpp
   using B::i;
   using B::i;       // error: double member declaration
 };
 ```
+Members added to the namespace after the *using-declaration* are not
+considered when a use of the name is made. Thus, additional overloads
+added after the *using-declaration* are ignored, but default function
+arguments ([[dcl.fct.default]]), default template arguments (
+[[temp.param]]), and template specializations ([[temp.class.spec]],
+[[temp.expl.spec]]) are considered.
 ``` cpp
 namespace A {
   void f(int);
 }
   struct x x1;      // x1 has class type B::x
 }
 ```
 If a function declaration in namespace scope or block scope has the same
+name and the same parameter-type-list ([[dcl.fct]]) as a function
+introduced by a *using-declaration*, and the declarations do not declare
+the same function, the program is ill-formed. If a function template
+declaration in namespace scope has the same name, parameter-type-list,
+return type, and template parameter list as a function template
+introduced by a *using-declaration*, the program is ill-formed. Two
+*using-declaration*s may introduce functions with the same name and the
+same parameter-type-list. If, for a call to an unqualified function
+name, function overload resolution selects the functions introduced by
+such *using-declaration*s, the function call is ill-formed.
 ``` cpp
 namespace B {
   void f(int);
   void f(double);
 When a *using-declaration* brings names from a base class into a derived
 class scope, member functions and member function templates in the
 derived class override and/or hide member functions and member function
 templates with the same name, parameter-type-list ([[dcl.fct]]),
 cv-qualification, and *ref-qualifier* (if any) in a base class (rather
+than conflicting). For *using-declaration*s that name a constructor,
 see  [[class.inhctor]].
 ``` cpp
 struct B {
   virtual void f(int);
 namespaces were considered and the relationships among the namespaces
 implied by the *using-directive*s do not cause preference to be given to
 any of the declarations found by the search. An ambiguity exists if the
 best match finds two functions with the same signature, even if one is
 in a namespace reachable through *using-directive*s in the namespace of
+the other.[^7]
 ``` cpp
 namespace D {
   int d1;
   void f(char);
 ``` cpp
 extern "C" void f1(void(*pf)(int));
                                 // the name f1 and its function type have C language
                                 // linkage; pf is a pointer to a C function
 extern "C" typedef void FUNC();
+FUNC f2;                        // the name f2 has C++language linkage and the
                                 // function's type has C language linkage
 extern "C" FUNC f3;             // the name of function f3 and the function's type
                                 // have C language linkage
+void (*pf2)(FUNC*);             // the name of the variable pf2 has C++linkage and
+                                // the type of pf2 is pointer to C++function that
                                 // takes one parameter of type pointer to C function
 extern "C" {
   static void f4();             // the name of the function f4 has
                                 // internal linkage (not C language
                                 // linkage) and the function's type
 }
 extern "C" void f5() {
   extern void f4();             // OK: Name linkage (internal)
                                 // and function type linkage (C
+                                // language linkage) obtained from
                                 // previous declaration.
 }
 extern void f4();               // OK: Name linkage (internal)
                                 // and function type linkage (C
+                                // language linkage) obtained from
                                 // previous declaration.
 void f6() {
   extern void f4();             // OK: Name linkage (internal)
                                 // and function type linkage (C
+                                // language linkage) obtained from
                                 // previous declaration.
 }
 ```
 A C language linkage is ignored in determining the language linkage of
   int i;                            // definition
 }
 extern "C" static void g();         // error
 ```
+Because the language linkage is part of a function type, when
+indirecting through a pointer to C function, the function to which the
+resulting lvalue refers is considered a C function.
 Linkage from C++to objects defined in other languages and to objects
 defined in C++from other languages is implementation-defined and
 language-dependent. Only where the object layout strategies of two
 language implementations are similar enough can such linkage be
 ```
 ``` bnf
 alignment-specifier:
   'alignas (' type-id '...'ₒₚₜ ')'
+  'alignas (' constant-expression '...'ₒₚₜ ')'
 ```
 ``` bnf
 attribute-list:
   attributeₒₚₜ
 the behavior is *implementation-defined*.
 Two consecutive left square bracket tokens shall appear only when
 introducing an *attribute-specifier*. If two consecutive left square
 brackets appear where an *attribute-specifier* is not allowed, the
+program is ill-formed even if the brackets match an alternative grammar
 production.
 ``` cpp
 int p[10];
 void f() {
   int x = 42, y[5];
+  int(p[[x] { return x; }()]);  // error: invalid attribute on a nested
                                 // declarator-id and not a function-style cast of
                                 // an element of p.
   y[[] { return 2; }()] = 2;    // error even though attributes are not allowed
                                 // in this context.
 }
 ### Alignment specifier <a id="dcl.align">[[dcl.align]]</a>
 An *alignment-specifier* may be applied to a variable or to a class data
 member, but it shall not be applied to a bit-field, a function
+parameter, an *exception-declaration* ([[except.handle]]), or a
+variable declared with the `register` storage class specifier. An
+*alignment-specifier* may also be applied to the declaration or
+definition of a class (in an *elaborated-type-specifier* (
+[[dcl.type.elab]]) or *class-head* (Clause  [[class]]), respectively)
+and to the declaration or definition of an enumeration (in an
+*opaque-enum-declaration* or *enum-head*, respectively ([[dcl.enum]])).
+An *alignment-specifier* with an ellipsis is a pack expansion (
+[[temp.variadic]]).
 When the *alignment-specifier* is of the form `alignas(`
+*constant-expression* `)`:
+- the *constant-expression* shall be an integral constant expression
 - if the constant expression evaluates to a fundamental alignment, the
   alignment requirement of the declared entity shall be the specified
   fundamental alignment
 - if the constant expression evaluates to an extended alignment and the
   implementation supports that alignment in the context of the
 [[carries_dependency]] struct foo* f(int i) {
   return foo_head[i].load(memory_order_consume);
 }
+int g(int* x, int* y [[carries_dependency]]) {
   return kill_dependency(foo_array[*x][*y]);
 }
 /* Translation unit B. */
 [[carries_dependency]] struct foo* f(int i);
+int g(int* x, int* y [[carries_dependency]]);
 int c = 3;
 void h(int i) {
   struct foo* p;
 value carries a dependency out of `f`, so that the implementation need
 not constrain ordering upon return from `f`. Implementations of `f` and
 its caller may choose to preserve dependencies instead of emitting
 hardware memory ordering instructions (a.k.a. fences).
+Function `g`’s second parameter has a `carries_dependency` attribute,
+but its first parameter does not. Therefore, function `h`’s first call
+to `g` carries a dependency into `g`, but its second call does not. The
 implementation might need to insert a fence prior to the second call to
 `g`.
+### Deprecated attribute <a id="dcl.attr.deprecated">[[dcl.attr.deprecated]]</a>
+The *attribute-token* `deprecated` can be used to mark names and
+entities whose use is still allowed, but is discouraged for some reason.
+in particular, `deprecated` is appropriate for names and entities that
+are deemed obsolescent or unsafe. It shall appear at most once in each
+*attribute-list*. An *attribute-argument-clause* may be present and, if
+present, it shall have the form:
+``` cpp
+( string-literal )
+```
+the *string-literal* in the *attribute-argument-clause* could be used to
+explain the rationale for deprecation and/or to suggest a replacing
+entity.
+The attribute may be applied to the declaration of a class, a
+*typedef-name*, a variable, a non-static data member, a function, an
+enumeration, or a template specialization.
+A name or entity declared without the `deprecated` attribute can later
+be re-declared with the attribute and vice-versa. Thus, an entity
+initially declared without the attribute can be marked as deprecated by
+a subsequent redeclaration. However, after an entity is marked as
+deprecated, later redeclarations do not un-deprecate the entity.
+Redeclarations using different forms of the attribute (with or without
+the *attribute-argument-clause* or with different
+*attribute-argument-clause*s) are allowed.
+Implementations may use the `deprecated `attribute to produce a
+diagnostic message in case the program refers to a name or entity other
+than to declare it, after a declaration that specifies the attribute.
+The diagnostic message may include the text provided within the
+*attribute-argument-clause* of any `deprecated` attribute applied to the
+name or entity.

Diff to HTML by rtfpessoa