Merge 2017-07 CWG Motion 8

Author: zygoloid

source/compatibility.tex

@@ -600,6 +600,43 @@
 \howwide
 Common in old programs, but already known to be obsolescent.
 
+\ref{dcl.init.aggr}
+\change
+In \Cpp, designated initialization support is restricted
+compared to the corresponding functionality in C.
+In \Cpp,
+designators for non-static data members
+must be specified in declaration order,
+designators for array elements and nested designators
+are not supported,
+and
+designated and non-designated initializers
+cannot be mixed in the same initializer list.
+
+Example:
+
+\begin{codeblock}
+struct A { int x, y; };
+struct B { struct A a; };
+struct A a = {.y = 1, .x = 2};  // valid C, invalid \Cpp
+int arr[3] = {[1] = 5};         // valid C, invalid \Cpp
+struct B b = {.a.x = 0};        // valid C, invalid \Cpp
+struct A c = {.x = 1, 2};       // valid C, invalid \Cpp
+\end{codeblock}
+\rationale
+In \Cpp, members are destroyed in reverse construction order
+and the elements of an initializer list are evaluated in lexical order,
+so field initializers must be specified in order.
+Array designators conflict with \grammarterm{lambda-expression} syntax.
+Nested designators are seldom used.
+\effect
+Deletion of feature that is incompatible with \Cpp.
+\difficulty
+Syntactic transformation.
+\howwide
+Out-of-order initializers are common.
+The other features are seldom used.
+
 \ref{dcl.init.string}
 \change In \Cpp, when initializing an array of character with a string, the number of
 characters in the string (including the terminating \tcode{'\textbackslash 0'}) must not exceed the

source/declarators.tex

@@ -2416,16 +2416,33 @@
     braced-init-list
 \end{bnf}
 
+\begin{bnf}
+\nontermdef{braced-init-list}\br
+    \terminal{\{} initializer-list \terminal{,\opt} \terminal{\}}\br
+    \terminal{\{} designated-initializer-list \terminal{,\opt} \terminal{\}}\br
+    \terminal{\{} \terminal{\}}
+\end{bnf}
+
 \begin{bnf}
 \nontermdef{initializer-list}\br
     initializer-clause \terminal{...}\opt\br
     initializer-list \terminal{,} initializer-clause \terminal{...}\opt
 \end{bnf}
 
 \begin{bnf}
-\nontermdef{braced-init-list}\br
-    \terminal{\{} initializer-list \terminal{,\opt} \terminal{\}}\br
-    \terminal{\{} \terminal{\}}
+\nontermdef{designated-initializer-list}\br
+    designated-initializer-clause\br
+    designated-initializer-list \terminal{,} designated-initializer-clause
+\end{bnf}
+
+\begin{bnf}
+\nontermdef{designated-initializer-clause}\br
+    designator brace-or-equal-initializer
+\end{bnf}
+
+\begin{bnf}
+\nontermdef{designator}\br
+    \tcode{.} identifier
 \end{bnf}
 
 \begin{bnf}
@@ -2894,6 +2911,11 @@
 the expressions are evaluated in the order
 specified for function calls~(\ref{expr.call}).
 
+\pnum
+The same \grammarterm{identifier}
+shall not appear in multiple \grammarterm{designator}{s} of a
+\grammarterm{designated-initializer-list}.
+
 \pnum
 An object whose initialization has completed
 is deemed to be constructed,
@@ -2960,15 +2982,53 @@
 When an aggregate is initialized by an initializer list
 as specified in~\ref{dcl.init.list},
 the elements of the initializer list are taken as initializers
