[dcl.init] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpr2az0aq1/{from.md → to.md} +319 -234

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

@@ -92,11 +92,13 @@ duration is described in  [[basic.start]] and
 A declaration D of a variable with linkage shall not have an
 *initializer* if D inhabits a block scope.
 To *zero-initialize* an object or reference of type `T` means:
-- if `T` is a scalar type [[term.scalar.type]], the object is
   initialized to the value obtained by converting the integer literal
   `0` (zero) to `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
   bits [[term.padding.bits]] are initialized to zero bits and each
   non-static data member, each non-virtual base class subobject, and, if
@@ -114,11 +116,14 @@ To *default-initialize* an object of type `T` means:
   are considered. The applicable constructors are enumerated
   [[over.match.ctor]], and the best one for the *initializer* `()` is
   chosen through overload resolution [[over.match]]. The constructor
   thus selected is called, with an empty argument list, to initialize
   the object.
-- If `T` is an array type, each element is default-initialized.
 - Otherwise, no initialization is performed.
 A class type `T` is *const-default-constructible* if
 default-initialization of `T` would invoke a user-provided constructor
 of `T` (not inherited from a base class) or if
@@ -133,37 +138,36 @@ of `T` (not inherited from a base class) or if
   member has a default member initializer, and
 - each potentially constructed base class of `T` is
   const-default-constructible.
 If a program calls for the default-initialization of an object of a
-const-qualified type `T`, `T` shall be a const-default-constructible
-class type or array thereof.
 To *value-initialize* an object of type `T` means:
-- if `T` is a (possibly cv-qualified) class type [[class]], then
- - if `T` has either no default constructor [[class.default.ctor]] or a
-    default constructor that is user-provided or deleted, then the
- object is default-initialized;
- - otherwise, 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.
 A program that calls for default-initialization or value-initialization
 of an entity of reference type is ill-formed.
-[*Note 4*: For every object of static storage duration, static
 initialization [[basic.start.static]] is performed at program startup
 before any other initialization takes place. In some cases, additional
 initialization is done later. — *end note*]
 If no initializer is specified for an object, the object is
 default-initialized.
-If the entity being initialized does not have class type, the
 *expression-list* in a parenthesized initializer shall be a single
 expression.
 The initialization that occurs in the `=` form of a
 *brace-or-equal-initializer* or *condition* [[stmt.select]], as well as
@@ -185,14 +189,14 @@ The initialization that occurs
 - in the *braced-init-list* form of a *condition*
 is called *direct-initialization*.
 The semantics of initializers are as follows. The *destination type* is
-the type of the object or reference being initialized and the *source
-type* is the type of the initializer expression. If the initializer is
-not a single (possibly parenthesized) expression, the source type is not
-defined.
 - If the initializer is a (non-parenthesized) *braced-init-list* or is
   `=` *braced-init-list*, the object or reference is list-initialized
   [[dcl.init.list]].
 - If the destination type is a reference type, see  [[dcl.init.ref]].
@@ -207,35 +211,35 @@ defined.
   X a();
   ```
   is not the declaration of an object of class `X`, but the declaration
   of a function taking no arguments and returning an `X`. The form `()`
- is permitted in certain other initialization contexts
   [[expr.new]], [[expr.type.conv]], [[class.base.init]].
   — *end note*]
 - Otherwise, if the destination type is an array, the object is
-  initialized as follows. Let x₁, …, xₖ be the elements of the
   *expression-list*. If the destination type is an array of unknown
   bound, it is defined as having k elements. Let n denote the array size
   after this potential adjustment. If k is greater than n, the program
   is ill-formed. Otherwise, the iᵗʰ array element is copy-initialized
   with xᵢ for each 1 ≤ i ≤ k, and value-initialized for each k < i ≤ n.
   For each 1 ≤ i < j ≤ n, every value computation and side effect
   associated with the initialization of the iᵗʰ element of the array is
   sequenced before those associated with the initialization of the jᵗʰ
   element.
-- Otherwise, if the destination type is a (possibly cv-qualified) class
-  type:
   - If the initializer expression is a prvalue and the cv-unqualified
-    version of the source type is the same class as the class of the
- destination, the initializer expression is used to initialize the
- destination object. \[*Example 2*: `T x = T(T(T()));`
- value-initializes `x`. — *end example*]
   - Otherwise, if the initialization is direct-initialization, or if it
     is copy-initialization where the cv-unqualified version of the
-    source type is the same class as, or a derived class of, the class
- of the destination, constructors are considered. The applicable
     constructors are enumerated [[over.match.ctor]], and the best one is
     chosen through overload resolution [[over.match]]. Then:
     - If overload resolution is successful, the selected constructor is
       called to initialize the object, with the initializer expression
       or *expression-list* as its argument(s).
