CWG2879 Undesired outcomes with const_cast

Also fixes CWG1965.
tkoeppe · Dec 16, 2024 · Nov 27, 2024 · Nov 27, 2024 · Nov 27, 2024 · Nov 27, 2024
commit fc62fb5e950fd34efb31983322863d9a661f0207
diff --git a/source/declarations.tex b/source/declarations.tex
@@ -5810,6 +5810,10 @@
   return x;
 }
 constexpr int z = f();              // error: not a constant expression
+
+typedef int *A[3];                  // array of 3 pointer to \tcode{int}
+typedef const int *const CA[3];     // array of 3 const pointer to \tcode{const int}
+ACPC &&r = AP{};                    // binds directly
 \end{codeblock}
 \end{example}
 

diff --git a/source/expressions.tex b/source/expressions.tex
@@ -266,7 +266,8 @@
 \end{note}
 
 \pnum
-Whenever a prvalue appears as an operand of an operator that
+Unless otherwise specified\iref{expr.const.cast},
+whenever a prvalue appears as an operand of an operator that
 expects a glvalue for that operand, the
 temporary materialization conversion\iref{conv.rval} is
 applied to convert the expression to an xvalue.
@@ -4497,7 +4498,10 @@
 otherwise, the result is a prvalue and the
 lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
 and function-to-pointer\iref{conv.func} standard conversions are
-performed on the expression \tcode{v}. Conversions that can be performed explicitly using
+performed on the expression \tcode{v}.
+The temporary materialization conversion\iref{conv.rval} is not
+performed on \tcode{v}, other than as specified below.
+Conversions that can be performed explicitly using
 \keyword{const_cast} are listed below. No other conversion shall be
 performed explicitly using \keyword{const_cast}.
 
@@ -4508,23 +4512,16 @@
 \end{note}
 
 \pnum
-For two similar types \tcode{T1} and \tcode{T2}\iref{conv.qual},
-a prvalue of type \tcode{T1} may be explicitly
+For two similar object pointer or pointer to data member types
+\tcode{T1} and \tcode{T2}\iref{conv.qual},
+a prvalue of type \tcode{T1} can be explicitly
 converted to the type \tcode{T2} using a \keyword{const_cast}
 if, considering the qualification-decompositions of both types,
 each $P^1_i$ is the same as $P^2_i$ for all $i$.
-The result of a \keyword{const_cast} refers to the original entity.
-\begin{example}
-\begin{codeblock}
-typedef int *A[3];                  // array of 3 pointer to \tcode{int}
-typedef const int *const CA[3];     // array of 3 const pointer to \tcode{const int}
-
-CA &&r = A{};                       // OK, reference binds to temporary array object
-                                    // after qualification conversion to type \tcode{CA}
-A &&r1 = const_cast<A>(CA{});       // error: temporary array decayed to pointer
-A &&r2 = const_cast<A&&>(CA{});     // OK
-\end{codeblock}
-\end{example}
+If \tcode{v} is a null pointer or null member pointer,
+the result is a null pointer or null member pointer, respectively.
+Otherwise, the result points to or past the end of the same object, or
+points to the same member, respectively, as \tcode{v}.
 
 \pnum
 For two object types \tcode{T1} and \tcode{T2}, if a pointer to \tcode{T1} can
@@ -4537,20 +4534,22 @@
 \item a glvalue of type \tcode{T1} can be explicitly converted to an xvalue
 of type \tcode{T2} using the cast \tcode{\keyword{const_cast}<T2\&\&>}; and
 
-\item if \tcode{T1} is a class type, a prvalue of type \tcode{T1} can be
+\item if \tcode{T1} is a class or array type,
+a prvalue of type \tcode{T1} can be
 explicitly converted to an xvalue of type \tcode{T2} using the cast
 \tcode{\keyword{const_cast}<T2\&\&>}.
+The temporary materialization conversion is performed on \tcode{v}.
 \end{itemize}
 
-The result of a reference \keyword{const_cast} refers
-to the original object if the operand is a glvalue and
-to the result of applying the temporary materialization conversion\iref{conv.rval} otherwise.
+The result refers to the same object as the (possibly converted) operand.
+\begin{example}
+\begin{codeblock}
+typedef int *A[3];                  // array of 3 pointer to \tcode{int}
+typedef const int *const CA[3];     // array of 3 const pointer to \tcode{const int}
 
-\pnum
-A null pointer value\iref{basic.compound} is converted to the null pointer
-value of the destination type. The null member pointer
-value\iref{conv.mem} is converted to the null member pointer value of
-the destination type.
+auto &&r2 = const_cast<A&&>(CA{});  // OK, temporary materialization conversion is performed
+\end{codeblock}
+\end{example}
 
 \pnum
 \begin{note}