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

Files changed (1) hide show

tmp/tmpng4sxnb2/{from.md → to.md} +356 -276

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

@@ -25,11 +25,11 @@ modify the type of the specifiers with operators such as `*` (pointer
 to) and `()` (function returning). Initial values can also be specified
 in a declarator; initializers are discussed in  [[dcl.init]] and
 [[class.init]].
 Each *init-declarator* in a declaration is analyzed separately as if it
-was in a declaration by itself.[^9]
 Declarators have the syntax
 ``` bnf
 declarator:
@@ -51,12 +51,12 @@ noptr-declarator:
     '(' ptr-declarator ')'
 ```
 ``` bnf
 parameters-and-qualifiers:
-    '(' parameter-declaration-clause ')' attribute-specifier-seqₒₚₜ cv-qualifier-seqₒₚₜ
-  ref-qualifierₒₚₜ exception-specificationₒₚₜ
 ```
 ``` bnf
 trailing-return-type:
     '->' trailing-type-specifier-seq abstract-declaratorₒₚₜ
@@ -88,17 +88,12 @@ ref-qualifier:
 ```
 ``` bnf
 declarator-id:
     '...'ₒₚₜ id-expression
-    nested-name-specifierₒₚₜ class-name
 ```
-A *class-name* has special meaning in a declaration of the class of that
-name and when qualified by that name using the scope resolution operator
-`::` ([[expr.prim]], [[class.ctor]], [[class.dtor]]).
 The optional *attribute-specifier-seq* in a *trailing-return-type*
 appertains to the indicated return type. The *type-id* in a
 *trailing-return-type* includes the longest possible sequence of
 *abstract-declarator*s. This resolves the ambiguous binding of array and
 function declarators.
@@ -283,32 +278,26 @@ void h(int *(C[10]));           // void h(int *(*_fp)(C _parm[10]));
 A list of declarators appears after an optional (Clause  [[dcl.dcl]])
 *decl-specifier-seq* ([[dcl.spec]]). Each declarator contains exactly
 one *declarator-id*; it names the identifier that is declared. An
 *unqualified-id* occurring in a *declarator-id* shall be a simple
-*identifier* except for the declaration of some special functions (
-[[class.conv]], [[class.dtor]], [[over.oper]]) and for the declaration
-of template specializations or partial specializations ([[temp.spec]]).
-A *declarator-id* shall not be qualified except for the definition of a
-member function ([[class.mfct]]) or static data member (
-[[class.static]]) outside of its class, the definition or explicit
-instantiation of a function or variable member of a namespace outside of
-its namespace, or the definition of an explicit specialization outside
-of its namespace, or the declaration of a friend function that is a
-member of another class or namespace ([[class.friend]]). When the
-*declarator-id* is qualified, the declaration shall refer to a
-previously declared member of the class or namespace to which the
-qualifier refers (or, in the case of a namespace, of an element of the
-inline namespace set of that namespace ([[namespace.def]])) or to a
-specialization thereof; the member shall not merely have been introduced
-by a *using-declaration* in the scope of the class or namespace
-nominated by the *nested-name-specifier* of the *declarator-id*. The
-*nested-name-specifier* of a qualified *declarator-id* shall not begin
-with a *decltype-specifier*. If the qualifier is the global `::` scope
-resolution operator, the *declarator-id* refers to a name declared in
-the global namespace scope. The optional *attribute-specifier-seq*
-following a *declarator-id* appertains to the entity that is declared.
 A `static`, `thread_local`, `extern`, `register`, `mutable`, `friend`,
 `inline`, `virtual`, or `typedef` specifier applies directly to each
 *declarator-id* in an *init-declarator-list*; the type specified for
 each *declarator-id* depends on both the *decl-specifier-seq* and its
@@ -420,13 +409,15 @@ cv-unqualified pointer later, for example:
 *p = 5;             // clobber ci
 ```
 See also  [[expr.ass]] and  [[dcl.init]].
-There are no pointers to references; see  [[dcl.ref]]. Since the address
-of a bit-field ([[class.bit]]) cannot be taken, a pointer can never
-point to a bit-field.
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
@@ -437,13 +428,13 @@ In a declaration `T` `D` where `D` has either of the forms
 and the type of the identifier in the declaration `T` `D1` is “ `T`,”
 then the type of the identifier of `D` is “ reference to `T`.” The
 optional *attribute-specifier-seq* appertains to the reference type.
 Cv-qualified references are ill-formed except when the cv-qualifiers are
-introduced through the use of a typedef ([[dcl.typedef]]) or of a
-template type argument ([[temp.arg]]), in which case the cv-qualifiers
-are ignored.
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
@@ -513,20 +504,20 @@ contains an explicit `extern` specifier ([[dcl.stc]]), is a class
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
 object or function. in particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
-would be to bind it to the “object” obtained by dereferencing a null
-pointer, which causes undefined behavior. As described in
 [[class.bit]], a reference cannot be bound directly to a bit-field.
-If a typedef ([[dcl.typedef]]), a type *template-parameter* (
-[[temp.arg.type]]), or a *decltype-specifier* ([[dcl.type.simple]])
-denotes a type `TR` that is a reference to a type `T`, an attempt to
-create the type “lvalue reference to cv `TR`” creates the type “lvalue
-reference to `T`”, while an attempt to create the type “rvalue reference
-to cv `TR`” creates the type `TR`.
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
@@ -540,10 +531,13 @@ RRI&& r5 = 5;                   // r5 has the type int&&
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
@@ -607,24 +601,25 @@ and the type of the identifier in the declaration `T` `D1` is
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
 `auto` , the program is ill-formed. `T` is called the array *element
 type*; this type shall not be a reference type, the (possibly
 cv-qualified) type `void`, a function type or an abstract class type. If
-the *constant-expression* ([[expr.const]]) is present, it shall be an
-integral constant expression and its value shall be greater than zero.
-The constant expression specifies the *bound* of (number of elements in)
-the array. If the value of the constant expression is `N`, the array has
-`N` elements numbered `0` to `N-1`, and the type of the identifier of
-`D` is “ array of `N` `T`”. An object of array type contains a
-contiguously allocated non-empty set of `N` subobjects of type `T`.
-Except as noted below, if the constant expression is omitted, the type
-of the identifier of `D` is “ array of unknown bound of `T`”, an
-incomplete object type. The type “ array of `N` `T`” is a different type
-from the type “ array of unknown bound of `T`”, see  [[basic.types]].
-Any type of the form “ array of `N` `T`” is adjusted to “array of `N`
-`T`”, and similarly for “array of unknown bound of `T`”. The optional
-*attribute-specifier-seq* appertains to the array.
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
@@ -753,11 +748,11 @@ and the type of the contained *declarator-id* in the declaration `T`
 “*derived-declarator-type-list* function of
 (*parameter-declaration-clause*) *cv-qualifier-seq*
 *ref-qualifier*returning *trailing-return-type*”. The optional
 *attribute-specifier-seq* appertains to the function type.
-A type of either form is a *function type*.[^10]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ ...ₒₚₜ
     parameter-declaration-list ',' ...
@@ -783,18 +778,18 @@ appertains to the parameter.
 The *parameter-declaration-clause* determines the arguments that can be
 specified, and their processing, when the function is called. the
 *parameter-declaration-clause* is used to convert the arguments
 specified on the function call; see  [[expr.call]]. If the
 *parameter-declaration-clause* is empty, the function takes no
-arguments. The parameter list `(void)` is equivalent to the empty
-parameter list. Except for this special case, `void` shall not be a
-parameter type (though types derived from `void`, such as `void*`, can).
-If the *parameter-declaration-clause* terminates with an ellipsis or a
-function parameter pack ([[temp.variadic]]), the number of arguments
-shall be equal to or greater than the number of parameters that do not
-have a default argument and are not function parameter packs. Where
-syntactically correct and where “” is not part of an
 *abstract-declarator*, “” is synonymous with “”. the declaration
 ``` cpp
 int printf(const char*, ...);
 ```
@@ -828,20 +823,31 @@ presence or absence of the ellipsis or a function parameter pack is the
 function’s *parameter-type-list*. This transformation does not affect
 the types of the parameters. For example,
 `int(*)(const int p, decltype(p)*)` and `int(*)(int, const int*)` are
 identical types.
-A *cv-qualifier-seq* or a *ref-qualifier* shall only be part of:
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
-  [[temp.names]]).
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
 latter case, the cv-qualifiers are ignored. a function type that has a
 *cv-qualifier-seq* is not a cv-qualified type; there are no cv-qualified
@@ -870,20 +876,21 @@ int fseek(FILE*, long, int);
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
 If the type of a parameter includes a type of the form “pointer to array
 of unknown bound of `T`” or “reference to array of unknown bound of
-`T`,” the program is ill-formed.[^11] Functions shall not have a return
 type of type array or function, although they may have a return type of
 type pointer or reference to such things. There shall be no arrays of
 functions, although there can be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
-incomplete class type (possibly cv-qualified) unless the function
-definition is nested within the *member-specification* for that class
-(including definitions in nested classes defined within the class).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
 ``` cpp
