Merge 2019-07 CWG Motion 25

P0784R7 More constexpr containers

Fixes #3004.

Author: zygoloid

source/basic.tex

@@ -4540,7 +4540,7 @@
 \item a possibly cv-qualified class type\iref{class} that
 has all of the following properties:
 \begin{itemize}
-\item it has a trivial destructor,
+\item it has a constexpr destructor\iref{dcl.constexpr},
 \item it is either a closure type\iref{expr.prim.lambda.closure},
 an aggregate type\iref{dcl.init.aggr}, or
 has at least one constexpr constructor or constructor template

source/classes.tex

@@ -2144,7 +2144,12 @@
 A prospective destructor shall take no arguments\iref{dcl.fct}.
 Each \grammarterm{decl-specifier} of the \grammarterm{decl-specifier-seq}
 of a prospective destructor declaration (if any)
-shall be \tcode{friend}, \tcode{inline}, or \tcode{virtual}.
+shall be
+\tcode{friend},
+\tcode{inline},
+\tcode{virtual},
+\tcode{constexpr}, or
+\tcode{consteval}.
 
 \pnum
 \indextext{generated destructor|see{destructor, default}}%
@@ -2234,6 +2239,13 @@
 Otherwise, the destructor is
 \defnx{non-trivial}{destructor!non-trivial}.
 
+\pnum
+The defaulted destructor is a constexpr destructor
+if it satisfies the requirements for a constexpr destructor\iref{dcl.constexpr}.
+\begin{note}
+In particular, a trivial destructor is a constexpr destructor.
+\end{note}
+
 \pnum
 A destructor
 that is defaulted and not defined as deleted

source/declarations.tex

@@ -814,12 +814,9 @@
 
 \pnum
 A \tcode{constexpr} or \tcode{consteval} specifier
-used in the declaration of a function that is not a constructor
+used in the declaration of a function
 declares that function to be
 a \defnx{constexpr function}{specifier!\idxcode{constexpr}!function}.
-Similarly, a \tcode{constexpr} or \tcode{consteval} specifier used in
-a constructor declaration declares that constructor to be
-a \defnx{constexpr constructor}{specifier!\idxcode{constexpr}!constructor}.
 A function or constructor declared with the \tcode{consteval} specifier
 is called an \defn{immediate function}.
 A destructor, an allocation function, or a deallocation function
@@ -833,14 +830,18 @@
 
 \begin{itemize}
 \item
-its return type shall be a literal type;
+its return type (if any) shall be a literal type;
 
 \item
 each of its parameter types shall be a literal type;
 
 \item
 it shall not be a coroutine\iref{dcl.fct.def.coroutine};
 
+\item
+if the function is a constructor or destructor,
+its class shall not have any virtual base classes;
+
 \item
 its \grammarterm{function-body} shall not enclose\iref{stmt.stmt}
 \begin{itemize}
@@ -887,24 +888,10 @@
 
 \pnum
 \indextext{specifier!\idxcode{constexpr}!constructor}%
-The definition of a constexpr constructor shall satisfy the
-following requirements:
-\begin{itemize}
-\item
-the class shall not have any virtual base classes;
-
-\item
-each of the parameter types shall be a literal type.
-\end{itemize}
-
-In addition, either its \grammarterm{function-body} shall be
-\tcode{= delete}, or it shall satisfy the following requirements:
+The definition of a constexpr constructor
+whose \grammarterm{function-body} is not \tcode{= delete}
+shall additionally satisfy the following requirements:
 \begin{itemize}
-\item
-either its \grammarterm{function-body} shall be \tcode{= default}, or the \grammarterm{compound-statement} of its \grammarterm{function-body}
-shall satisfy the requirements for a \grammarterm{function-body} of a
-constexpr function;
-
 \item
 if the class is a union having variant members\iref{class.union}, exactly one of them
 shall be initialized;
@@ -932,6 +919,17 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+The definition of a constexpr destructor
+whose \grammarterm{function-body} is not \tcode{= delete}
+shall additionally satisfy the following requirement:
+\begin{itemize}
+\item
+  for every subobject of class type or
+  (possibly multi-dimensional) array thereof,
+  that class type shall have a constexpr destructor.
+\end{itemize}
+
 \pnum
 For a constexpr function or constexpr constructor
 that is neither defaulted nor a template,
