Merge 2017-07 CWG Motion 3

Author: zygoloid

source/compatibility.tex

@@ -1294,7 +1294,7 @@
 \item using \tcode{operator==} to compare to \tcode{false} or \tcode{true};
 \item returning a value from a function with a return type of \tcode{bool};
 \item initializing members of type \tcode{bool} via aggregate initialization;
-\item initializing a \tcode{const bool\&} which would bind to a temporary.
+\item initializing a \tcode{const bool\&} which would bind to a temporary object.
 \end{itemize}
 
 \ref{ios::failure}

source/expressions.tex

@@ -238,7 +238,7 @@
 \begin{note}
 If the expression is an lvalue of
 class type, it must have a volatile copy constructor to initialize the
-temporary that is the result object of the lvalue-to-rvalue
+temporary object that is the result object of the lvalue-to-rvalue
 conversion. \end{note}
 The glvalue expression is evaluated and its value is discarded.
 

source/lib-intro.tex

@@ -2602,7 +2602,8 @@
 and thus is not covered by the previous sentence. \end{note} \begin{note} If a program casts
 an lvalue to an xvalue while passing that lvalue to a library function (e.g. by calling the function
 with the argument \tcode{std::move(x)}), the program
-is effectively asking that function to treat that lvalue as a temporary. The implementation
+is effectively asking that function to treat that lvalue as a temporary object.
+The implementation
 is free to optimize away aliasing checks which might be needed if the argument was
 an lvalue. \end{note}
 \end{itemize}

source/numerics.tex

@@ -6745,7 +6745,7 @@
 by the generalized subscript operators.\footnote{The intent is to specify
 an array template that has the minimum functionality
 necessary to address aliasing ambiguities and the proliferation of
-temporaries.
+temporary objects.
 Thus, the
 \tcode{valarray}
 template is neither a

source/overloading.tex

@@ -1211,8 +1211,8 @@
 the non-explicit conversion functions of
 \tcode{S}
 and its base classes are considered.
-When initializing a temporary to be bound to the first parameter of a
-constructor
+When initializing a temporary object~(\ref{class.mem})
+to be bound to the first parameter of a constructor
 where the parameter is of type
 ``reference to possibly \cv-qualified \tcode{T}''
 and the constructor is

source/special.tex

@@ -524,13 +524,83 @@
 
 \pnum
 The third context is when a reference is bound to a
-temporary.\footnote{The same rules apply to initialization of an
+temporary object.\footnote{The same rules apply to initialization of an
   \tcode{initializer_list} object~(\ref{dcl.init.list}) with its
   underlying temporary array.}
-The temporary to which the reference is bound or the temporary
+The temporary object to which the reference is bound or the temporary object
 that is the complete object of a subobject to which the reference is bound
-persists for the lifetime of the reference except:
+persists for the lifetime of the reference if the glvalue
+to which the reference is bound
+was obtained through one of the following:
+\begin{itemize}
+\item
+  a temporary materialization conversion~(\ref{conv.rval}),
+\item
+  \tcode{(} \grammarterm{expression} \tcode{)},
+  where \grammarterm{expression} is one of these expressions,
+\item
+  subscripting~(\ref{expr.sub}) of an array operand,
+  where that operand is one of these expressions,
+\item
+  a class member access~(\ref{expr.ref}) using the \tcode{.} operator
+  where the left operand is one of these expressions and
+  the right operand designates a non-static data member of non-reference type,
+\item 
+  a pointer-to-member operation~(\ref{expr.mptr.oper}) using the \tcode{.*} operator
+  where the left operand is one of these expressions and
+  the right operand is a pointer to data member of non-reference type,
+\item 
+  a \tcode{const_cast}~(\ref{expr.const.cast}),
+  \tcode{static_cast}~(\ref{expr.static.cast}),
+  \tcode{dynamic_cast}~(\ref{expr.dynamic.cast}), or
+  \tcode{reinterpret_cast}~(\ref{expr.reinterpret.cast})
+  converting, without a user-defined conversion,
+  a glvalue operand that is one of these expressions
+  to a glvalue that refers
+  to the object designated by the operand, or
+  to its complete object or a subobject thereof,
+\item 
+  a conditional expression~(\ref{expr.cond}) that is a glvalue
+  where the second or third operand is one of these expressions, or
+\item 
+  a comma expression~(\ref{expr.comma}) that is a glvalue
+  where the right operand is one of these expressions.
+\end{itemize}
+\begin{example}
+\begin{codeblock}
+template<typename T> using id = T;
+
+int&& a = id<int[3]>{1, 2, 3}[i];          // temporary array has same lifetime as \tcode{a}
+const int& b = static_cast<const int&>(0); // temporary \tcode{int} has same lifetime as \tcode{b}
+int&& c = cond ? id<int[3]>{1, 2, 3}[i] : static_cast<int&&>(0);
+                                           // exactly one of the two temporaries is lifetime-extended
+\end{codeblock}
+\end{example}
+\begin{note}
+An explicit type conversion~(\ref{expr.type.conv}, \ref{expr.cast})
+is interpreted as
+a sequence of elementary casts,
+covered above.
+\begin{example}
+\begin{codeblock}
+const int& x = (const int&)1;  // temporary for value 1 has same lifetime as x
+\end{codeblock}
+\end{example}
+\end{note}
+\begin{note}
+If a temporary object has a reference member initialized by another temporary object,
+lifetime extension applies recursively to such a member's initializer.
+\begin{example}
+\begin{codeblock}
+struct S {
+  const int& m;
+};
+const S& s = S{1};             // both \tcode{S} and \tcode{int} temporaries have lifetime of \tcode{s}
+\end{codeblock}
+\end{example}
+\end{note}
 
+The exceptions to this lifetime rule are:
 \begin{itemize}
 \item A temporary object bound to a reference parameter in a function call~(\ref{expr.call})
 persists until the completion of the full-expression containing the call.
@@ -541,7 +611,7 @@
 \begin{codeblock}
 struct S { int mi; const std::pair<int,int>& mp; };
 S a { 1, {2,3} };
-S* p = new S{ 1, {2,3} };   // Creates dangling reference
+S* p = new S{ 1, {2,3} };      // creates dangling reference
 \end{codeblock}
 \end{example} \begin{note} This may introduce a dangling reference, and implementations should issue a warning in such a case. \end{note}
 \end{itemize}

source/utilities.tex

@@ -10585,7 +10585,7 @@
 \pnum\effects  Equivalent to \tcode{weak_ptr(r).swap(*this)}.
 
 \pnum\remarks  The implementation may meet the effects (and the
-implied guarantees) via different means, without creating a temporary.
+implied guarantees) via different means, without creating a temporary object.
 
 \pnum\returns  \tcode{*this}.
 \end{itemdescr}