@@ -891,34 +898,18 @@ typedef void F();
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
-A typedef of a function type whose declarator includes a
-*cv-qualifier-seq* shall be used only to declare the function type for a
-non-static member function, to declare the function type to which a
-pointer to member refers, or to declare the top-level function type of
-another function typedef declaration.
-``` cpp
-typedef int FIC(int) const;
-FIC f;              // ill-formed: does not declare a member function
-struct S {
-  FIC f;            // OK
-};
-FIC S::*pm = &S::f; // OK
-```
 An identifier can optionally be provided as a parameter name; if present
-in a function definition ([[dcl.fct.def]]), it names a parameter
-(sometimes called “formal argument”). In particular, parameter names are
-also optional in function definitions and names used for a parameter in
-different declarations and the definition of a function need not be the
-same. If a parameter name is present in a function declaration that is
-not a definition, it cannot be used outside of its function declarator
-because that is the extent of its potential scope (
-[[basic.scope.proto]]).
 the declaration
 ``` cpp
 int i,
@@ -952,11 +943,11 @@ IFUNC*  fpif(int);
 ```
 or
 ``` cpp
-auto fpif(int)->int(*)(int)
 ```
 A *trailing-return-type* is most useful for a type that would be more
 complicated to specify before the *declarator-id*:
@@ -968,10 +959,13 @@ rather than
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
 function parameter pack ([[temp.variadic]]). Otherwise, the
@@ -991,13 +985,13 @@ void g() {
 ```
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
-of the parameter names a template parameter pack that has not been
-expanded; otherwise, it is parsed as part of the
-*parameter-declaration-clause*.[^12]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
@@ -1023,11 +1017,11 @@ A default argument shall be specified only in the
 *parameter-declaration-clause* of a function declaration or in a
 *template-parameter* ([[temp.param]]); in the latter case, the
 *initializer-clause* shall be an *assignment-expression*. A default
 argument shall not be specified for a parameter pack. If it is specified
 in a *parameter-declaration-clause*, it shall not occur within a
-*declarator* or *abstract-declarator* of a *parameter-declaration*.[^13]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
@@ -1066,20 +1060,19 @@ accumulated sets of default arguments at the end of the translation
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
 template in the translation unit.
-A default argument is implicitly converted (Clause  [[conv]]) to the
-parameter type. The default argument has the same semantic constraints
-as the initializer in a declaration of a variable of the parameter type,
-using the copy-initialization semantics ([[dcl.init]]). The names in
-the default argument are bound, and the semantic constraints are
-checked, at the point where the default argument appears. Name lookup
-and checking of semantic constraints for default arguments in function
-templates and in member functions of class templates are performed as
-described in  [[temp.inst]]. in the following code, `g` will be called
-with the value `f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
@@ -1098,13 +1091,16 @@ up as described in  [[basic.lookup.unqual]]. Access checking applies to
 names in default arguments as described in Clause  [[class.access]].
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
-member function declaration in the class definition. Default arguments
-for a member function of a class template shall be specified on the
-initial declaration of the member function within the class template.
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
@@ -1133,16 +1129,16 @@ function.
 class A {
   void f(A* p = this) { }       // error
 };
 ```
-Default arguments are evaluated each time the function is called. The
-order of evaluation of function arguments is unspecified. Consequently,
-parameters of a function shall not be used in a default argument, even
-if they are not evaluated. Parameters of a function declared before a
-default argument are in scope and can hide namespace and class member
-names.
 ``` cpp
 int a;
 int f(int a, int b = a);            // error: parameter a
                                     // used as default argument
@@ -1279,22 +1275,22 @@ void print(int a, int) {
 }
 ```
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
-(see  [[basic.scope.local]]).
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
-distinct from that of any other object in the program.[^14]
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
@@ -1305,11 +1301,11 @@ void f(const char * s = __func__);  // error: __func__ is undeclared
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator ' = default ;'
 ```
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
@@ -1320,50 +1316,51 @@ explicitly defaulted shall
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
 An explicitly-defaulted function may be declared `constexpr` only if it
-would have been implicitly declared as `constexpr`, and may have an
-explicit *exception-specification* only if it is compatible (
-[[except.spec]]) with the *exception-specification* on the implicit
-declaration. If a function is explicitly defaulted on its first
-declaration,
 - it is implicitly considered to be `constexpr` if the implicit
-  declaration would be,
 - it is implicitly considered to have the same *exception-specification*
-  as if it had been implicitly declared ([[except.spec]]), and
-- in the case of a copy constructor, move constructor, copy assignment
-  operator, or move assignment operator, it shall have the same
-  parameter type as if it had been implicitly declared.
 ``` cpp
 struct S {
   constexpr S() = default;                  // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;                   // ill-formed: default argument
   void operator=(const S&) = default;       // ill-formed: non-matching return type
-  ~S() throw(int) = default;                // ill-formed: exception specification does not match
 private:
   int i;
   S(S&);                                    // OK: private copy constructor
 };
 S::S(S&) = default;                         // OK: defines copy constructor
 ```
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
-[[class.copy]]), which might mean defining them as deleted. A special
-member function is *user-provided* if it is user-declared and not
-explicitly defaulted or deleted on its first declaration. A
-user-provided explicitly-defaulted function (i.e., explicitly defaulted
-after its first declaration) is defined at the point where it is
-explicitly defaulted; if such a function is implicitly defined as
-deleted, the program is ill-formed. Declaring a function as defaulted
-after its first declaration can provide efficient execution and concise
-definition while enabling a stable binary interface to an evolving code
-base.
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
@@ -1382,11 +1379,11 @@ nontrivial1::nontrivial1() = default;           // not first declaration
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
-attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator ' = delete ;'
 ```
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
@@ -1508,15 +1505,18 @@ int c(b);
 Default arguments are more restricted; see  [[dcl.fct.default]].
 The order of initialization of variables with static storage duration is
 described in  [[basic.start]] and  [[stmt.dcl]].
 To *zero-initialize* an object or reference of type `T` means:
-- if `T` is a scalar type ([[basic.types]]), the object is set to the
-  value `0` (zero), taken as an integral constant expression, converted
- to `T`;[^15]
 - if `T` is a (possibly cv-qualified) non-union class type, each
   non-static data member and each base-class subobject is
   zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
@@ -1525,29 +1525,33 @@ To *zero-initialize* an object or reference of type `T` means:
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
-  the default constructor for `T` is called (and the initialization is
-  ill-formed if `T` has no accessible default constructor);
 - if `T` is an array type, each element is default-initialized;
 - otherwise, no initialization is performed.
 If a program calls for the default initialization of an object of a
 const-qualified type `T`, `T` shall be a class type with a user-provided
 default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
-  with a user-provided constructor ([[class.ctor]]), then the default
-  constructor for `T` is called (and the initialization is ill-formed if
- `T` has no accessible default constructor);
-- if `T` is a (possibly cv-qualified) non-union class type without a
- user-provided constructor, then the object is zero-initialized and, if
- `T`’s implicitly-declared default constructor is non-trivial, that
-  constructor is called.
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
 An object that is value-initialized is deemed to be constructed and thus
 subject to provisions of this International Standard applying to
@@ -1575,14 +1579,48 @@ is not the declaration of an object of class `X`, but the declaration of
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 If no initializer is specified for an object, the object is
-default-initialized; if no initialization is performed, an object with
-automatic or dynamic storage duration has indeterminate value. Objects
-with static or thread storage duration are zero-initialized, see
-[[basic.start.init]].
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
@@ -1696,15 +1734,14 @@ An *initializer-clause* followed by an ellipsis is a pack expansion (
 [[temp.variadic]]).
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class (Clause  [[class]]) with no
-user-provided constructors ([[class.ctor]]), no
-*brace-or-equal-initializer*s for non-static data members (
-[[class.mem]]), no private or protected non-static data members (Clause
-[[class.access]]), no base classes (Clause  [[class.derived]]), and no
-virtual functions ([[class.virtual]]).
 When an aggregate is initialized by an initializer list, as specified
 in  [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the members of the aggregate, in increasing subscript
 or member order. Each member is copy-initialized from the corresponding
@@ -1740,11 +1777,11 @@ int x[] = { 1, 3, 5 };
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 An empty initializer list `{}` shall not be used as the
-*initializer-clause * for an array of unknown bound.[^16]
 Static data members and anonymous bit-fields are not considered members
 of the class for purposes of aggregate initialization.
 ``` cpp
