CWG2765 Address comparisons between potentially non-unique objects during constant evaluation

burblebee · tkoeppe · commit adcdd790be87 · 2026-04-12T00:26:22.000+01:00
diff --git a/source/basic.tex b/source/basic.tex
@@ -5985,6 +5985,28 @@
 alignment requirement.
 \end{note}
 
+\pnum
+A pointer value
+pointing to a potentially non-unique object $O$\iref{intro.object} is
+\indextext{value!associated with an evaluation}%
+\defn{associated with} the evaluation of
+\begin{itemize}
+\item
+the string-literal\iref{lex.string} that resulted in the string literal object,
+\item
+the initializer list\iref{dcl.init.list} that resulted in the backing array,
+or
+\item
+the initialization of
+the template parameter object\iref{temp.arg.nontype, meta.define.static}
+\end{itemize}
+that is $O$ or of which $O$ is a subobject.
+\begin{note}
+A pointer value obtained by pointer arithmetic\iref{expr.add}
+from a pointer value associated with an evaluation $E$
+is also associated with $E$.
+\end{note}
+
 \pnum
 A pointer value $P$ is
 \indextext{value!valid in the context of an evaluation}%
diff --git a/source/expressions.tex b/source/expressions.tex
@@ -8329,6 +8329,19 @@
 
 \rSec2[expr.const.core]{Core constant expressions}
 
+\pnum
+\indextext{type!constexpr-unknown representation}%
+A type has \defnadj{constexpr-unknown}{representation} if it
+\begin{itemize}
+\item is a union,
+\item is a pointer or pointer-to-member type,
+\item is volatile-qualified,
+\item is a class type with a non-static data member of reference type, or
+\item
+has a base class or a non-static member whose
+type has constexpr-unknown representation.
+\end{itemize}
+
 \pnum
 An expression $E$ is a \defnadj{core constant}{expression}
 unless the evaluation of $E$, following the rules of the abstract
@@ -8556,6 +8569,34 @@
 relational\iref{expr.rel}, or equality\iref{expr.eq}
 operator where the result is unspecified;
 
+\item
+an equality operator comparing pointers to potentially non-unique objects,
+if the pointer values of the two operands
+are associated with different evaluations\iref{basic.compound} and either
+they can both point to the same offset within
+the same potentially non-unique object or
+one of them points to an object whose
+type has constexpr-unknown representation;
+\begin{example}
+\begin{codeblock}
+constexpr const char *f() { return "foo"; }
+
+constexpr bool b1 = +"foo" == "foo";                // error: non-constant
+constexpr bool b2 = f() == f();                     // error: non-constant
+constexpr const char *p = f();
+constexpr bool b3 = p == p;                         // OK, value of \tcode{b3} is \tcode{true}
+constexpr bool b4 = "xfoo" + 1 == "foo\0y";         // error: non-constant; string literal
+                                                    // object could contain \tcode{"xfoo\textbackslash{}0y"}
+constexpr bool b5 = "foo" == "bar" + 0;             // OK, value of \tcode{b5} is \tcode{false}
+constexpr bool b6 = (const char*)"foo" == "oo";     // OK, value of \tcode{b6} is \tcode{false}; offsets would
+                                                    // be different in a merged string literal object
+
+constexpr std::initializer_list<int *> il1 = { (int *)nullptr };
+constexpr std::initializer_list<unsigned long> il2 = { 0 };
+constexpr bool b7 = il1.begin() == (void *)il2.begin();     // error: non-constant
+\end{codeblock}
+\end{example}
+
 \item
 a \keyword{dynamic_cast}\iref{expr.dynamic.cast} or
 \keyword{typeid}\iref{expr.typeid} expression
diff --git a/source/utilities.tex b/source/utilities.tex
@@ -15943,15 +15943,8 @@
 
 \pnum
 \constantwhen
-\tcode{To}, \tcode{From}, and the types of all subobjects
-of \tcode{To} and \tcode{From} are types \tcode{T} such that:
-\begin{itemize}
-\item \tcode{is_union_v<T>} is \tcode{false};
-\item \tcode{is_pointer_v<T>} is \tcode{false};
-\item \tcode{is_member_pointer_v<T>} is \tcode{false};
-\item \tcode{is_volatile_v<T>} is \tcode{false}; and
-\item \tcode{T} has no non-static data members of reference type.
-\end{itemize}
+Neither \tcode{To} nor \tcode{From}
+has constexpr-unknown representation\iref{expr.const}.
 
 \pnum
 \returns