@@ -251,11 +255,11 @@ defined.
       value computation and side effect associated with the
       initialization of eᵢ is sequenced before those associated with the
       initialization of eⱼ.
       \[*Note 7*:
       By contrast with direct-list-initialization, narrowing conversions
-      [[dcl.init.list]] are permitted, designators are not permitted, a
       temporary object bound to a reference does not have its lifetime
       extended [[class.temporary]], and there is no brace elision.
       \[*Example 3*:
       ``` cpp
       struct A {
@@ -299,16 +303,16 @@ defined.
 - Otherwise, if the initialization is direct-initialization, the source
   type is `std::nullptr_t`, and the destination type is `bool`, the
   initial value of the object being initialized is `false`.
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. A standard
-  conversion sequence [[conv]] will be used, if necessary, to convert
- the initializer expression to the cv-unqualified version of the
- destination type; no user-defined conversions are considered. If the
- conversion cannot be done, the initialization is ill-formed. When
- initializing a bit-field with a value that it cannot represent, the
- resulting value of the bit-field is *implementation-defined*.
   \[*Note 8*:
   An expression of type “*cv1* `T`” can initialize an object of type
   “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
   ``` cpp
   int a;
@@ -371,11 +375,11 @@ An *aggregate* is an array or a class [[class]] with
 - no private or protected direct base classes [[class.access.base]], and
 - no virtual functions [[class.virtual]] or virtual base classes
   [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
-and private base class’ members or constructors. — *end note*]
 The *elements* of an aggregate are:
 - for an array, the array elements in increasing subscript order, or
 - for a class, the direct base classes in declaration order, followed by
@@ -391,13 +395,13 @@ initialized elements* of the aggregate are determined as follows:
   *designated-initializer-list*, the aggregate shall be of class type,
   the *identifier* in each *designator* shall name a direct non-static
   data member of the class, and the explicitly initialized elements of
   the aggregate are the elements that are, or contain, those members.
 - If the initializer list is a brace-enclosed *initializer-list*, the
-  explicitly initialized elements of the aggregate are the first n
- elements of the aggregate, where n is the number of elements in the
- initializer list.
 - Otherwise, the initializer list must be `{}`, and there are no
   explicitly initialized elements.
 For each explicitly initialized element:
@@ -417,21 +421,26 @@ For each explicitly initialized element:
   } c = { .a = 1, .x = 3 };
   ```
   initializes `c.a` with 1 and `c.x` with 3.
   — *end example*]
-- Otherwise, the element is copy-initialized from the corresponding
-  *initializer-clause* or is initialized with the
   *brace-or-equal-initializer* of the corresponding
   *designated-initializer-clause*. If that initializer is of the form
- *assignment-expression* or `= `*assignment-expression* and a narrowing
- conversion [[dcl.init.list]] is required to convert the expression,
- the program is ill-formed.
- \[*Note 2*: If the initialization is by
-  *designated-initializer-clause*, its form determines whether
-  copy-initialization or direct-initialization is
   performed. — *end note*]
   \[*Note 3*: If an initializer is itself an initializer list, the
   element is list-initialized, which will result in a recursive
   application of the rules in this subclause if the element is an
   aggregate. — *end note*]
   \[*Example 2*:
@@ -490,19 +499,11 @@ 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
 ``` cpp
 struct A {
   string a;
   int b = 42;
@@ -524,21 +525,21 @@ associated with a given element are sequenced before those of any
 element that follows it in order.
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
-The destructor for each element of class type is potentially invoked
-[[class.dtor]] from the context where the aggregate initialization
-occurs.
 [*Note 4*: This provision ensures that destructors can be called for
 fully-constructed subobjects in case an exception is thrown
 [[except.ctor]]. — *end note*]
-An array of unknown bound initialized with a brace-enclosed
-*initializer-list* containing `n` *initializer-clause*s is defined as
-having `n` elements [[dcl.array]].
 [*Example 4*:
 ``` cpp
 int x[] = { 1, 3, 5 };
@@ -547,10 +548,24 @@ 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.
 — *end example*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
 [*Note 5*:
@@ -558,11 +573,11 @@ A default member initializer does not determine the bound for a member
 array of unknown bound. Since the default member initializer is ignored
 if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
 unknown bound.
-[*Example 5*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
@@ -575,11 +590,11 @@ struct S {
 [*Note 6*:
 Static data members, non-static data members of anonymous union members,
 and unnamed bit-fields are not considered elements of the aggregate.
-[*Example 6*:
 ``` cpp
 struct A {
   int i;
   static int s;
@@ -595,23 +610,10 @@ unnamed bit-field before it.
 — *end example*]
 — *end note*]
-An *initializer-list* is ill-formed if the number of
-*initializer-clause*s exceeds the number of elements of the aggregate.
-[*Example 7*:
-``` cpp
-char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error
-```
-is ill-formed.
-— *end example*]
 If a member has a default member initializer and a potentially-evaluated
 subexpression thereof is an aggregate initialization that would use that
 default member initializer, the program is ill-formed.
 [*Example 8*:
@@ -630,42 +632,15 @@ struct B {
 };
 ```
 — *end example*]
-If an aggregate class `C` contains a subaggregate element `e` with no
-elements, the *initializer-clause* for `e` shall not be omitted from an
-*initializer-list* for an object of type `C` unless the
-*initializer-clause*s for all elements of `C` following `e` are also
-omitted.
-[*Example 9*:
-``` cpp
-struct S { } s;
-struct A {
-  S s1;
-  int i1;
-  S s2;
-  int i2;
-  S s3;
-  int i3;
-} a = {
-  { },              // Required initialization
-  0,
-  s,                // Required initialization
-  0
-};                  // Initialization not required for A::s3 because A::i3 is also not initialized
-```
-— *end example*]
 When initializing a multidimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest [[dcl.array]].
-[*Example 10*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
@@ -681,23 +656,77 @@ float y[4][3] = {
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 — *end example*]
-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 elements
-of a subaggregate; it is erroneous for there to be more
-*initializer-clause*s than elements. If, however, the *initializer-list*
-for a subaggregate does not begin with a left brace, then only enough
-*initializer-clause*s from the list are taken to initialize the elements
-of the subaggregate; any remaining *initializer-clause*s are left to
-initialize the next element of the aggregate of which the current
-subaggregate is an element.
 [*Example 11*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
   { 3, 5, 7 },
@@ -705,15 +734,15 @@ float y[4][3] = {
 ```
 is a completely-braced initialization: 1, 3, and 5 initialize the first
 row of the array `y[0]`, namely `y[0][0]`, `y[0][1]`, and `y[0][2]`.
 Likewise the next two lines initialize `y[1]` and `y[2]`. The
-initializer ends early and therefore `y[3]`s elements are initialized as
-if explicitly initialized with an expression of the form `float()`, that
-is, are initialized with `0.0`. In the following example, braces in the
-*initializer-list* are elided; however the *initializer-list* has the
-same effect as the completely-braced *initializer-list* of the above
 example,
 ``` cpp
 float y[4][3] = {
   1, 3, 5, 2, 4, 6, 3, 5, 7
@@ -724,22 +753,39 @@ The initializer for `y` begins with a left brace, but the one for `y[0]`
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 — *end example*]
-All implicit type conversions [[conv]] are considered when initializing
-the element with an *assignment-expression*. If the
-*assignment-expression* can initialize an element, the element is
-initialized. Otherwise, if the element is itself a subaggregate, brace
-elision is assumed and the *assignment-expression* is considered for the
-initialization of the first element of the subaggregate.
-[*Note 7*: As specified above, brace elision cannot apply to
-subaggregates with no elements; an *initializer-clause* for the entire
-subobject is required. — *end note*]
-[*Example 12*:
 ``` cpp
 struct A {
   int i;
   operator int();
@@ -756,23 +802,24 @@ Braces are elided around the *initializer-clause* for `b.a1.i`. `b.a1.i`
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
-[*Note 8*: An aggregate array or an aggregate class can contain
 elements of a class type with a user-declared constructor
 [[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
-[*Note 9*: Whether the initialization of aggregates with static storage
-duration is static or dynamic is specified in  [[basic.start.static]],
-[[basic.start.dynamic]], and  [[stmt.dcl]]. — *end note*]
 When a union is initialized with an initializer list, there shall not be
 more than one explicitly initialized element.
-[*Example 13*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
@@ -783,11 +830,11 @@ u f = { .b = "asdf" };
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
-[*Note 10*: 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. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
@@ -858,11 +905,11 @@ void f() {
 A reference cannot be changed to refer to another object after
 initialization.
 [*Note 1*: Assignment to a reference assigns to the object referred to
-by the reference [[expr.ass]]. — *end note*]
 Argument passing [[expr.call]] and function value return [[stmt.return]]
 are initializations.
 The initializer can be omitted for a reference only in a parameter
@@ -935,23 +982,25 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   — *end example*]
 - Otherwise, if the initializer expression
-  - is an rvalue (but not a bit-field) 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 rvalue or
- function lvalue of type “*cv3* `T3`”, where “*cv1* `T1`” is
-    reference-compatible with “*cv3* `T3`” (see  [[over.match.ref]]),
   then the initializer expression in the first case and the converted
   expression in the second case is called the converted initializer. If
-  the converted initializer is a prvalue, its type `T4` is adjusted to
- type “*cv1* `T4`” [[conv.qual]] and the temporary materialization
- conversion [[conv.rval]] is applied. In any case, the reference binds
- to the resulting glvalue (or to an appropriate base class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
@@ -963,37 +1012,40 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
   } x;
   const A& r = x;                     // binds to the A subobject of the result of the conversion
   int i2 = 42;
   int&& rri = static_cast<int&&>(i2); // binds directly to i2
   B&& rrb = x;                        // binds directly to the result of operator B
   ```
   — *end example*]
-- Otherwise:
-  - If `T1` or `T2` is a class type and `T1` is not reference-related to
- `T2`, user-defined conversions are considered using the rules for
- copy-initialization of an object of type “*cv1* `T1`” by
-    user-defined conversion
     [[dcl.init]], [[over.match.copy]], [[over.match.conv]]; 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. For this
-    direct-initialization, user-defined conversions are not considered.
   - Otherwise, the initializer expression is implicitly converted to a
     prvalue of type “`T1`”. The temporary materialization conversion is
     applied, considering the type of the prvalue to be “*cv1* `T1`”, and
     the reference is bound to the result.
-  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. \[*Note 3*: This can be affected by whether
-    the initializer expression is move-eligible
-    [[expr.prim.id.unqual]]. — *end note*]
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
   struct Alaska { operator Banana&(); };
@@ -1002,32 +1054,33 @@ A reference to type “*cv1* `T1`” is initialized by an expression of type
     Banana &&banana1 = ConstBanana(); // error
     Banana &&banana2 = Enigma();      // error
     Banana &&banana3 = Alaska();      // error
   }
-  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: cv-qualifier dropped
   struct A { operator volatile int&(); } a;
   const int& r3 = a;                  // error: cv-qualifier dropped
                                       // from result of conversion function
   double d2 = 1.0;
-  double&& rrd2 = d2;                 // error: initializer is lvalue of related type
   struct X { operator int&(); };
-  int&& rri2 = X();                   // error: result of conversion function is lvalue of related type
   int i3 = 2;
   double&& rrd3 = i3;                 // rrd3 refers to temporary with value 2.0
   ```
   — *end example*]
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
-[*Note 4*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
@@ -1037,27 +1090,29 @@ or *designated-initializer-clause*s of the *designated-initializer-list*
 are called the *elements* of the initializer list. An initializer list
 may be empty. List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
-*copy-list-initialization*.
 [*Note 1*:
 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]]
-- in a *mem-initializer* [[class.base.init]]
-- on the right-hand side of an assignment [[expr.ass]]
 [*Example 1*:
 ``` cpp
 int a = {1};
@@ -1092,29 +1147,29 @@ The template `std::initializer_list` is not predefined; if a standard
 library declaration [[initializer.list.syn]], [[std.modules]] of
 `std::initializer_list` is not reachable from [[module.reach]] 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 *braced-init-list* contains a *designated-initializer-list*,
-  `T` shall be an aggregate class. The ordered *identifier*s in the
-  *designator*s of the *designated-initializer-list* shall form a
- subsequence of the ordered *identifier*s in the direct non-static data
-  members of `T`. Aggregate initialization is performed
-  [[dcl.init.aggr]].
   \[*Example 2*:
   ``` cpp
   struct A { int x; int y; int z; };
   A a{.y = 2, .x = 1};                // error: designator order does not match declaration order
   A b{.x = 1, .z = 2};                // OK, b.y initialized to 0
   ```
   — *end example*]
 - If `T` is an aggregate class and the initializer list has a single
-  element of type *cv* `U`, where `U` is `T` or a class derived from
   `T`, the object is initialized from that element (by
   copy-initialization for copy-list-initialization, or by
   direct-initialization for direct-list-initialization).
 - Otherwise, if `T` is a character array and the initializer list has a
   single element that is an appropriately-typed *string-literal*
@@ -1137,28 +1192,30 @@ follows:
   ```
   — *end example*]
 - 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>`,
- the object is constructed as described below.
 - 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]]. If a
   narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
-    S(); // #3
     // ...
   };
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
-  S s3 = { }; // invoke #3
   ```
   — *end example*]
   \[*Example 5*:
   ``` cpp
@@ -1182,15 +1239,16 @@ follows:
   S s3 { };                           // OK, invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
-  [[dcl.enum]] `U`, the *initializer-list* has a single element `v`, `v`
-  can be implicitly converted to `U`, and the initialization is
-  direct-list-initialization, the object is initialized with the value
-  `T(v)` [[expr.type.conv]]; if a narrowing conversion is required to
-  convert `v` to `U`, the program is ill-formed.
   \[*Example 7*:
   ``` cpp
   enum byte : unsigned char { };
   byte b { 42 };                      // OK
   byte c = { 42 };                    // error
@@ -1207,12 +1265,13 @@ follows:
   enum class Handle : uint32_t { Invalid = 0 };
   Handle h { 42 };                    // OK
   ```
   — *end example*]
-- 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 (by copy-initialization for copy-list-initialization, or
   by direct-initialization for direct-list-initialization); if a
   narrowing conversion (see below) is required to convert the element to
   `T`, the program is ill-formed.
@@ -1248,10 +1307,13 @@ follows:
   const int (&iar)[2] = { 1, 2 };     // OK, iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
@@ -1299,49 +1361,75 @@ even though ordinarily there are no sequencing constraints on the
 arguments of a call. — *end note*]
 An object of type `std::initializer_list<E>` is constructed from an
 initializer list as if the implementation generated and materialized
 [[conv.rval]] a prvalue of type “array of N `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.
 [*Note 5*: A constructor or conversion function selected for the copy
-is required to be accessible [[class.access]] in the context of the
 initializer list. — *end note*]
 If a narrowing conversion is required to initialize any of the elements,
 the program is ill-formed.
-[*Example 12*:
-``` cpp
-struct X {
-  X(std::initializer_list<double> v);
-};
-X x{ 1,2,3 };
-```
-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.
-— *end example*]
-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.
 [*Example 13*:
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
@@ -1365,22 +1453,19 @@ variable, so the array persists for the lifetime of the variable. For
 *ctor-initializer* as if by binding a temporary array to a reference
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
-[*Note 6*: The implementation is free to allocate the array in
-read-only memory if an explicit array with the same initializer can be
-so allocated. — *end note*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from a floating-point type `T` to another floating-point type whose
   floating-point conversion rank is neither greater than nor equal to
-  that of `T`, except where the source is a constant expression and the
- actual value after conversion is within the range of values that can
- be represented (even if it cannot be represented exactly), or
 - from an integer type or unscoped enumeration type to a floating-point
   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

 A declaration D of a variable with linkage shall not have an
 *initializer* if D inhabits a block scope.
 To *zero-initialize* an object or reference of type `T` means:
+- if `T` is `std::meta::info`, the object is initialized to a null
+  reflection value;
+- if `T` is any other scalar type [[term.scalar.type]], the object is
   initialized to the value obtained by converting the integer literal
   `0` (zero) to `T`;[^5]
 - if `T` is a (possibly cv-qualified) non-union class type, its padding
   bits [[term.padding.bits]] are initialized to zero bits and each
   non-static data member, each non-virtual base class subobject, and, if
   are considered. The applicable constructors are enumerated
   [[over.match.ctor]], and the best one for the *initializer* `()` is
   chosen through overload resolution [[over.match]]. The constructor
   thus selected is called, with an empty argument list, to initialize
   the object.
+- If `T` is an array type, the semantic constraints of
+  default-initializing a hypothetical element shall be met and each
+  element is default-initialized.
+- If `T` is `std::meta::info`, the object is zero-initialized.
 - Otherwise, no initialization is performed.
 A class type `T` is *const-default-constructible* if
 default-initialization of `T` would invoke a user-provided constructor
 of `T` (not inherited from a base class) or if
   member has a default member initializer, and
 - each potentially constructed base class of `T` is
   const-default-constructible.
 If a program calls for the default-initialization of an object of a
+const-qualified type `T`, `T` shall be `std::meta::info` or a
+const-default-constructible class type, or array thereof.
 To *value-initialize* an object of type `T` means:
+- If `T` is a (possibly cv-qualified) class type [[class]], then let `C`
+ be the constructor selected to default-initialize the object, if any.
+  If `C` is not user-provided, the object is first zero-initialized. In
+  all cases, the object is then default-initialized.
+- If `T` is an array type, the semantic constraints of
+  value-initializing a hypothetical element shall be met and each
+  element is value-initialized.
+- Otherwise, the object is zero-initialized.
 A program that calls for default-initialization or value-initialization
 of an entity of reference type is ill-formed.
+[*Note 4*: For every object with static storage duration, static
 initialization [[basic.start.static]] is performed at program startup
 before any other initialization takes place. In some cases, additional
 initialization is done later. — *end note*]
 If no initializer is specified for an object, the object is
 default-initialized.
+If the entity being initialized does not have class or array type, the
 *expression-list* in a parenthesized initializer shall be a single
 expression.
 The initialization that occurs in the `=` form of a
 *brace-or-equal-initializer* or *condition* [[stmt.select]], as well as
 - in the *braced-init-list* form of a *condition*
 is called *direct-initialization*.
 The semantics of initializers are as follows. The *destination type* is
+the cv-unqualified type of the object or reference being initialized and
+the *source type* is the type of the initializer expression. If the
+initializer is not a single (possibly parenthesized) expression, the
+source type is not defined.
 - If the initializer is a (non-parenthesized) *braced-init-list* or is
   `=` *braced-init-list*, the object or reference is list-initialized
   [[dcl.init.list]].
 - If the destination type is a reference type, see  [[dcl.init.ref]].
   X a();
   ```
   is not the declaration of an object of class `X`, but the declaration
   of a function taking no arguments and returning an `X`. The form `()`
+ can appear in certain other initialization contexts
   [[expr.new]], [[expr.type.conv]], [[class.base.init]].
   — *end note*]
 - Otherwise, if the destination type is an array, the object is
+  initialized as follows. The *initializer* shall be of the form `(`
+  *expression-list* `)`. Let x₁, …, xₖ be the elements of the
   *expression-list*. If the destination type is an array of unknown
   bound, it is defined as having k elements. Let n denote the array size
   after this potential adjustment. If k is greater than n, the program
   is ill-formed. Otherwise, the iᵗʰ array element is copy-initialized
   with xᵢ for each 1 ≤ i ≤ k, and value-initialized for each k < i ≤ n.
   For each 1 ≤ i < j ≤ n, every value computation and side effect
   associated with the initialization of the iᵗʰ element of the array is
   sequenced before those associated with the initialization of the jᵗʰ
   element.
+- Otherwise, if the destination type is a class type:
   - If the initializer expression is a prvalue and the cv-unqualified
+    version of the source type is the same as the destination type, the
+    initializer expression is used to initialize the destination object.
+    \[*Example 2*: `T x = T(T(T()));` value-initializes `x`
+ [[basic.lval]], [[expr.type.conv]]. — *end example*]
   - Otherwise, if the initialization is direct-initialization, or if it
     is copy-initialization where the cv-unqualified version of the
+    source type is the same as or is derived from the class of the
+    destination type, constructors are considered. The applicable
     constructors are enumerated [[over.match.ctor]], and the best one is
     chosen through overload resolution [[over.match]]. Then:
     - If overload resolution is successful, the selected constructor is
       called to initialize the object, with the initializer expression
       or *expression-list* as its argument(s).
       value computation and side effect associated with the
       initialization of eᵢ is sequenced before those associated with the
       initialization of eⱼ.
       \[*Note 7*:
       By contrast with direct-list-initialization, narrowing conversions
+      [[dcl.init.list]] can appear, designators are not permitted, a
       temporary object bound to a reference does not have its lifetime
       extended [[class.temporary]], and there is no brace elision.
       \[*Example 3*:
       ``` cpp
       struct A {
 - Otherwise, if the initialization is direct-initialization, the source
   type is `std::nullptr_t`, and the destination type is `bool`, the
   initial value of the object being initialized is `false`.
 - Otherwise, the initial value of the object being initialized is the
   (possibly converted) value of the initializer expression. A standard
+  conversion sequence [[conv]] is used to convert the initializer
+  expression to a prvalue of the destination type; no user-defined
+  conversions are considered. If the conversion cannot be done, the
+  initialization is ill-formed. When initializing a bit-field with a
+  value that it cannot represent, the resulting value of the bit-field
+  is *implementation-defined*.
   \[*Note 8*:
   An expression of type “*cv1* `T`” can initialize an object of type
   “*cv2* `T`” independently of the cv-qualifiers *cv1* and *cv2*.
   ``` cpp
   int a;
 - no private or protected direct base classes [[class.access.base]], and
 - no virtual functions [[class.virtual]] or virtual base classes
   [[class.mi]].
 [*Note 1*: Aggregate initialization does not allow accessing protected
+and private base class’ members, including constructors. — *end note*]
 The *elements* of an aggregate are:
 - for an array, the array elements in increasing subscript order, or
 - for a class, the direct base classes in declaration order, followed by
   *designated-initializer-list*, the aggregate shall be of class type,
   the *identifier* in each *designator* shall name a direct non-static
   data member of the class, and the explicitly initialized elements of
   the aggregate are the elements that are, or contain, those members.
 - If the initializer list is a brace-enclosed *initializer-list*, the
+  explicitly initialized elements of the aggregate are those for which
+ an element of the initializer list appertains to the aggregate element
+ or to a subobject thereof (see below).
 - Otherwise, the initializer list must be `{}`, and there are no
   explicitly initialized elements.
 For each explicitly initialized element:
   } c = { .a = 1, .x = 3 };
   ```
   initializes `c.a` with 1 and `c.x` with 3.
   — *end example*]
+- Otherwise, if the initializer list is a brace-enclosed
+  *designated-initializer-list*, the element is initialized with the
   *brace-or-equal-initializer* of the corresponding
   *designated-initializer-clause*. If that initializer is of the form
+  `= `*assignment-expression* and a narrowing conversion
+  [[dcl.init.list]] is required to convert the expression, the program
+  is ill-formed. \[*Note 2*: The form of the initializer determines
+ whether copy-initialization or direct-initialization is
   performed. — *end note*]
+- Otherwise, the initializer list is a brace-enclosed
+  *initializer-list*. If an *initializer-clause* appertains to the
+  aggregate element, then the aggregate element is copy-initialized from
+  the *initializer-clause*. Otherwise, the aggregate element is
+  copy-initialized from a brace-enclosed *initializer-list* consisting
+  of all of the *initializer-clause*s that appertain to subobjects of
+  the aggregate element, in the order of appearance.
   \[*Note 3*: If an initializer is itself an initializer list, the
   element is list-initialized, which will result in a recursive
   application of the rules in this subclause if the element is an
   aggregate. — *end note*]
   \[*Example 2*:
 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'`).
 ``` cpp
 struct A {
   string a;
   int b = 42;
 element that follows it in order.
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in  [[dcl.init]].
+The destructor for each element of class type other than an anonymous
+union member is potentially invoked [[class.dtor]] from the context
+where the aggregate initialization occurs.
 [*Note 4*: This provision ensures that destructors can be called for
 fully-constructed subobjects in case an exception is thrown
 [[except.ctor]]. — *end note*]
+The number of elements [[dcl.array]] in an array of unknown bound
+initialized with a brace-enclosed *initializer-list* is the number of
+explicitly initialized elements of the array.
 [*Example 4*:
 ``` cpp
 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.
 — *end example*]
+[*Example 5*:
+In
+``` cpp
+struct X { int i, j, k; };
+X a[] = { 1, 2, 3, 4, 5, 6 };
+X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
+```
+`a` and `b` have the same value.
+— *end example*]
 An array of unknown bound shall not be initialized with an empty
 *braced-init-list* `{}`.[^6]
 [*Note 5*:
 array of unknown bound. Since the default member initializer is ignored
 if a suitable *mem-initializer* is present [[class.base.init]], the
 default member initializer is not considered to initialize the array of
 unknown bound.
+[*Example 6*:
 ``` cpp
 struct S {
   int y[] = { 0 };          // error: non-static data member of incomplete type
 };
 [*Note 6*:
 Static data members, non-static data members of anonymous union members,
 and unnamed bit-fields are not considered elements of the aggregate.
+[*Example 7*:
 ``` cpp
 struct A {
   int i;
   static int s;
 — *end example*]
 — *end note*]
 If a member has a default member initializer and a potentially-evaluated
 subexpression thereof is an aggregate initialization that would use that
 default member initializer, the program is ill-formed.
 [*Example 8*:
 };
 ```
 — *end example*]
 When initializing a multidimensional array, the *initializer-clause*s
 initialize the elements with the last (rightmost) index of the array
 varying the fastest [[dcl.array]].
+[*Example 9*:
 ``` cpp
 int x[2][2] = { 3, 1, 4, 2 };
 ```
 initializes the first column of `y` (regarded as a two-dimensional
 array) and leaves the rest zero.
 — *end example*]
+Each *initializer-clause* in a brace-enclosed *initializer-list* is said
+to *appertain* to an element of the aggregate being initialized or to an
+element of one of its subaggregates. Considering the sequence of
+*initializer-clause*s, and the sequence of aggregate elements initially
+formed as the sequence of elements of the aggregate being initialized
+and potentially modified as described below, each *initializer-clause*
+appertains to the corresponding aggregate element if
+- the aggregate element is not an aggregate, or
+- the *initializer-clause* begins with a left brace, or
+- the *initializer-clause* is an expression and an implicit conversion
+  sequence can be formed that converts the expression to the type of the
+  aggregate element, or
+- the aggregate element is an aggregate that itself has no aggregate
+  elements.
+Otherwise, the aggregate element is an aggregate and that subaggregate
+is replaced in the list of aggregate elements by the sequence of its own
+aggregate elements, and the appertainment analysis resumes with the
+first such element and the same *initializer-clause*.
+[*Note 7*:
+These rules apply recursively to the aggregate’s subaggregates.
+[*Example 10*:
+In
+``` cpp
+struct S1 { int a, b; };
+struct S2 { S1 s, t; };
+S2 x[2] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+S2 y[2] = {
+  {
+    { 1, 2 },
+    { 3, 4 }
+  },
+  {
+    { 5, 6 },
+    { 7, 8 }
+  }
+};
+```
+`x` and `y` have the same value.
+— *end example*]
+— *end note*]
+This process continues until all *initializer-clause*s have been
+exhausted. If any *initializer-clause* remains that does not appertain
+to an element of the aggregate or one of its subaggregates, the program
+is ill-formed.
 [*Example 11*:
+``` cpp
+char cv[4] = { 'a', 's', 'd', 'f', 0 };     // error: too many initializers
+```
+— *end example*]
+[*Example 12*:
 ``` cpp
 float y[4][3] = {
   { 1, 3, 5 },
   { 2, 4, 6 },
   { 3, 5, 7 },
 ```
 is a completely-braced initialization: 1, 3, and 5 initialize the first
 row of the array `y[0]`, namely `y[0][0]`, `y[0][1]`, and `y[0][2]`.
 Likewise the next two lines initialize `y[1]` and `y[2]`. The
+initializer ends early and therefore `y[3]`’s elements are initialized
+as if explicitly initialized with an expression of the form `float()`,
+that is, are initialized with `0.0`. In the following example, braces in
+the *initializer-list* are elided; however the *initializer-list* has
+the same effect as the completely-braced *initializer-list* of the above
 example,
 ``` cpp
 float y[4][3] = {
   1, 3, 5, 2, 4, 6, 3, 5, 7
 does not, therefore three elements from the list are used. Likewise the
 next three are taken successively for `y[1]` and `y[2]`.
 — *end example*]
+[*Note 8*:
+The initializer for an empty subaggregate is needed if any initializers
+are provided for subsequent elements.
+[*Example 13*:
+``` cpp
+struct S { } s;
+struct A {
+  S s1;
+  int i1;
+  S s2;
+  int i2;
+  S s3;
+  int i3;
+} a = {
+  { },              // Required initialization
+  0,
+  s,                // Required initialization
+  0
+};                  // Initialization not required for A::s3 because A::i3 is also not initialized
+```
+— *end example*]
+— *end note*]
+[*Example 14*:
 ``` cpp
 struct A {
   int i;
   operator int();
 is initialized with 4, `b.a2` is initialized with `a`, `b.z` is
 initialized with whatever `a.operator int()` returns.
 — *end example*]
+[*Note 9*: An aggregate array or an aggregate class can contain
 elements of a class type with a user-declared constructor
 [[class.ctor]]. Initialization of these aggregate objects is described
 in  [[class.expl.init]]. — *end note*]
+[*Note 10*: Whether the initialization of aggregates with static
+storage duration is static or dynamic is specified in
+[[basic.start.static]], [[basic.start.dynamic]], and
+[[stmt.dcl]]. — *end note*]
 When a union is initialized with an initializer list, there shall not be
 more than one explicitly initialized element.
+[*Example 15*:
 ``` cpp
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u g = { .a = 1, .b = "asdf" };  // error
 ```
 — *end example*]
+[*Note 11*: 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. — *end note*]
 ### Character arrays <a id="dcl.init.string">[[dcl.init.string]]</a>
 A reference cannot be changed to refer to another object after
 initialization.
 [*Note 1*: Assignment to a reference assigns to the object referred to
+by the reference [[expr.assign]]. — *end note*]
 Argument passing [[expr.call]] and function value return [[stmt.return]]
 are initializations.
 The initializer can be omitted for a reference only in a parameter
   double& rd3 = i;                // error: type mismatch and reference not const
   ```
   — *end example*]
 - Otherwise, if the initializer expression
+  - is an rvalue (but not a bit-field) or an lvalue of function type 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 rvalue of type
+    “*cv3* `T3`” or an lvalue of function type “*cv3* `T3`”, where
+ “*cv1* `T1`” is reference-compatible with “*cv3* `T3`” (see
+    [[over.match.ref]]),
   then the initializer expression in the first case and the converted
   expression in the second case is called the converted initializer. If
+  the converted initializer is a prvalue, let its type be denoted by
+  `T4`; the temporary materialization conversion [[conv.rval]] is
+ applied, considering the type of the prvalue to be “*cv1* `T4`”
+ [[conv.qual]]. In any case, the reference binds to the resulting
+  glvalue (or to an appropriate base class subobject).
   \[*Example 5*:
   ``` cpp
   struct A { };
   struct B : A { } b;
   extern B f();
   } x;
   const A& r = x;                     // binds to the A subobject of the result of the conversion
   int i2 = 42;
   int&& rri = static_cast<int&&>(i2); // binds directly to i2
   B&& rrb = x;                        // binds directly to the result of operator B
+  constexpr int f() {
+    const int &x = 42;
+    const_cast<int &>(x) = 1;         // undefined behavior
+    return x;
+  }
+  constexpr int z = f();              // error: not a constant expression
+  typedef int *AP[3];                 // array of 3 pointer to int
+  typedef const int *const ACPC[3];   // array of 3 const pointer to const int
+  ACPC &&r = AP{};                    // binds directly
   ```
   — *end example*]
+- Otherwise, `T1` shall not be reference-related to `T2`.
+  - If `T1` or `T2` is a class type, user-defined conversions are
+    considered using the rules for copy-initialization of an object of
+    type “*cv1* `T1`” by user-defined conversion
     [[dcl.init]], [[over.match.copy]], [[over.match.conv]]; the program
     is ill-formed if the corresponding non-reference copy-initialization
+    would be ill-formed. The result E of the call to the conversion
     function, as described for the non-reference copy-initialization, is
+    then used to direct-initialize the reference using the form `(E)`.
+ For this direct-initialization, user-defined conversions are not
+    considered.
   - Otherwise, the initializer expression is implicitly converted to a
     prvalue of type “`T1`”. The temporary materialization conversion is
     applied, considering the type of the prvalue to be “*cv1* `T1`”, and
     the reference is bound to the result.
   \[*Example 6*:
   ``` cpp
   struct Banana { };
   struct Enigma { operator const Banana(); };
   struct Alaska { operator Banana&(); };
     Banana &&banana1 = ConstBanana(); // error
     Banana &&banana2 = Enigma();      // error
     Banana &&banana3 = Alaska();      // error
   }
+  const double& rcd2 = 2;             // rcd2 refers to temporary with type const double and value 2.0
   double&& rrd = 2;                   // rrd refers to temporary with value 2.0
   const volatile int cvi = 1;
   const int& r2 = cvi;                // error: cv-qualifier dropped
   struct A { operator volatile int&(); } a;
   const int& r3 = a;                  // error: cv-qualifier dropped
                                       // from result of conversion function
   double d2 = 1.0;
+  double&& rrd2 = d2;                 // error: initializer is lvalue of reference-related type
   struct X { operator int&(); };
+  int&& rri2 = X();                   // error: result of conversion function is
+                                      // lvalue of reference-related type
   int i3 = 2;
   double&& rrd3 = i3;                 // rrd3 refers to temporary with value 2.0
   ```
   — *end example*]
 In all cases except the last (i.e., implicitly converting the
 initializer expression to the referenced type), the reference is said to
 *bind directly* to the initializer expression.
+[*Note 3*:  [[class.temporary]] describes the lifetime of temporaries
 bound to references. — *end note*]
 ### List-initialization <a id="dcl.init.list">[[dcl.init.list]]</a>
 *List-initialization* is initialization of an object or reference from a
 are called the *elements* of the initializer list. An initializer list
 may be empty. List-initialization can occur in direct-initialization or
 copy-initialization contexts; list-initialization in a
 direct-initialization context is called *direct-list-initialization* and
 list-initialization in a copy-initialization context is called
+*copy-list-initialization*. Direct-initialization that is not
+list-initialization is called *direct-non-list-initialization*.
 [*Note 1*:
 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 template argument [[temp.arg.nontype]],
+- 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]],
+- in a *mem-initializer* [[class.base.init]], or
+- on the right-hand side of an assignment [[expr.assign]].
 [*Example 1*:
 ``` cpp
 int a = {1};
 library declaration [[initializer.list.syn]], [[std.modules]] of
 `std::initializer_list` is not reachable from [[module.reach]] 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 *cv* `T` is
+defined as follows:
+- If the *braced-init-list* contains a *designated-initializer-list* and
+  `T` is not a reference type, `T` shall be an aggregate class. The
+ ordered *identifier*s in the *designator*s of the
+ *designated-initializer-list* shall form a subsequence of the ordered
+ *identifier*s in the direct non-static data members of `T`. Aggregate
+ initialization is performed [[dcl.init.aggr]].
   \[*Example 2*:
   ``` cpp
   struct A { int x; int y; int z; };
   A a{.y = 2, .x = 1};                // error: designator order does not match declaration order
   A b{.x = 1, .z = 2};                // OK, b.y initialized to 0
   ```
   — *end example*]
 - If `T` is an aggregate class and the initializer list has a single
+  element of type *cv1* `U`, where `U` is `T` or a class derived from
   `T`, the object is initialized from that element (by
   copy-initialization for copy-list-initialization, or by
   direct-initialization for direct-list-initialization).
 - Otherwise, if `T` is a character array and the initializer list has a
   single element that is an appropriately-typed *string-literal*
   ```
   — *end example*]
 - 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`, the
+  object is constructed as described below.
 - 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]]. If a
   narrowing conversion (see below) is required to convert any of the
   arguments, the program is ill-formed.
   \[*Example 4*:
   ``` cpp
   struct S {
     S(std::initializer_list<double>); // #1
     S(std::initializer_list<int>);    // #2
+    S(std::initializer_list<S>); // #3
+    S();                              // #4
     // ...
   };
   S s1 = { 1.0, 2.0, 3.0 };           // invoke #1
   S s2 = { 1, 2, 3 };                 // invoke #2
+  S s3{s2}; // invoke #3 (not the copy constructor)
+  S s4 = { };                         // invoke #4
   ```
   — *end example*]
   \[*Example 5*:
   ``` cpp
   S s3 { };                           // OK, invoke #2
   ```
   — *end example*]
 - Otherwise, if `T` is an enumeration with a fixed underlying type
+  [[dcl.enum]] `U`, the *initializer-list* has a single element `v` of
+ scalar type, `v` can be implicitly converted to `U`, and the
+ initialization is direct-list-initialization, the object is
+ initialized with the value `T(v)` [[expr.type.conv]]; if a narrowing
+ conversion is required to convert `v` to `U`, the program is
+  ill-formed.
   \[*Example 7*:
   ``` cpp
   enum byte : unsigned char { };
   byte b { 42 };                      // OK
   byte c = { 42 };                    // error
   enum class Handle : uint32_t { Invalid = 0 };
   Handle h { 42 };                    // OK
   ```
   — *end example*]
+- Otherwise, if the initializer list is not a
+ *designated-initializer-list* and 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 (by copy-initialization for copy-list-initialization, or
   by direct-initialization for direct-list-initialization); if a
   narrowing conversion (see below) is required to convert the element to
   `T`, the program is ill-formed.
   const int (&iar)[2] = { 1, 2 };     // OK, iar is bound to temporary array
   struct A { } a;
   struct B { explicit B(const A&); };
   const B& b2{a};                     // error: cannot copy-list-initialize B temporary from A
+  struct C { int x; };
+  C&& c = { .x = 1 };                 // OK
   ```
   — *end example*]
 - Otherwise, if the initializer list has no elements, the object is
   value-initialized.
 arguments of a call. — *end note*]
 An object of type `std::initializer_list<E>` is constructed from an
 initializer list as if the implementation generated and materialized
 [[conv.rval]] a prvalue of type “array of N `const E`”, where N is the
+number of elements in the initializer list; this is called the
+initializer list’s *backing array*. Each element of the backing 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.
 [*Note 5*: A constructor or conversion function selected for the copy
+needs to be accessible [[class.access]] in the context of the
 initializer list. — *end note*]
 If a narrowing conversion is required to initialize any of the elements,
 the program is ill-formed.
+[*Note 6*: Backing arrays are potentially non-unique objects
+[[intro.object]]. — *end note*]
+The backing 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.
+[*Example 12*:
+``` cpp
+void f(std::initializer_list<double> il);
+void g(float x) {
+  f({1, x, 3});
+}
+void h() {
+  f({1, 2, 3});
+}
+struct A {
+  mutable int i;
+};
+void q(std::initializer_list<A>);
+void r() {
+  q({A{1}, A{2}, A{3}});
+}
+```
+The initialization will be implemented in a way roughly equivalent to
+this:
+``` cpp
+void g(float x) {
+  const double __a[3] = {double{1}, double{x}, double{3}};              // backing array
+  f(std::initializer_list<double>(__a, __a+3));
+}
+void h() {
+  static constexpr double __b[3] = {double{1}, double{2}, double{3}};   // backing array
+  f(std::initializer_list<double>(__b, __b+3));
+}
+void r() {
+  const A __c[3] = {A{1}, A{2}, A{3}};                                  // backing array
+  q(std::initializer_list<A>(__c, __c+3));
+}
+```
+assuming that the implementation can construct an `initializer_list`
+object with a pair of pointers, and with the understanding that `__b`
+does not outlive the call to `f`.
+— *end example*]
 [*Example 13*:
 ``` cpp
 typedef std::complex<double> cmplx;
 std::vector<cmplx> v1 = { 1, 2, 3 };
 *ctor-initializer* as if by binding a temporary array to a reference
 member, so the program is ill-formed [[class.base.init]].
 — *end example*]
 A *narrowing conversion* is an implicit conversion
 - from a floating-point type to an integer type, or
 - from a floating-point type `T` to another floating-point type whose
   floating-point conversion rank is neither greater than nor equal to
+  that of `T`, except where the result of the conversion is a constant
+ expression and either its value is finite and the conversion did not
+ overflow, or the values before and after the conversion are not
+  finite, or
 - from an integer type or unscoped enumeration type to a floating-point
   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

Diff to HTML by rtfpessoa