@@ -1771,20 +1808,30 @@ char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
 members in the aggregate, then each member not explicitly initialized
-shall be initialized from an empty initializer list (
 [[dcl.init.list]]).
 ``` cpp
-struct S { int a; const char* b; int c; };
 S ss = { 1, "asdf" };
 ```
-initializes `ss.a` with 1, `ss.b` with `"asdf"`, and `ss.c` with the
-value of an expression of the form `int()`, that is, `0`.
 If an aggregate class `C` contains a subaggregate member `m` that has no
 members for purposes of aggregate initialization, the
 *initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
@@ -1829,17 +1876,11 @@ float y[4][3] = {
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
-In a declaration of the form
-``` cpp
-T x = { a };
-```
-braces can be elided in an *initializer-list* as follows.[^17] If the
 *initializer-list* begins with a left brace, then the succeeding
 comma-separated list of *initializer-clause*s initializes the members of
 a subaggregate; it is erroneous for there to be more
 *initializer-clause*s than members. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
@@ -1928,17 +1969,17 @@ As described above, the braces around the *initializer-clause* for a
 union member can be omitted if the union is a member of another
 aggregate.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
-A `char` array (whether plain `char`, `signed` `char`, or `unsigned`
-`char`), `char16_t` array, `char32_t` array, or `wchar_t` array can be
-initialized by a narrow character literal, `char16_t` string literal,
-`char32_t` string literal, or wide string literal, respectively, or by
-an appropriately-typed string literal enclosed in braces. Successive
-characters of the value of the string literal initialize the elements of
-the array.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
@@ -1996,33 +2037,30 @@ extern int& r2;                 // OK
 ```
 Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
 same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
 `T2`” if `T1` is reference-related to `T2` and *cv1* is the same
-cv-qualification as, or greater cv-qualification than, *cv2*. For
-purposes of overload resolution, cases for which *cv1* is greater
-cv-qualification than *cv2* are identified as
-*reference-compatible with added qualification* (see
-[[over.ics.rank]]). In all cases where the reference-related or
-reference-compatible relationship of two types is used to establish the
-validity of a reference binding, and `T1` is a base class of `T2`, a
-program that necessitates such a binding is ill-formed if `T1` is an
-inaccessible (Clause  [[class.access]]) or ambiguous (
-[[class.member.lookup]]) base class of `T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “ `T1`” is
     reference-compatible with “ `T2`,” or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
-    reference-related to `T2`, and can be implicitly converted to an
- lvalue of type “ `T3`,” where “ `T1`” is reference-compatible with “
- `T3`”[^18] (this conversion is selected by enumerating the
- applicable conversion functions ([[over.match.ref]]) and choosing
- the best one through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
   subobject of the object). The usual lvalue-to-rvalue ([[conv.lval]]),
@@ -2048,16 +2086,18 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
-    - is an xvalue, class prvalue, array prvalue or function lvalue and
-      “*cv1* `T1`” is reference-compatible with “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
-      reference-related to `T2`, and can be implicitly converted to an
- xvalue, class prvalue, or function lvalue of type “*cv3* `T3`”,
- where “*cv1* `T1`” is reference-compatible with “*cv3* `T3`”,
     then the reference is bound to the value of the initializer
     expression in the first case and to the result of the conversion in
     the second case (or, in either case, to an appropriate base class
     subobject). In the second case, if the reference is an rvalue
@@ -2079,18 +2119,40 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
     int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
                                         // result of operator int&
     ```
-  - Otherwise, a temporary of type “ `T1`” is created and initialized
- from the initializer expression using the rules for a non-reference
- copy-initialization ([[dcl.init]]). The reference is then bound to
-    the temporary. If `T1` is reference-related to `T2`, *cv1* shall be
- the same cv-qualification as, or greater cv-qualification than,
-    *cv2*. If `T1` is reference-related to `T2` and the reference is an
-    rvalue reference, the initializer expression shall not be an lvalue.
     ``` cpp
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
     const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
@@ -2119,10 +2181,11 @@ list-initialization in a copy-initialization context is called
 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
@@ -2144,22 +2207,24 @@ A constructor is an *initializer-list constructor* if its first
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
-[[over.match.list]]).The template `std::initializer_list` is not
-predefined; if the header `<initializer_list>` is not included prior to
-a use of `std::initializer_list` — even an implicit use in which the
 type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
-- If the initializer list has no elements and `T` is a class type with a
- default constructor, the object is value-initialized.
-- Otherwise, if `T` is an aggregate, aggregate initialization is
-  performed ([[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
@@ -2168,13 +2233,15 @@ follows:
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
-- Otherwise, if `T` is a specialization of `std::initializer_list<E>`,
- an `initializer_list` object is constructed as described below and
-  used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
@@ -2208,15 +2275,25 @@ follows:
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
-  referenced by `T` is list-initialized, and the reference is bound to
- that temporary. As usual, the binding will fail and the program is
- ill-formed if the reference type is an lvalue reference to a non-const
-  type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
@@ -2226,18 +2303,10 @@ follows:
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
-- Otherwise, if the initializer list has a single element, the object or
-  reference is initialized from that element; if a narrowing conversion
-  (see below) is required to convert the element to `T`, the program is
-  ill-formed.
-  ``` cpp
-  int x1 {2};                         // OK
-  int x2 {2.0};                       // error: narrowing
-  ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
@@ -2272,17 +2341,19 @@ ordering holds regardless of the semantics of the initialization; for
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
-initializer list as if the implementation allocated an array of N
-elements of type `E`, where N is the number of elements in the
 initializer list. Each element of that array is copy-initialized with
 the corresponding element of the initializer list, and the
 `std::initializer_list<E>` object is constructed to refer to that array.
-If a narrowing conversion is required to initialize any of the elements,
-the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
@@ -2291,35 +2362,47 @@ X x{ 1,2,3 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
-double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
-The lifetime of the array is the same as that of the `initializer_list`
-object.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
 ```
-For `v1` and `v2`, the `initializer_list` object and array created for
-`{ 1, 2, 3 }` have full-expression lifetime. For `i3`, the
-`initializer_list` object and array have automatic lifetime. The
-implementation is free to allocate the array in read-only memory if an
-explicit array with the same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
@@ -2330,13 +2413,12 @@ A *narrowing conversion* is an implicit conversion
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
-  where the source is a constant expression and the actual value after
- conversion will fit into the target type and will produce the original
-  value when converted back to the original type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
@@ -2374,12 +2456,13 @@ int a[] =
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
-[basic.scope.local]: basic.md#basic.scope.local
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
@@ -2403,11 +2486,10 @@ int a[] =
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
-[class.mfct.non-static]: class.md#class.mfct.non-static
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
@@ -2415,19 +2497,21 @@ int a[] =
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
@@ -2465,15 +2549,18 @@ int a[] =
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
-[expr.prim]: expr.md#expr.prim
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
@@ -2484,19 +2571,19 @@ int a[] =
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
 [namespace.memdef]: #namespace.memdef
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
-[over.ics.rank]: over.md#over.ics.rank
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
@@ -2512,11 +2599,10 @@ int a[] =
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
-[temp.arg]: temp.md#temp.arg
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
@@ -2531,39 +2617,35 @@ int a[] =
 [^1]: The “implicit int” rule of C is no longer supported.
 [^2]: The inline keyword has no effect on the linkage of a function.
-[^3]: The resulting converted value will include an lvalue-to-rvalue
-    conversion ([[conv.lval]]) if the corresponding copy-initialization
-    requires one.
-[^4]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
-[^5]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
-[^6]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
-[^7]: this implies that the name of the class or function is
     unqualified.
-[^8]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
-[^9]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
@@ -2593,42 +2675,40 @@ int a[] =
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
-[^10]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
-[^11]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
-[^12]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
-[^13]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
-[^14]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
-[^15]: As specified in  [[conv.ptr]], converting an integral constant
- expression whose value is `0` to a pointer type results in a null
- pointer value.
-[^16]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
-[^17]: Braces cannot be elided in other uses of list-initialization.
-[^18]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

 to) and `()` (function returning). Initial values can also be specified
 in a declarator; initializers are discussed in  [[dcl.init]] and
 [[class.init]].
 Each *init-declarator* in a declaration is analyzed separately as if it
+was in a declaration by itself.[^8]
 Declarators have the syntax
 ``` bnf
 declarator:
     '(' ptr-declarator ')'
 ```
 ``` bnf
 parameters-and-qualifiers:
+    '(' parameter-declaration-clause ')' cv-qualifier-seqₒₚₜ
+  ref-qualifierₒₚₜ exception-specificationₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 ``` bnf
 trailing-return-type:
     '->' trailing-type-specifier-seq abstract-declaratorₒₚₜ
 ```
 ``` bnf
 declarator-id:
     '...'ₒₚₜ id-expression
 ```
 The optional *attribute-specifier-seq* in a *trailing-return-type*
 appertains to the indicated return type. The *type-id* in a
 *trailing-return-type* includes the longest possible sequence of
 *abstract-declarator*s. This resolves the ambiguous binding of array and
 function declarators.
 A list of declarators appears after an optional (Clause  [[dcl.dcl]])
 *decl-specifier-seq* ([[dcl.spec]]). Each declarator contains exactly
 one *declarator-id*; it names the identifier that is declared. An
 *unqualified-id* occurring in a *declarator-id* shall be a simple
+*identifier* except for the declaration of some special functions (
+[[class.ctor]], [[class.conv]], [[class.dtor]], [[over.oper]]) and for
+the declaration of template specializations or partial specializations (
+[[temp.spec]]). When the *declarator-id* is qualified, the declaration
+shall refer to a previously declared member of the class or namespace to
+which the qualifier refers (or, in the case of a namespace, of an
+element of the inline namespace set of that namespace (
+[[namespace.def]])) or to a specialization thereof; the member shall not
+merely have been introduced by a *using-declaration* in the scope of the
+class or namespace nominated by the *nested-name-specifier* of the
+*declarator-id*. The *nested-name-specifier* of a qualified
+*declarator-id* shall not begin with a *decltype-specifier*. If the
+qualifier is the global `::` scope resolution operator, the
+*declarator-id* refers to a name declared in the global namespace scope.
+The optional *attribute-specifier-seq* following a *declarator-id*
+appertains to the entity that is declared.
 A `static`, `thread_local`, `extern`, `register`, `mutable`, `friend`,
 `inline`, `virtual`, or `typedef` specifier applies directly to each
 *declarator-id* in an *init-declarator-list*; the type specified for
 each *declarator-id* depends on both the *decl-specifier-seq* and its
 *p = 5;             // clobber ci
 ```
 See also  [[expr.ass]] and  [[dcl.init]].
+Forming a pointer to reference type is ill-formed; see  [[dcl.ref]].
+Forming a pointer to function type is ill-formed if the function type
+has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]]. Since the
+address of a bit-field ([[class.bit]]) cannot be taken, a pointer can
+never point to a bit-field.
 ### References <a id="dcl.ref">[[dcl.ref]]</a>
 In a declaration `T` `D` where `D` has either of the forms
 and the type of the identifier in the declaration `T` `D1` is “ `T`,”
 then the type of the identifier of `D` is “ reference to `T`.” The
 optional *attribute-specifier-seq* appertains to the reference type.
 Cv-qualified references are ill-formed except when the cv-qualifiers are
