Merge 2016-06 CWG Motion 9

Author: zygoloid

source/declarators.tex

@@ -2798,6 +2798,11 @@
 An \grammarterm{initializer-clause} followed by an ellipsis is a
 pack expansion~(\ref{temp.variadic}).
 
+\pnum
+If the initializer is a parenthesized \grammarterm{expression-list},
+the expressions are evaluated in the order
+specified for function calls~(\ref{expr.call}).
+
 \rSec2[dcl.init.aggr]{Aggregates}%
 \indextext{aggregate}%
 \indextext{initialization!aggregate}%

source/expressions.tex

@@ -32,8 +32,8 @@
 expressions of class type~(Clause \ref{class}) or enumeration
 type~(\ref{dcl.enum}). Uses of overloaded operators are transformed into
 function calls as described in~\ref{over.oper}. Overloaded operators
-obey the rules for syntax specified in Clause~\ref{expr}, but the
-requirements of operand type, value category, and evaluation order are replaced
+obey the rules for syntax and evaluation order specified in Clause~\ref{expr},
+but the requirements of operand type and value category are replaced
 by the rules for function call. Relations between operators, such as
 \tcode{++a} meaning \tcode{a+=1}, are not guaranteed for overloaded
 operators~(\ref{over.oper}).
@@ -1461,6 +1461,7 @@
 \tcode{+} and~\ref{dcl.array} for details of arrays.
 \end{note}, except that in the case of an array operand, the result is an lvalue
 if that operand is an lvalue and an xvalue otherwise.
+The expression \tcode{E1} is sequenced before the expression \tcode{E2}.
 
 \pnum
 A \grammarterm{braced-init-list} shall not be used with the built-in subscript operator.
@@ -1538,8 +1539,6 @@
 When a function is called, each parameter~(\ref{dcl.fct}) shall be
 initialized~(\ref{dcl.init},~\ref{class.copy},~\ref{class.ctor}) with
 its corresponding argument.
-\begin{note} Such initializations are indeterminately sequenced
-with respect to each other~(\ref{intro.execution}) \end{note}
 If the function is a non-static member
 function, the \tcode{this} parameter of the function~(\ref{class.this})
 shall be initialized with a pointer to the object of the call, converted
@@ -1573,6 +1572,33 @@
 (Clause~\ref{except}) with a handler that could handle the exception,
 this handler is not considered.
 \end{example}
+
+\pnum
+\indextext{evaluation!order~of argument}%
+\indextext{evaluation!unspecified order~of function~call}%
+\indextext{evaluation!unspecified order~of argument}%
+The \grammarterm{postfix-expression} is sequenced before
+each \grammarterm{expression} in the \grammarterm{expression-list}
+and any default argument.
+The initialization of a parameter,
+including every associated value computation and side effect,
+is indeterminately sequenced with respect to that of any other parameter.
+\begin{note}
+All side effects of
+argument evaluations are sequenced before the function is
+entered (see~\ref{intro.execution}).
+\end{note}
+\begin{example}
+\begin{codeblock}
+void f() {
+  std::string s = "but I have heard it works even if you don't believe in it";
+  s.replace(0, 4, "").replace(s.find("even"), 4, "only").replace(s.find(" don't"), 6, "");
+  assert(s == "I have heard it works only if you believe in it"); // OK
+}
+\end{codeblock}
+\end{example}
+
+\pnum
 The result of a function call is the
 result of the operand of the evaluated \tcode{return} statement~(\ref{stmt.return})
 in the called function (if any),
@@ -1642,18 +1668,6 @@
 promoted type before the call. These promotions are referred to as
 the \defnx{default argument promotions}{promotion!default argument promotion}.
 
-\pnum
-\indextext{evaluation!order~of argument}%
-\indextext{evaluation!unspecified order~of function~call}%
-\begin{note}
-The evaluations of the postfix expression and of the arguments
-are all unsequenced relative to one another.
-\indextext{evaluation!unspecified order~of argument}%
-All side effects of
-argument evaluations are sequenced before the function is
-entered (see~\ref{intro.execution}).
-\end{note}
-
 \pnum
 \indextext{function~call!recursive}%
 Recursive calls are permitted, except to the \tcode{main}