@@ -966,12 +964,12 @@
 template
 or member function of a class template
 would fail to satisfy the requirements for a constexpr
-function or constexpr constructor,
-that specialization is still a constexpr function or constexpr
-constructor, even though a call to such a function cannot appear in a constant
+function,
+that specialization is still a constexpr function,
+even though a call to such a function cannot appear in a constant
 expression. If no specialization of the template would satisfy the
-requirements for a constexpr function or constexpr constructor
-when considered as a non-template function or constructor, the template is
+requirements for a constexpr function
+when considered as a non-template function, the template is
 ill-formed, no diagnostic required.
 
 \pnum
@@ -987,7 +985,7 @@
 
 \pnum
 The \tcode{constexpr} and \tcode{consteval} specifiers have no
-effect on the type of a constexpr function or a constexpr constructor.
+effect on the type of a constexpr function.
 \begin{example}
 \begin{codeblock}
 constexpr int bar(int x, int y)         // OK
@@ -1007,6 +1005,7 @@
 In any \tcode{constexpr} variable declaration,
 the full-expression of the initialization
 shall be a constant expression\iref{expr.const}.
+A \tcode{constexpr} variable shall have constant destruction.
 \begin{example}
 \begin{codeblock}
 struct pixel {

source/expressions.tex

@@ -4894,7 +4894,19 @@
 An implementation is allowed to omit a call to a replaceable global allocation
 function~(\ref{new.delete.single}, \ref{new.delete.array}). When it does so,
 the storage is instead provided by the implementation or provided by extending
-the allocation of another \grammarterm{new-expression}. The implementation may
+the allocation of another \grammarterm{new-expression}.
+
+\pnum
+During an evaluation of a constant expression,
+a call to an allocation function is always omitted.
+\begin{note}
+Only \grammarterm{new-expression}{s} that would otherwise result in
+a call to a replaceable global allocation function
+can be evaluated in constant expressions (see \ref{expr.const}).
+\end{note}
+
+\pnum
+The implementation may
 extend the allocation of a \grammarterm{new-expression} \tcode{e1} to provide
 storage for a \grammarterm{new-expression} \tcode{e2} if the
 following would be true were the allocation not extended:
@@ -6864,26 +6876,22 @@
 \begin{itemize}
 \item
 \tcode{this}\iref{expr.prim.this}, except in a constexpr
-function or a constexpr constructor that is being evaluated as part
+function\iref{dcl.constexpr} that is being evaluated as part
 of \tcode{e};
 
 \item
-an invocation of a function other than
-a constexpr constructor for a literal class,
-a constexpr function,
-or an implicit invocation of a trivial destructor\iref{class.dtor}
+an invocation of a non-constexpr function
 \begin{note} Overload resolution\iref{over.match}
-is applied as usual \end{note};
+is applied as usual.
+\end{note};
 
 \item
-an invocation of an undefined constexpr function or an
-undefined constexpr constructor;
+an invocation of an undefined constexpr function;
 
 \item
-an invocation of an instantiated constexpr function or
-constexpr constructor that fails to satisfy the requirements
-for a constexpr function or
-constexpr constructor\iref{dcl.constexpr};
+an invocation of an instantiated constexpr function
+that fails to satisfy the requirements
+for a constexpr function;
 
 \item
 an invocation of a virtual function\iref{class.virtual}
@@ -6991,9 +6999,6 @@
 \item
 a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast};
 
-\item
-a pseudo-destructor call\iref{expr.prim.id.dtor};
-
 \item
 modification of an object~(\ref{expr.ass}, \ref{expr.post.incr},
 \ref{expr.pre.incr})
@@ -7002,10 +7007,27 @@
 whose lifetime began within the evaluation of \tcode{e};
 
 \item
-a \grammarterm{new-expression}\iref{expr.new};
+a \grammarterm{new-expression}\iref{expr.new},
+unless the selected allocation function is
+a replaceable global allocation function~(\ref{new.delete.single},
+\ref{new.delete.array}) and
+the allocated storage is deallocated within the evaluation of \tcode{e};
+
+\item
+a \grammarterm{delete-expression}\iref{expr.delete},
+unless it deallocates a region of storage
+allocated within the evaluation of \tcode{e};
+
+\item
+a call to an instance of
+\tcode{std::allocator<T>::allocate}\iref{allocator.members},
+unless the allocated storage is deallocated within the evaluation of \tcode{e};
 
 \item