+introduced through the use of a *typedef-name* ([[dcl.typedef]],
+[[temp.param]]) or *decltype-specifier* ([[dcl.type.simple]]), in which
+case the cv-qualifiers are ignored.
 ``` cpp
 typedef int& A;
 const A aref = 3;   // ill-formed; lvalue reference to non-const initialized with rvalue
 ```
 member ([[class.mem]]) declaration within a class definition, or is the
 declaration of a parameter or a return type ([[dcl.fct]]); see
 [[basic.def]]. A reference shall be initialized to refer to a valid
 object or function. in particular, a null reference cannot exist in a
 well-defined program, because the only way to create such a reference
+would be to bind it to the “object” obtained by indirection through a
+null pointer, which causes undefined behavior. As described in
 [[class.bit]], a reference cannot be bound directly to a bit-field.
+If a *typedef-name* ([[dcl.typedef]], [[temp.param]]) or a
+*decltype-specifier* ([[dcl.type.simple]]) denotes a type `TR` that is
+a reference to a type `T`, an attempt to create the type “lvalue
+reference to cv `TR`” creates the type “lvalue reference to `T`”, while
+an attempt to create the type “rvalue reference to cv `TR`” creates the
+type `TR`.
 ``` cpp
 int i;
 typedef int& LRI;
 typedef int&& RRI;
 decltype(r2)& r6 = i;           // r6 has the type int&
 decltype(r2)&& r7 = i;          // r7 has the type int&
 ```
+Forming a reference to function type is ill-formed if the function type
+has *cv-qualifier*s or a *ref-qualifier*; see  [[dcl.fct]].
 ### Pointers to members <a id="dcl.mptr">[[dcl.mptr]]</a>
 In a declaration `T` `D` where `D` has the form
 ``` bnf
 “*derived-declarator-type-list* `T`”, then the type of the identifier of
 `D` is an array type; if the type of the identifier of `D` contains the
 `auto` , the program is ill-formed. `T` is called the array *element
 type*; this type shall not be a reference type, the (possibly
 cv-qualified) type `void`, a function type or an abstract class type. If
+the *constant-expression* ([[expr.const]]) is present, it shall be a
+converted constant expression of type `std::size_t` and its value shall
+be greater than zero. The constant expression specifies the *bound* of
+(number of elements in) the array. If the value of the constant
+expression is `N`, the array has `N` elements numbered `0` to `N-1`, and
+the type of the identifier of `D` is “ array of `N` `T`”. An object of
+array type contains a contiguously allocated non-empty set of `N`
+subobjects of type `T`. Except as noted below, if the constant
+expression is omitted, the type of the identifier of `D` is “ array of
+unknown bound of `T`”, an incomplete object type. The type “ array of
+`N` `T`” is a different type from the type “ array of unknown bound of
+`T`”, see  [[basic.types]]. Any type of the form “ array of `N` `T`” is
+adjusted to “array of `N` `T`”, and similarly for “array of unknown
+bound of `T`”. The optional *attribute-specifier-seq* appertains to the
+array.
 ``` cpp
 typedef int A[5], AA[2][3];
 typedef const A CA;             // type is ``array of 5 const int''
 typedef const AA CAA;           // type is ``array of 2 array of 3 const int''
 “*derived-declarator-type-list* function of
 (*parameter-declaration-clause*) *cv-qualifier-seq*
 *ref-qualifier*returning *trailing-return-type*”. The optional
 *attribute-specifier-seq* appertains to the function type.