@@ -3393,16 +3407,12 @@
 \pnum
 \indextext{\idxcode{new}!unspecified order~of evaluation}%
 \indextext{\idxcode{new}!unspecified constructor~and}%
-The invocation of the allocation function is indeterminately sequenced with respect to
+The invocation of the allocation function is sequenced before
 the evaluations of expressions in the \grammarterm{new-initializer}. Initialization of
 the allocated object is sequenced before the
 \indextext{value computation}%
 value computation of the
 \grammarterm{new-expression}.
-\indextext{constructor!unspecified argument~to}%
-It is unspecified whether expressions in the \grammarterm{new-initializer} are
-evaluated if the allocation function returns the null pointer or exits
-using an exception.
 
 \pnum
 If the \grammarterm{new-expression} creates an object or an array of
@@ -3417,8 +3427,7 @@
 If any part of the object initialization described above\footnote{This may
 include evaluating a \grammarterm{new-initializer} and/or calling
 a constructor.}
-terminates by throwing an exception, storage has been obtained for the
-object, and a suitable deallocation function
+terminates by throwing an exception and a suitable deallocation function
 can be found, the deallocation function is called to free the memory in
 which the object was being constructed, after which the exception
 continues to propagate in the context of the \grammarterm{new-expression}.
@@ -3871,6 +3880,7 @@
 If the dynamic type of \tcode{E1} does not
 contain the member to which
 \tcode{E2} refers, the behavior is undefined.
+Otherwise, the expression \tcode{E1} is sequenced before the expression \tcode{E2}.
 
 \pnum
 The restrictions on \cvqual{cv-}qualification, and the manner in which
@@ -4125,6 +4135,9 @@
 has a signed type and a negative value, the resulting value is
 \impldef{result of right shift of negative value}.
 
+\pnum
+The expression \tcode{E1} is sequenced before the expression \tcode{E2}.
+
 \rSec1[expr.rel]{Relational operators}%
 \indextext{expression!relational operators}%
 \indextext{operator!relational}
@@ -4685,7 +4698,9 @@
 \indextext{value computation}%
 value computation of the right and left operands,
 and before the
-value computation of the assignment expression. With
+value computation of the assignment expression.
+The right operand is sequenced before the left operand.
+With
 respect to an indeterminately-sequenced function call, the operation of
 a compound assignment is a single evaluation.
 \begin{note}
@@ -4795,10 +4810,7 @@
 
 A pair of expressions separated by a comma is evaluated left-to-right;
 the left expression is
-a discarded-value expression (Clause~\ref{expr}).\footnote{However, an
-invocation of an overloaded comma operator is an ordinary function call; hence,
-the evaluations of its argument expressions are unsequenced relative to one
-another~(see \ref{intro.execution}).}
+a discarded-value expression (Clause~\ref{expr}).
 Every
 \indextext{value computation}%
 value computation and side effect

source/intro.tex

@@ -954,6 +954,14 @@
 \term{B} or \term{B} is sequenced before \term{A}, but it is unspecified which.
 \begin{note} Indeterminately sequenced evaluations cannot overlap, but either
 could be executed first. \end{note}
+An expression \placeholder{X}
+is said to be sequenced before
+an expression \placeholder{Y} if
+every value computation and every side effect
+associated with the expression \placeholder{X}
+is sequenced before
+every value computation and every side effect
+associated with the expression \placeholder{Y}.
 
 \pnum
 Every
@@ -1012,10 +1020,7 @@
 side effect associated with any argument
 expression, or with the postfix expression designating the called
 function, is sequenced before execution of every expression or statement
-in the body of the called function. \begin{note}
-Value computations and
-side effects associated with different argument expressions are
-unsequenced. \end{note}
+in the body of the called function.
 For each function invocation \term{F},
 for every evaluation \term{A} that occurs within \term{F} and
 every evaluation \term{B} that does not occur within \term{F} but

source/overloading.tex

@@ -962,6 +962,8 @@
 to the equivalent function-call notation as summarized in
 Table~\ref{tab:over.rel.op.func}
 (where \tcode{@} denotes one of the operators covered in the specified subclause).
+However, the operands are sequenced in the order prescribed
+for the built-in operator (Clause~\ref{expr}).
 
 \begin{floattable}{Relationship between operator and function call notation}{tab:over.rel.op.func}
 {l|m|m|m}