-a \grammarterm{delete-expression}\iref{expr.delete};
+a call to an instance of
+\tcode{std::allocator<T>::deallocate}\iref{allocator.members},
+unless it deallocates a region of storage
+allocated within the evaluation of \tcode{e};
 
 \item
 an \grammarterm{await-expression}\iref{expr.await};
@@ -7076,6 +7098,50 @@
 \end{codeblock}
 \end{example}
 
+\pnum
+For the purposes of determining
+whether an expression is a core constant expression,
+the evaluation of a call to a member function of \tcode{std::allocator<T>}
+as defined in \ref{allocator.members}, where \tcode{T} is a literal type,
+does not disqualify the expression from being a core constant expression,
+even if the actual evaluation of such a call
+would otherwise fail the requirements for a core constant expression.
+Similarly, the evaluation of a call to
+\tcode{std::destroy_at},
+\tcode{std::ranges::destroy_at},
+\tcode{std::construct_at}, or
+\tcode{std::ranges::construct_at}
+is a valid core constant expression unless:
+\begin{itemize}
+\item
+  for a call to \tcode{std::construct_at} or \tcode{std::ranges::construct_at},
+  the first argument, of type \tcode{T*},
+  does not point to storage allocated with \tcode{std::allocator<T>} or
+  the evaluation of the underlying constructor call
+  is not a core constant expression, or
+\item
+  for a call to \tcode{std::destroy_at} or \tcode{std::ranges::destroy_at},
+  the first argument, of type \tcode{T*},
+  does not point to storage allocated with \tcode{std::allocator<T>} or
+  the evaluation of the underlying destructor call
+  is not a core constant expression.
+\end{itemize}
+
+\pnum
+An object \tcode{a} is said to have \defnadj{constant}{destruction} if:
+\begin{itemize}
+\item
+  it is not of class type nor (possibly multi-dimensional) array thereof, or
+\item
+  it is of class type or (possibly multi-dimensional) array thereof,
+  that class type has a constexpr destructor, and
+  for a hypothetical expression \tcode{e}
+  whose only effect is to destroy \tcode{a},
+  \tcode{e} would be a core constant expression
+  if the lifetime of \tcode{a} and its non-mutable subobjects
+  (but not its mutable subobjects) were considered to start within \tcode{e}.
+\end{itemize}
+
 \pnum
 An \defnadj{integral constant}{expression}
 is an expression of integral or

source/preprocessor.tex

@@ -1669,6 +1669,7 @@
 \defnxname{cpp_char8_t}                           & \tcode{201811L} \\ \rowsep
 \defnxname{cpp_conditional_explicit}              & \tcode{201806L} \\ \rowsep
 \defnxname{cpp_constexpr}                         & \tcode{201907L} \\ \rowsep
+\defnxname{cpp_constexpr_dynamic_alloc}           & \tcode{201907L} \\ \rowsep
 \defnxname{cpp_constinit}                         & \tcode{201907L} \\ \rowsep
 \defnxname{cpp_coroutines}                        & \tcode{201902L} \\ \rowsep
 \defnxname{cpp_decltype}                          & \tcode{200707L} \\ \rowsep

source/support.tex

@@ -574,6 +574,8 @@
   \tcode{<string_view>} \tcode{<tuple>} \tcode{<utility>} \\ \rowsep
 \defnlibxname{cpp_lib_constexpr_swap_algorithms}            & \tcode{201806L} &
   \tcode{<algorithm>} \\ \rowsep
+\defnlibxname{cpp_lib_constexpr_dynamic_alloc}              & \tcode{201907L} &
+  \tcode{<memory>} \\ \rowsep
 \defnlibxname{cpp_lib_destroying_delete}                    & \tcode{201806L} &
   \tcode{<new>} \\ \rowsep
 \defnlibxname{cpp_lib_enable_shared_from_this}              & \tcode{201603L} &