+A type of either form is a *function type*.[^9]
 ``` bnf
 parameter-declaration-clause:
     parameter-declaration-listₒₚₜ ...ₒₚₜ
     parameter-declaration-list ',' ...
 The *parameter-declaration-clause* determines the arguments that can be
 specified, and their processing, when the function is called. the
 *parameter-declaration-clause* is used to convert the arguments
 specified on the function call; see  [[expr.call]]. If the
 *parameter-declaration-clause* is empty, the function takes no
+arguments. A parameter list consisting of a single unnamed parameter of
+non-dependent type `void` is equivalent to an empty parameter list.
+Except for this special case, a parameter shall not have type *cv*
+`void`. If the *parameter-declaration-clause* terminates with an
+ellipsis or a function parameter pack ([[temp.variadic]]), the number
+of arguments shall be equal to or greater than the number of parameters
+that do not have a default argument and are not function parameter
+packs. Where syntactically correct and where “” is not part of an
 *abstract-declarator*, “” is synonymous with “”. the declaration
 ``` cpp
 int printf(const char*, ...);
 ```
 function’s *parameter-type-list*. This transformation does not affect
 the types of the parameters. For example,
 `int(*)(const int p, decltype(p)*)` and `int(*)(int, const int*)` are
 identical types.
+A function type with a *cv-qualifier-seq* or a *ref-qualifier*
+(including a type named by *typedef-name* ([[dcl.typedef]],
+[[temp.param]])) shall appear only as:
 - the function type for a non-static member function,
 - the function type to which a pointer to member refers,
 - the top-level function type of a function typedef declaration or
   *alias-declaration*,
 - the *type-id* in the default argument of a *type-parameter* (
   [[temp.param]]), or
 - the *type-id* of a *template-argument* for a *type-parameter* (
+  [[temp.arg.type]]).
+``` cpp
+typedef int FIC(int) const;
+FIC f;              // ill-formed: does not declare a member function
+struct S {
+  FIC f;            // OK
+};
+FIC S::*pm = &S::f; // OK
+```
 The effect of a *cv-qualifier-seq* in a function declarator is not the
 same as adding cv-qualification on top of the function type. In the
 latter case, the cv-qualifiers are ignored. a function type that has a
 *cv-qualifier-seq* is not a cv-qualified type; there are no cv-qualified
 declares a function taking three arguments of the specified types, and
 returning `int` ([[dcl.type]]).
 If the type of a parameter includes a type of the form “pointer to array
 of unknown bound of `T`” or “reference to array of unknown bound of
+`T`,” the program is ill-formed.[^10] Functions shall not have a return
 type of type array or function, although they may have a return type of
 type pointer or reference to such things. There shall be no arrays of
 functions, although there can be arrays of pointers to functions.
 Types shall not be defined in return or parameter types. The type of a
 parameter or the return type for a function definition shall not be an
+incomplete class type (possibly cv-qualified) unless the function is
+deleted ([[dcl.fct.def.delete]]) or the definition is nested within the
+*member-specification* for that class (including definitions in nested
+classes defined within the class).
 A typedef of function type may be used to declare a function but shall
 not be used to define a function ([[dcl.fct.def]]).
 ``` cpp
 F  fv;              // OK: equivalent to void fv();
 F  fv { }           // ill-formed
 void fv() { }       // OK: definition of fv
 ```
 An identifier can optionally be provided as a parameter name; if present
+in a function definition ([[dcl.fct.def]]), it names a parameter. In
+particular, parameter names are also optional in function definitions
+and names used for a parameter in different declarations and the
+definition of a function need not be the same. If a parameter name is
+present in a function declaration that is not a definition, it cannot be
+used outside of its function declarator because that is the extent of
+its potential scope ([[basic.scope.proto]]).
 the declaration
 ``` cpp
 int i,
 ```
 or
 ``` cpp
+auto fpif(int)->int(*)(int);
 ```
 A *trailing-return-type* is most useful for a type that would be more
 complicated to specify before the *declarator-id*:
 ``` cpp
 template <class T, class U> decltype((*(T*)0) + (*(U*)0)) add(T t, U u);
 ```
+A *non-template function* is a function that is not a function template
+specialization. A function template is not a function.
 A *declarator-id* or *abstract-declarator* containing an ellipsis shall
 only be used in a *parameter-declaration*. Such a
 *parameter-declaration* is a parameter pack ([[temp.variadic]]). When
 it is part of a *parameter-declaration-clause*, the parameter pack is a
 function parameter pack ([[temp.variadic]]). Otherwise, the
 ```
 There is a syntactic ambiguity when an ellipsis occurs at the end of a
 *parameter-declaration-clause* without a preceding comma. In this case,
 the ellipsis is parsed as part of the *abstract-declarator* if the type
+of the parameter either names a template parameter pack that has not
+been expanded or contains `auto`; otherwise, it is parsed as part of the
+*parameter-declaration-clause*.[^11]
 ### Default arguments <a id="dcl.fct.default">[[dcl.fct.default]]</a>
 If an *initializer-clause* is specified in a *parameter-declaration*
 this *initializer-clause* is used as a default argument. Default
 *parameter-declaration-clause* of a function declaration or in a
 *template-parameter* ([[temp.param]]); in the latter case, the
 *initializer-clause* shall be an *assignment-expression*. A default
 argument shall not be specified for a parameter pack. If it is specified
 in a *parameter-declaration-clause*, it shall not occur within a
+*declarator* or *abstract-declarator* of a *parameter-declaration*.[^12]
 For non-template functions, default arguments can be added in later
 declarations of a function in the same scope. Declarations in different
 scopes have completely distinct sets of default arguments. That is,
 declarations in inner scopes do not acquire default arguments from
 units shall be the same; see  [[basic.def.odr]]. If a friend declaration
 specifies a default argument expression, that declaration shall be a
 definition and shall be the only declaration of the function or function
 template in the translation unit.
+The default argument has the same semantic constraints as the
+initializer in a declaration of a variable of the parameter type, using
+the copy-initialization semantics ([[dcl.init]]). The names in the
+default argument are bound, and the semantic constraints are checked, at
+the point where the default argument appears. Name lookup and checking
+of semantic constraints for default arguments in function templates and
+in member functions of class templates are performed as described in
+[[temp.inst]]. in the following code, `g` will be called with the value
+`f(2)`:
 ``` cpp
 int a = 1;
 int f(int);
 int g(int x = f(a));            // default argument: f(::a)
 names in default arguments as described in Clause  [[class.access]].
 Except for member functions of class templates, the default arguments in
 a member function definition that appears outside of the class
 definition are added to the set of default arguments provided by the
+member function declaration in the class definition; the program is
+ill-formed if a default constructor ([[class.ctor]]), copy or move
+constructor, or copy or move assignment operator ([[class.copy]]) is so
+declared. Default arguments for a member function of a class template
+shall be specified on the initial declaration of the member function
+within the class template.
 ``` cpp
 class C {
   void f(int i = 3);
   void g(int i, int j = 99);
 class A {
   void f(A* p = this) { }       // error
 };
 ```
+A default argument is evaluated each time the function is called with no
+argument for the corresponding parameter. The order of evaluation of
+function arguments is unspecified. Consequently, parameters of a
+function shall not be used in a default argument, even if they are not
+evaluated. Parameters of a function declared before a default argument
+are in scope and can hide namespace and class member names.
 ``` cpp
 int a;
 int f(int a, int b = a);            // error: parameter a
                                     // used as default argument
 }
 ```
 In the *function-body*, a *function-local predefined variable* denotes a
 block-scope object of static storage duration that is implicitly defined
+(see  [[basic.scope.block]]).
 The function-local predefined variable `__func__` is defined as if a
 definition of the form
 ``` cpp
 static const char __func__[] = "function-name";
 ```
 had been provided, where *function-name* is an *implementation-defined*
 string. It is unspecified whether such a variable has an address
+distinct from that of any other object in the program.[^13]
 ``` cpp
 struct S {
   S() : s(__func__) { }             // OK
   const char* s;
 ### Explicitly-defaulted functions <a id="dcl.fct.def.default">[[dcl.fct.def.default]]</a>
 A function definition of the form:
 ``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = default ;'
 ```
 is called an *explicitly-defaulted* definition. A function that is
 explicitly defaulted shall
   non-const `T`”, where `T` is the name of the member function’s class)
   as if it had been implicitly declared, and
 - not have default arguments.
 An explicitly-defaulted function may be declared `constexpr` only if it
+would have been implicitly declared as `constexpr`. If a function is
+explicitly defaulted on its first declaration,
 - it is implicitly considered to be `constexpr` if the implicit
+  declaration would be, and,
 - it is implicitly considered to have the same *exception-specification*
+  as if it had been implicitly declared ([[except.spec]]).
+If a function that is explicitly defaulted has an explicit
+*exception-specification* that is not compatible ([[except.spec]]) with
+the *exception-specification* on the implicit declaration, then
+- if the function is explicitly defaulted on its first declaration, it
+  is defined as deleted;
+- otherwise, the program is ill-formed.
 ``` cpp
 struct S {
   constexpr S() = default;                  // ill-formed: implicit S() is not constexpr
   S(int a = 0) = default;                   // ill-formed: default argument
   void operator=(const S&) = default;       // ill-formed: non-matching return type
+  ~S() throw(int) = default;                // deleted: exception specification does not match
 private:
   int i;
   S(S&);                                    // OK: private copy constructor
 };
 S::S(S&) = default;                         // OK: defines copy constructor
 ```
 Explicitly-defaulted functions and implicitly-declared functions are
 collectively called *defaulted* functions, and the implementation shall
 provide implicit definitions for them ([[class.ctor]] [[class.dtor]],
+[[class.copy]]), which might mean defining them as deleted. A function
+is *user-provided* if it is user-declared and not explicitly defaulted
+or deleted on its first declaration. A user-provided
+explicitly-defaulted function (i.e., explicitly defaulted after its
+first declaration) is defined at the point where it is explicitly
+defaulted; if such a function is implicitly defined as deleted, the
+program is ill-formed. Declaring a function as defaulted after its first
+declaration can provide efficient execution and concise definition while
+enabling a stable binary interface to an evolving code base.
 ``` cpp
 struct trivial {
   trivial() = default;
   trivial(const trivial&) = default;
 ### Deleted definitions <a id="dcl.fct.def.delete">[[dcl.fct.def.delete]]</a>
 A function definition of the form:
 ``` bnf
+attribute-specifier-seqₒₚₜ decl-specifier-seqₒₚₜ declarator virt-specifier-seqₒₚₜ ' = delete ;'
 ```
 is called a *deleted definition*. A function with a deleted definition
 is also called a *deleted function*.
 Default arguments are more restricted; see  [[dcl.fct.default]].
 The order of initialization of variables with static storage duration is
 described in  [[basic.start]] and  [[stmt.dcl]].
+A declaration of a block-scope variable with external or internal
+linkage that has an *initializer* is ill-formed.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is a scalar type ([[basic.types]]), the object is initialized
+ to the value obtained by converting the integer literal `0` (zero) to
+  `T`;[^14]
 - if `T` is a (possibly cv-qualified) non-union class type, each
   non-static data member and each base-class subobject is
   zero-initialized and padding is initialized to zero bits;
 - if `T` is a (possibly cv-qualified) union type, the object’s first
   non-static named data member is zero-initialized and padding is
 - if `T` is a reference type, no initialization is performed.
 To *default-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]]),
