P0595R2 std::is_constant_evaluated()

Author: jensmaurer

source/basic.tex

@@ -5667,15 +5667,9 @@
 \pnum
 \indextext{initialization!static object@\tcode{static} object}%
 \indextext{initialization!constant}%
-A \defn{constant initializer} for a variable or temporary object \tcode{o}
-is an initializer whose full-expression is a
-constant expression, except that if \tcode{o} is an object,
-such an initializer may also invoke constexpr constructors
-for \tcode{o} and its subobjects even if those objects are of non-literal class
-types. \begin{note} Such a class may have a non-trivial destructor. \end{note}
 \defnx{Constant initialization}{constant initialization} is performed
 if a variable or temporary object with static or thread storage duration
-is initialized by a constant initializer for the entity.
+is initialized by a constant initializer\iref{expr.const} for the entity.
 \indextext{initialization!runtime}%
 If constant initialization is not performed, a variable with static
 storage duration\iref{basic.stc.static} or thread storage

source/expressions.tex

@@ -6488,6 +6488,26 @@
     conditional-expression
 \end{bnf}
 
+\pnum
+A \defn{constant initializer} for a variable or temporary object \tcode{o} is
+an initializer for which interpreting its full-expression
+as a \grammarterm{constant-expression} results in a constant expression,
+except that if \tcode{o} is an object,
+such an initializer may also invoke constexpr constructors
+for \tcode{o} and its subobjects
+even if those objects are of non-literal class types.
+\begin{note}
+Such a class may have a non-trivial destructor.
+Within this evaluation,
+\tcode{std::is_constant_evaluated()}\iref{meta.is_constant_evaluated}
+returns \tcode{true}.
+\end{note}
+A variable is
+\defnx{usable in constant expressions}{usable in constant expression} after
+its initializing declaration is encountered if it is a constexpr variable, or
+it is of reference type or of const-qualified integral or enumeration type, and
+its initializer is a constant initializer.
+
 \pnum
 An expression \tcode{e} is a \defnadj{core constant}{expression}
 unless the evaluation of \tcode{e}, following the rules of the abstract
@@ -6540,17 +6560,6 @@
   to a complete non-volatile const object with a preceding initialization,
   initialized with a constant expression, or
 
-  \item
-  a non-volatile glvalue that refers to a subobject of a string
-  literal\iref{lex.string}, or
-
-  \item
-  a non-volatile glvalue that refers to a non-volatile object
-  defined with \tcode{constexpr} or
-  a template parameter object\iref{temp.param},
-  or that refers to a non-mutable subobject
-  of such an object, or
-
   \item
   a non-volatile glvalue of literal type that refers to a non-volatile object
   whose lifetime began within the evaluation of \tcode{e};
@@ -6579,7 +6588,7 @@
 
 \begin{itemize}
   \item
-  it is initialized with a constant expression or
+  it is usable in constant expressions or
 
   \item
   its lifetime began within the evaluation of \tcode{e};
@@ -6835,6 +6844,43 @@
 It is unspecified whether the value of \tcode{f()} will be \tcode{true} or \tcode{false}.
 \end{example} \end{note}%
 
+\pnum
+An expression or conversion \tcode{e} is \defn{manifestly constant-evaluated}
+if it is:
+\begin{itemize}
+\item a \grammarterm{constant-expression}, or
+\item the condition of a constexpr if statement\iref{stmt.if}, or
+\item the initializer of a constexpr variable\iref{dcl.constexpr}, or
+\item an immediate invocation, or
+\item a \grammarterm{constraint-expression}\iref{temp.constr.decl}
+(possibly one formed from the \grammarterm{constraint-logical-or-expression}
+of a \grammarterm{requires-clause}), or
+\item the initializer of a variable
+that is usable in constant expressions or
+has constant initialization.\footnote{Testing this condition
+may involve a trial evaluation of its initializer as described above.}
+\begin{example}
+\begin{codeblock}
+template<bool> struct X {};
+X<std::is_constant_evaluated()> x;                      // type X<true>
+int y;
+const int a = std::is_constant_evaluated() ? y : 1;     // dynamic initialization to 1
+double z[a];                                            // ill-formed: "a" is not "usable in constant expressions"
+const int b = std::is_constant_evaluated() ? 2 : y;     // static initialization to 2 
+int c = y + (std::is_constant_evaluated() ? 2 : y);     // dynamic initialization to y+y
+  
+constexpr int f() {
+  const int n = std::is_constant_evaluated() ? 13 : 17; // n == 13
+  int m = std::is_constant_evaluated() ? 13 : 17;       // m might be 13 or 17 (see below)
+  char arr[n] = {}; // char[13]
+  return m + sizeof(arr);
+}
+int p = f();                                            // m == 13; initialized to 26
+int q = p + f();                                        // m == 17 for this call; initialized to 56
+\end{codeblock}
+\end{example}
+\end{itemize}
+
 \pnum
 \indextext{expression!potentially constant evaluated}%
 An expression is \defn{potentially constant evaluated}

source/support.tex

@@ -599,6 +599,8 @@
   \tcode{<functional>} \\ \rowsep
 \defnlibxname{cpp_lib_is_aggregate}                         & \tcode{201703L} &
   \tcode{<type_traits>} \\ \rowsep
+\defnlibxname{cpp_lib_is_constant_evaluated}                & \tcode{201811L} &
+  \tcode{<type_traits>} \\ \rowsep
 \defnlibxname{cpp_lib_is_final}                             & \tcode{201402L} &
   \tcode{<type_traits>} \\ \rowsep
 \defnlibxname{cpp_lib_is_invocable}                         & \tcode{201703L} &

source/utilities.tex

@@ -15744,6 +15744,9 @@
     inline constexpr bool disjunction_v = disjunction<B...>::value;
   template<class B>
     inline constexpr bool negation_v = negation<B>::value;
+
+  // \ref{meta.is_constant_evaluated}, constexpr evaluation
+  constexpr bool is_constant_evaluated() noexcept;
 }
 \end{codeblock}
 
@@ -17394,6 +17397,29 @@
 to either \tcode{endian::big} or \tcode{endian::little}.
 \end{itemdescr}
 
+\rSec2[meta.is_constant_evaluated]{Constexpr evaluation context}
+\begin{itemdecl}
+constexpr bool is_constant_evaluation() noexcept;
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\returns \tcode{true} if and only if evaluation of the call occurs
+within the evaluation of an expression or conversion
+that is manifestly constant-evaluated\iref{expr.const}.
+
+\pnum
+\begin{example}
+constexpr void f(unsigned char *p, int n) {
+  if (std::is_constant_evaluated()) {           // should not be a constexpr if statement
+    for (int k = 0; k<n; ++k) p[k] = 0;
+  } else {
+    memset(p, 0, n);                          // not a core constant expression
+  }
+}
+\end{example}
+\end{itemdescr}
+
 \rSec1[ratio]{Compile-time rational arithmetic}
 
 \rSec2[ratio.general]{In general}