-for the elements of the aggregate, in order.
-Each element is copy-initialized
-from the corresponding \grammarterm{initializer-clause}.
-If the \grammarterm{initializer-clause} is an expression and
+for the elements of the aggregate.
+The \defnx{explicitly initialized elements}{explicitly initialized elements!aggregate}
+of the aggregate are determined as follows:
+\begin{itemize}
+\item
+If the initializer list is a \grammarterm{designated-initializer-list},
+the aggregate shall be of class type,
+the \grammarterm{identifier} in each \grammarterm{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.
+\item
+If the initializer list is an \grammarterm{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.
+\item
+Otherwise, the initializer list must be \tcode{\{\}},
+and there are no explicitly initialized elements.
+\end{itemize}
+
+\pnum
+For each explicitly initialized element:
+\begin{itemize}
+\item
+If the element is an anonymous union object and
+the initializer list is a \grammarterm{designated-initializer-list},
+the anonymous union object is initialized by the
+\grammarterm{designated-initializer-list} \tcode{\{ }\placeholder{D}\tcode{ \}},
+where \placeholder{D} is the \grammarterm{designated-initializer-clause}
+naming a member of the anonymous union object.
+There shall be only one such \grammarterm{designated-initializer-clause}.
+\item
+Otherwise, the element is copy-initialized
+from the corresponding \grammarterm{initializer-clause}
+or the \grammarterm{brace-or-equal-initializer}
+of the corresponding \grammarterm{designated-initializer-clause}.
+If that initializer is of the form
+\grammarterm{assignment-expression} or
+\tcode{= }\grammarterm{assignment-expression}
+and
 a narrowing conversion~(\ref{dcl.init.list}) is required
 to convert the expression, the program is ill-formed.
-\begin{note} If an \grammarterm{initializer-clause} is itself an initializer list,
+\begin{note} 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 section if the element is an aggregate. \end{note}
+\end{itemize}
 \begin{example}
 \begin{codeblock}
 struct A {
@@ -3013,6 +3073,79 @@
 \tcode{d2.d} with 4.
 \end{example}
 
+\pnum
+For a non-union aggregate,
+each element that is not an explicitly initialized element
+is initialized as follows:
+\begin{itemize}
+\item
+If the element has a default member initializer~(\ref{class.mem}),
+the element is initialized from that initializer.
+\item
+Otherwise, if the element is not a reference, the element
+is copy-initialized from an empty initializer list~(\ref{dcl.init.list}).
+\item
+Otherwise, the program is ill-formed.
+\end{itemize}
+If the aggregate is a union and the initializer list is empty, then
+\begin{itemize}
+\item
+if any variant member has a default member initializer,
+that member is initialized from its default member initializer;
+\item
+otherwise, the first member of the union (if any)
+is copy-initialized from an empty initializer list.
+\end{itemize}
+\begin{example}
+
+\begin{codeblock}
+struct S { int a; const char* b; int c; int d = b[a]; };
+S ss = { 1, "asdf" };
+\end{codeblock}
+
+initializes
+\tcode{ss.a}
+with 1,
+\tcode{ss.b}
+with \tcode{"asdf"},
+\tcode{ss.c}
+with the value of an expression of the form
+\tcode{int\{\}}
+(that is, \tcode{0}), and \tcode{ss.d} with the value of \tcode{ss.b[ss.a]}
+(that is, \tcode{'s'}), and in
+
+\begin{codeblock}
+struct X { int i, j, k = 42; };
+X a[] = { 1, 2, 3, 4, 5, 6 };
+X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
+\end{codeblock}
+
+\tcode{a} and \tcode{b} have the same value
+
+\begin{codeblock}
+struct A {
+  string a;
+  int b = 42;
+  int c = -1;
+};
+\end{codeblock}
+
+\tcode{A\{.c=21\}} has the following steps:
+\begin{itemize}
+\item Initialize \tcode{a} with \tcode{\{\}}
+\item Initialize \tcode{b} with \tcode{= 42}
+\item Initialize \tcode{c} with \tcode{= 21}
+\end{itemize}
+\end{example}
+
+\pnum
+The initializations of the elements of the aggregate
+are evaluated in the element order.
+That is,
+all value computations and side effects associated with a given element
+are sequenced before
+those of any element that follows it in order.
+
 \pnum
 An aggregate that is a class can also be initialized with a single
 expression not enclosed in braces, as described in~\ref{dcl.init}.
@@ -3063,8 +3196,11 @@
 
 \pnum
 \begin{note}
-Static data members and unnamed bit-fields are not considered
-elements of the aggregate.
+Static data members,
+non-static data members of anonymous union members,
+and
+unnamed bit-fields
+are not considered elements of the aggregate.
 \begin{example}
 
 \begin{codeblock}
@@ -3090,7 +3226,7 @@
 \grammarterm{initializer-list}
 is ill-formed if the number of
 \grammarterm{initializer-clause}{s}
-exceeds the number of elements to initialize.
+exceeds the number of elements of the aggregate.
 \begin{example}
 
 \begin{codeblock}
@@ -3100,56 +3236,6 @@
 is ill-formed.
 \end{example}
 
-\pnum
-If there are fewer \grammarterm{initializer-clause}{s} in the list than there
-are elements in a non-union aggregate, then each element not explicitly initialized
-is initialized as follows:
-\begin{itemize}
-\item
-If the element has a default member initializer~(\ref{class.mem}),
-the element is initialized from that initializer.
-\item
-Otherwise, if the element is not a reference, the element
-is copy-initialized from an empty initializer list~(\ref{dcl.init.list}).
-\item
-Otherwise, the program is ill-formed.
-\end{itemize}
-If the aggregate is a union and the initializer list is empty, then
-\begin{itemize}
-\item
-if any variant member has a default member initializer,
-that member is initialized from its default member initializer;
-\item
-otherwise, the first member of the union (if any)
-is copy-initialized from an empty initializer list.
-\end{itemize}
-\begin{example}
-
-\begin{codeblock}
-struct S { int a; const char* b; int c; int d = b[a]; };
-S ss = { 1, "asdf" };
-\end{codeblock}
-
-initializes
-\tcode{ss.a}
-with 1,
-\tcode{ss.b}
-with \tcode{"asdf"},
-\tcode{ss.c}
-with the value of an expression of the form
-\tcode{int\{\}}
-(that is, \tcode{0}), and \tcode{ss.d} with the value of \tcode{ss.b[ss.a]}
-(that is, \tcode{'s'}), and in
-
-\begin{codeblock}
-struct X { int i, j, k = 42; };
-X a[] = { 1, 2, 3, 4, 5, 6 };
-X b[2] = { { 1, 2, 3 }, { 4, 5, 6 } };
-\end{codeblock}
-
-\tcode{a} and \tcode{b} have the same value
-\end{example}
-
 \pnum
 If a reference member is initialized from its default member initializer
 and a potentially-evaluated subexpression thereof is an aggregate
@@ -3374,19 +3460,19 @@
 
 \pnum
 \indextext{initialization!\idxcode{union}}%
-When a union is initialized with a brace-enclosed initializer,
-the braces shall only contain an
-\grammarterm{initializer-clause}
-for the first non-static data member of the union.
+When a union is initialized with an initializer list,
+there shall not be more than one
+explicitly initialized element.
 \begin{example}
-
 \begin{codeblock}
 union u { int a; const char* b; };
 u a = { 1 };
 u b = a;
 u c = 1;                        // error
 u d = { 0, "asdf" };            // error
 u e = { "asdf" };               // error
+u f = { .b = "asdf" };
+u g = { .a = 1, .b = "asdf" };  // error
 \end{codeblock}
 \end{example}
 
@@ -3730,9 +3816,15 @@
 
 \pnum
 \defnx{List-initialization}{list-initialization} is initialization of an object or reference from a
-\grammarterm{braced-init-list}. Such an initializer is called an \term{initializer
-list}, and the comma-separated \grammarterm{initializer-clause}{s} of the list are
-called the \term{elements} of the initializer list. An initializer list may be empty.
+\grammarterm{braced-init-list}.
+Such an initializer is called an \term{initializer list}, and
+the comma-separated
+\grammarterm{initializer-clause}{s}
+of the \grammarterm{initializer-list}
+or
+\grammarterm{designated-initializer-clause}{s}
+of the \grammarterm{designated-initializer-list}
+are called the \term{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
 \defn{direct-list-initialization} and list-initialization in a
@@ -3784,6 +3876,24 @@
 \pnum
 List-initialization of an object or reference of type \tcode{T} is defined as follows:
 \begin{itemize}
+\item
+If the \grammarterm{braced-init-list}
+contains a \grammarterm{designated-initializer-list},
+\tcode{T} shall be an aggregate class.
+The ordered \grammarterm{identifier}{s}
+in the \grammarterm{designator}{s}
+of the \grammarterm{designated-initializer-list}
+shall form a subsequence
+of the ordered \grammarterm{identifier}{s}
+in the direct non-static data members of \tcode{T}.
+Aggregate initialization is performed~(\ref{dcl.init.aggr}).
+\begin{example}
+\begin{codeblock}
+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, \tcode{b.y} initialized to \tcode{0}
+\end{codeblock}
+\end{example}
 
 \item If \tcode{T} is an aggregate class and the initializer list has a single element
 of type \cvqual{cv} \tcode{U},