+  the default constructor ([[class.ctor]]) for `T` is called (and the
+ initialization is ill-formed if `T` has no default constructor or
+  overload resolution ([[over.match]]) results in an ambiguity or in a
+  function that is deleted or inaccessible from the context of the
+  initialization);
 - if `T` is an array type, each element is default-initialized;
 - otherwise, no initialization is performed.
 If a program calls for the default initialization of an object of a
 const-qualified type `T`, `T` shall be a class type with a user-provided
 default constructor.
 To *value-initialize* an object of type `T` means:
 - if `T` is a (possibly cv-qualified) class type (Clause  [[class]])
+  with either no default constructor ([[class.ctor]]) or a default
+  constructor that is user-provided or deleted, then the object is
+  default-initialized;
+- if `T` is a (possibly cv-qualified) class type without a user-provided
+ or deleted default constructor, then the object is zero-initialized
+ and the semantic constraints for default-initialization are checked,
+ and if `T` has a non-trivial default constructor, the object is
+  default-initialized;
 - if `T` is an array type, then each element is value-initialized;
 - otherwise, the object is zero-initialized.
 An object that is value-initialized is deemed to be constructed and thus
 subject to provisions of this International Standard applying to
 a function taking no argument and returning an `X`. The form `()` is
 permitted in certain other initialization contexts ([[expr.new]],
 [[expr.type.conv]], [[class.base.init]]).
 If no initializer is specified for an object, the object is
+default-initialized. When storage for an object with automatic or
+dynamic storage duration is obtained, the object has an *indeterminate
+value*, and if no initialization is performed for the object, that
+object retains an indeterminate value until that value is replaced (
+[[expr.ass]]). Objects with static or thread storage duration are
+zero-initialized, see  [[basic.start.init]]. If an indeterminate value
+is produced by an evaluation, the behavior is undefined except in the
+following cases:
+- If an indeterminate value of unsigned narrow character type (
+  [[basic.fundamental]]) is produced by the evaluation of:
+  - the second or third operand of a conditional expression (
+    [[expr.cond]]),
+  - the right operand of a comma expression ([[expr.comma]]),
+  - the operand of a cast or conversion to an unsigned narrow character
+    type ([[conv.integral]], [[expr.type.conv]], [[expr.static.cast]],
+    [[expr.cast]]), or
+  - a discarded-value expression (Clause  [[expr]]),
+  then the result of the operation is an indeterminate value.
+- If an indeterminate value of unsigned narrow character type is
+  produced by the evaluation of the right operand of a simple assignment
+  operator ([[expr.ass]]) whose first operand is an lvalue of unsigned
+  narrow character type, an indeterminate value replaces the value of
+  the object referred to by the left operand.
+- If an indeterminate value of unsigned narrow character type is
+  produced by the evaluation of the initialization expression when
+  initializing an object of unsigned narrow character type, that object
+  is initialized to an indeterminate value.
+``` cpp
+int f(bool b) {
+    unsigned char c;
+    unsigned char d = c; // OK, d has an indeterminate value
+    int e = d;           // undefined behavior
+    return b ? d : 0;    // undefined behavior if b is true
+  }
+```
 An initializer for a static member is in the scope of the member’s
 class.
 ``` cpp
 [[temp.variadic]]).
 ### Aggregates <a id="dcl.init.aggr">[[dcl.init.aggr]]</a>
 An *aggregate* is an array or a class (Clause  [[class]]) with no
+user-provided constructors ([[class.ctor]]), no private or protected
+non-static data members (Clause  [[class.access]]), no base classes
+(Clause  [[class.derived]]), and no virtual functions (
+[[class.virtual]]).
 When an aggregate is initialized by an initializer list, as specified
 in  [[dcl.init.list]], the elements of the initializer list are taken as
 initializers for the members of the aggregate, in increasing subscript
 or member order. Each member is copy-initialized from the corresponding
 ```
 declares and initializes `x` as a one-dimensional array that has three
 elements since no size was specified and there are three initializers.
 An empty initializer list `{}` shall not be used as the
+*initializer-clause * for an array of unknown bound.[^15]
 Static data members and anonymous bit-fields are not considered members
 of the class for purposes of aggregate initialization.
 ``` cpp
 is ill-formed.
 If there are fewer *initializer-clause*s in the list than there are
 members in the aggregate, then each member not explicitly initialized
+shall be initialized from its *brace-or-equal-initializer* or, if there
+is no *brace-or-equal-initializer*, from an empty initializer list (
 [[dcl.init.list]]).
 ``` cpp
+struct S { int a; const char* b; int c; int d = b[a]; };
 S ss = { 1, "asdf" };
 ```
+initializes `ss.a` with 1, `ss.b` with `"asdf"`, `ss.c` with the value
+of an expression of the form `int{}` (that is, `0`), and `ss.d` with the
+value of `ss.b[ss.a]` (that is, `'s'`), and in
+``` cpp
+struct X { int i, j, k = 42; };
+X a[] = { 1, 2, 3, 4, 5, 6 };
+X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
+```
+`a` and `b` have the same value
 If an aggregate class `C` contains a subaggregate member `m` that has no
 members for purposes of aggregate initialization, the
 *initializer-clause* for `m` shall not be omitted from an
 *initializer-list* for an object of type `C` unless the
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
+Braces can be elided in an *initializer-list* as follows. If the
 *initializer-list* begins with a left brace, then the succeeding
 comma-separated list of *initializer-clause*s initializes the members of
 a subaggregate; it is erroneous for there to be more
 *initializer-clause*s than members. If, however, the *initializer-list*
 for a subaggregate does not begin with a left brace, then only enough
 union member can be omitted if the union is a member of another
 aggregate.
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
+An array of narrow character type ([[basic.fundamental]]), `char16_t`
+array, `char32_t` array, or `wchar_t` array can be initialized by a
+narrow string literal, `char16_t` string literal, `char32_t` string
+literal, or wide string literal, respectively, or by an
+appropriately-typed string literal enclosed in braces ([[lex.string]]).
+Successive characters of the value of the string literal initialize the
+elements of the array.
 ``` cpp
 char msg[] = "Syntax error on line %s\n";
 ```
 ```
 Given types “ `T1`” and “ `T2`,” “ `T1`” is to “ `T2`” if `T1` is the
 same type as `T2`, or `T1` is a base class of `T2`. “ `T1`” is with “
 `T2`” if `T1` is reference-related to `T2` and *cv1* is the same
+cv-qualification as, or greater cv-qualification than, *cv2*. In all
+cases where the reference-related or reference-compatible relationship
+of two types is used to establish the validity of a reference binding,
+and `T1` is a base class of `T2`, a program that necessitates such a
+binding is ill-formed if `T1` is an inaccessible (Clause
+[[class.access]]) or ambiguous ([[class.member.lookup]]) base class of
+`T2`.
 A reference to type “*cv1* `T1`” is initialized by an expression of type
 “*cv2* `T2`” as follows:
 - If the reference is an lvalue reference and the initializer expression
   - is an lvalue (but is not a bit-field), and “ `T1`” is
     reference-compatible with “ `T2`,” or
   - has a class type (i.e., `T2` is a class type), where `T1` is not
+    reference-related to `T2`, and can be converted to an lvalue of type
+    “ `T3`,” where “ `T1`” is reference-compatible with “ `T3`”[^16]
+    (this conversion is selected by enumerating the applicable
+    conversion functions ([[over.match.ref]]) and choosing the best one
+    through overload resolution ([[over.match]])),
   then the reference is bound to the initializer expression lvalue in
   the first case and to the lvalue result of the conversion in the
   second case (or, in either case, to the appropriate base class
   subobject of the object). The usual lvalue-to-rvalue ([[conv.lval]]),
   int  i = 2;
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   - If the initializer expression
+    - is an xvalue (but not a bit-field), class prvalue, array prvalue
+ or function lvalue and “*cv1* `T1`” is reference-compatible with
+      “*cv2* `T2`”, or
     - has a class type (i.e., `T2` is a class type), where `T1` is not
+      reference-related to `T2`, and can be converted to an xvalue,
+      class prvalue, or function lvalue of type “*cv3* `T3`”, where
+      “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
+      [[over.match.ref]]),
     then the reference is bound to the value of the initializer
     expression in the first case and to the result of the conversion in
     the second case (or, in either case, to an appropriate base class
     subobject). In the second case, if the reference is an rvalue
     int&& rri = static_cast<int&&>(i2); // bound directly to i2
     B&& rrb = x;                        // bound directly to the result of operator B
     int&& rri2 = X();                   // error: lvalue-to-rvalue conversion applied to the
                                         // result of operator int&
     ```
+  - Otherwise:
+ - If `T1` is a class type, user-defined conversions are considered
+      using the rules for copy-initialization of an object of type “
+ `T1`” by user-defined conversion ([[dcl.init]],
+      [[over.match.copy]]); the program is ill-formed if the
+      corresponding non-reference copy-initialization would be
+      ill-formed. The result of the call to the conversion function, as
+      described for the non-reference copy-initialization, is then used
+      to direct-initialize the reference. The program is ill-formed if
+      the direct-initialization does not result in a direct binding or
+      if it involves a user-defined conversion.
+    - If `T1` is a non-class type, a temporary of type “ `T1`” is
+      created and copy-initialized ([[dcl.init]]) from the initializer
+      expression. The reference is then bound to the temporary.
+    If `T1` is reference-related to `T2`:
+    - *cv1* shall be the same cv-qualification as, or greater
+      cv-qualification than, *cv2*; and
+    - if the reference is an rvalue reference, the initializer
+      expression shall not be an lvalue.
     ``` cpp
+    struct Banana { };
+    struct Enigma { operator const Banana(); };
+    void enigmatic() {
+      typedef const Banana ConstBanana;
+      Banana &&banana1 = ConstBanana(); // ill-formed
+      Banana &&banana2 = Enigma();      // ill-formed
+    }
     const double& rcd2 = 2;         // rcd2 refers to temporary with value 2.0
     double&& rrd = 2;               // rrd refers to temporary with value 2.0
     const volatile int cvi = 1;
     const int& r2 = cvi;            // error: type qualifiers dropped
     double d2 = 1.0;
 *copy-list-initialization*. List-initialization can be used
 - as the initializer in a variable definition ([[dcl.init]])
 - as the initializer in a new expression ([[expr.new]])
 - in a return statement ([[stmt.return]])
+- as a *for-range-initializer* ([[stmt.iter]])
 - as a function argument ([[expr.call]])
 - as a subscript ([[expr.sub]])
 - as an argument to a constructor invocation ([[dcl.init]],
   [[expr.type.conv]])
 - as an initializer for a non-static data member ([[class.mem]])
 parameter is of type `std::initializer_list<E>` or reference to possibly
 cv-qualified `std::initializer_list<E>` for some type `E`, and either
 there are no other parameters or else all other parameters have default
 arguments ([[dcl.fct.default]]). Initializer-list constructors are
 favored over other constructors in list-initialization (
+[[over.match.list]]). Passing an initializer list as the argument to the
+constructor template `template<class T> C(T)` of a class `C` does not
+create an initializer-list constructor, because an initializer list
+argument causes the corresponding parameter to be a non-deduced
+context ([[temp.deduct.call]]). The template `std::initializer_list` is
+not predefined; if the header `<initializer_list>` is not included prior
+to a use of `std::initializer_list` — even an implicit use in which the
 type is not named ([[dcl.spec.auto]]) — the program is ill-formed.
 List-initialization of an object or reference of type `T` is defined as
 follows:
+- If `T` is an aggregate, aggregate initialization is performed (
+ [[dcl.init.aggr]]).
   ``` cpp
   double ad[] = { 1, 2.0 };           // OK
   int ai[] = { 1, 2.0 };              // error: narrowing
   struct S2 {
   };
   S2 s21 = { 1, 2, 3.0 };             // OK
   S2 s22 { 1.0, 2, 3 };               // error: narrowing
   S2 s23 { };                         // OK: default to 0,0,0
   ```
+- Otherwise, if the initializer list has no elements and `T` is a class
+ type with a default constructor, the object is value-initialized.
+- Otherwise, if `T` is a specialization of `std::initializer_list<E>`, a
+  prvalue `initializer_list` object is constructed as described below
+  and used to initialize the object according to the rules for
   initialization of an object from a class of the same type (
   [[dcl.init]]).
 - Otherwise, if `T` is a class type, constructors are considered. The
   applicable constructors are enumerated and the best one is chosen
   through overload resolution ([[over.match]],  [[over.match.list]]).
   };
   S s1 = { 1, 2, 3.0 };               // OK: invoke #1
   S s2 { 1.0, 2, 3 };                 // error: narrowing
   S s3 { };                           // OK: invoke #2
   ```
+- Otherwise, if the initializer list has a single element of type `E`
+  and either `T` is not a reference type or its referenced type is
+  reference-related to `E`, the object or reference is initialized from
+  that element; if a narrowing conversion (see below) is required to
+  convert the element to `T`, the program is ill-formed.
+  ``` cpp
+  int x1 {2};                         // OK
+  int x2 {2.0};                       // error: narrowing
+  ```
 - Otherwise, if `T` is a reference type, a prvalue temporary of the type
+  referenced by `T` is copy-list-initialized or direct-list-initialized,
+ depending on the kind of initialization for the reference, and the
+ reference is bound to that temporary. As usual, the binding will fail
+ and the program is ill-formed if the reference type is an lvalue
+  reference to a non-const type.
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(const std::string&);            // #2
     // ...
   S& r3 = { 1, 2, 3 };                // error: initializer is not an lvalue
   const int& i1 = { 1 };              // OK
   const int& i2 = { 1.1 };            // error: narrowing
   const int (&iar)[2] = { 1, 2 };     // OK: iar is bound to temporary array
   ```
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
   ``` cpp
   int** pp {};                        // initialized to null pointer
   ```
 example, it applies when the elements of the *initializer-list* are
 interpreted as arguments of a constructor call, even though ordinarily
 there are no sequencing constraints on the arguments of a call.
 An object of type `std::initializer_list<E>` is constructed from an
+initializer list as if the implementation allocated a temporary array of
+N elements of type `const E`, where N is the number of elements in the
 initializer list. Each element of that array is copy-initialized with
 the corresponding element of the initializer list, and the
 `std::initializer_list<E>` object is constructed to refer to that array.
+A constructor or conversion function selected for the copy shall be
+accessible (Clause  [[class.access]]) in the context of the initializer
+list. If a narrowing conversion is required to initialize any of the
+elements, the program is ill-formed.
 ``` cpp
 struct X {
   X(std::initializer_list<double> v);
 };
 The initialization will be implemented in a way roughly equivalent to
 this:
 ``` cpp
+const double __a[3] = {double{1}, double{2}, double{3}};
 X x(std::initializer_list<double>(__a, __a+3));
 ```
 assuming that the implementation can construct an `initializer_list`
 object with a pair of pointers.
+The array has the same lifetime as any other temporary object (
+[[class.temporary]]), except that initializing an `initializer_list`
+object from the array extends the lifetime of the array exactly like
+binding a reference to a temporary.
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 void f() {
   std::vector<cmplx> v2{ 1, 2, 3 };
   std::initializer_list<int> i3 = { 1, 2, 3 };
 }
+struct A {
+  std::initializer_list<int> i4;
+  A() : i4{ 1, 2, 3 } {}  // creates an A with a dangling reference
+};
 ```
+For `v1` and `v2`, the `initializer_list` object is a parameter in a
+function call, so the array created for `{ 1, 2, 3 }` has
+full-expression lifetime. For `i3`, the `initializer_list` object is a
+variable, so the array persists for the lifetime of the variable. For
+`i4`, the `initializer_list` object is initialized in a constructor’s
+*ctor-initializer*, so the array persists only until the constructor
+exits, and so any use of the elements of `i4` after the constructor
+exits produces undefined behavior. The implementation is free to
+allocate the array in read-only memory if an explicit array with the
+same initializer could be so allocated.
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from `long double` to `double` or `float`, or from `double` to
   type, except where the source is a constant expression and the actual
   value after conversion will fit into the target type and will produce
   the original value when converted back to the original type, or
 - from an integer type or unscoped enumeration type to an integer type
   that cannot represent all the values of the original type, except
+  where the source is a constant expression whose value after integral
+ promotions will fit into the target type.
 As indicated above, such conversions are not allowed at the top level in
 list-initializations.
 ``` cpp
 [basic.lookup.udir]: basic.md#basic.lookup.udir
 [basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.lval]: basic.md#basic.lval
 [basic.namespace]: #basic.namespace
 [basic.scope]: basic.md#basic.scope
+[basic.scope.block]: basic.md#basic.scope.block
 [basic.scope.namespace]: basic.md#basic.scope.namespace
+[basic.scope.pdecl]: basic.md#basic.scope.pdecl
 [basic.scope.proto]: basic.md#basic.scope.proto
 [basic.start]: basic.md#basic.start
 [basic.start.init]: basic.md#basic.start.init
 [basic.stc]: basic.md#basic.stc
 [basic.stc.auto]: basic.md#basic.stc.auto
 [class.inhctor]: special.md#class.inhctor
 [class.init]: special.md#class.init
 [class.mem]: class.md#class.mem
 [class.member.lookup]: class.md#class.member.lookup
 [class.mfct]: class.md#class.mfct
 [class.name]: class.md#class.name
 [class.qual]: basic.md#class.qual
 [class.static]: class.md#class.static
 [class.static.data]: class.md#class.static.data
 [class.temporary]: special.md#class.temporary
 [class.union]: class.md#class.union
 [class.virtual]: class.md#class.virtual
 [conv]: conv.md#conv
 [conv.array]: conv.md#conv.array
 [conv.func]: conv.md#conv.func
+[conv.integral]: conv.md#conv.integral
 [conv.lval]: conv.md#conv.lval
 [conv.prom]: conv.md#conv.prom
 [conv.ptr]: conv.md#conv.ptr
 [dcl.align]: #dcl.align
 [dcl.ambig.res]: #dcl.ambig.res
 [dcl.array]: #dcl.array
 [dcl.asm]: #dcl.asm
 [dcl.attr]: #dcl.attr
 [dcl.attr.depend]: #dcl.attr.depend
+[dcl.attr.deprecated]: #dcl.attr.deprecated
 [dcl.attr.grammar]: #dcl.attr.grammar
 [dcl.attr.noreturn]: #dcl.attr.noreturn
 [dcl.constexpr]: #dcl.constexpr
 [dcl.dcl]: #dcl.dcl
 [dcl.decl]: #dcl.decl
 [except.throw]: except.md#except.throw
 [expr]: expr.md#expr
 [expr.alignof]: expr.md#expr.alignof
 [expr.ass]: expr.md#expr.ass
 [expr.call]: expr.md#expr.call
+[expr.cast]: expr.md#expr.cast
+[expr.comma]: expr.md#expr.comma
+[expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.const.cast]: expr.md#expr.const.cast
 [expr.mptr.oper]: expr.md#expr.mptr.oper
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.ref]: expr.md#expr.ref
 [expr.static.cast]: expr.md#expr.static.cast
 [expr.sub]: expr.md#expr.sub
 [expr.type.conv]: expr.md#expr.type.conv
 [expr.unary]: expr.md#expr.unary
 [intro.multithread]: intro.md#intro.multithread
 [lex.charset]: lex.md#lex.charset
 [lex.digraph]: lex.md#lex.digraph
 [lex.key]: lex.md#lex.key
 [lex.name]: lex.md#lex.name
+[lex.string]: lex.md#lex.string
 [namespace.alias]: #namespace.alias
 [namespace.def]: #namespace.def
 [namespace.memdef]: #namespace.memdef
 [namespace.qual]: basic.md#namespace.qual
 [namespace.udecl]: #namespace.udecl
 [namespace.udir]: #namespace.udir
 [namespace.unnamed]: #namespace.unnamed
 [over]: over.md#over
 [over.match]: over.md#over.match
 [over.match.conv]: over.md#over.match.conv
 [over.match.copy]: over.md#over.match.copy
 [over.match.ctor]: over.md#over.match.ctor
 [over.match.list]: over.md#over.match.list
 [stmt.select]: stmt.md#stmt.select
 [stmt.stmt]: stmt.md#stmt.stmt
 [support.runtime]: language.md#support.runtime
 [tab:simple.type.specifiers]: #tab:simple.type.specifiers
 [temp]: temp.md#temp
 [temp.arg.type]: temp.md#temp.arg.type
 [temp.class.spec]: temp.md#temp.class.spec
 [temp.deduct.call]: temp.md#temp.deduct.call
 [temp.dep]: temp.md#temp.dep
 [temp.expl.spec]: temp.md#temp.expl.spec
 [^1]: The “implicit int” rule of C is no longer supported.
 [^2]: The inline keyword has no effect on the linkage of a function.
+[^3]: There is no special provision for a *decl-specifier-seq* that
     lacks a *type-specifier* or that has a *type-specifier* that only
     specifies *cv-qualifier*s. The “implicit int” rule of C is no longer
     supported.
+[^4]: This set of values is used to define promotion and conversion
     semantics for the enumeration type. It does not preclude an
     expression of enumeration type from having a value that falls
     outside this range.
+[^5]: Although entities in an unnamed namespace might have external
     linkage, they are effectively qualified by a name unique to their
     translation unit and therefore can never be seen from any other
     translation unit.
+[^6]: this implies that the name of the class or function is
     unqualified.
+[^7]: During name lookup in a class hierarchy, some ambiguities may be
     resolved by considering whether one member hides the other along
     some paths ([[class.member.lookup]]). There is no such
     disambiguation when considering the set of names found as a result
     of following *using-directive*s.
+[^8]: A declaration with several declarators is usually equivalent to
     the corresponding sequence of declarations each with a single
     declarator. That is
     `T  D1, D2, ... Dn;`
     `auto i = 1, j = 2.0; \textrm{// error: deduced types for \tcode{i} and \tcode{j} do not match}`
     as opposed to
     `auto i = 1;    \textrm{// OK: \tcode{i} deduced to have type \tcode{int}}`
     `auto j = 2.0;  \textrm{// OK: \tcode{j} deduced to have type \tcode{double}}`
+[^9]: As indicated by syntax, cv-qualifiers are a significant component
     in function return types.
+[^10]: This excludes parameters of type “ `T2`” where `T2` is “pointer
     to array of unknown bound of `T`” and where means any sequence of
     “pointer to” and “array of” derived declarator types. This exclusion
     applies to the parameters of the function, and if a parameter is a
     pointer to function or pointer to member function then to its
     parameters also, etc.
+[^11]: One can explicitly disambiguate the parse either by introducing a
     comma (so the ellipsis will be parsed as part of the
     *parameter-declaration-clause*) or by introducing a name for the
     parameter (so the ellipsis will be parsed as part of the
     *declarator-id*).
+[^12]: This means that default arguments cannot appear, for example, in
     declarations of pointers to functions, references to functions, or
     `typedef` declarations.
+[^13]: Implementations are permitted to provide additional predefined
     variables with names that are reserved to the implementation (
     [[global.names]]). If a predefined variable is not odr-used (
     [[basic.def.odr]]), its string value need not be present in the
     program image.
+[^14]: As specified in  [[conv.ptr]], converting an integer literal
+    whose value is `0` to a pointer type results in a null pointer
+    value.
+[^15]: The syntax provides for empty *initializer-list*s, but
     nonetheless C++does not have zero length arrays.
+[^16]: This requires a conversion function ([[class.conv.fct]])
     returning a reference type.

Diff to HTML by rtfpessoa