Merge 2018-06 CWG Motion 10

Fixes #2122

Author: zygoloid

source/basic.tex

@@ -3360,36 +3360,47 @@
 declared in a namespace scope other than global scope or declared static
 in global scope.
 
+\pnum
+A deallocation function
+is a \defn{destroying operator delete}
+if it has at least two parameters
+and its second parameter
+is of type \tcode{std::destroying_delete_t}.
+A destroying operator delete
+shall be a class member function named \tcode{operator delete}.
+\begin{note}
+Array deletion cannot use a destroying operator delete.
+\end{note}
+
 \pnum
 \indextext{\idxcode{delete}!overloading and}%
-Each deallocation function shall return \tcode{void} and its first
+Each deallocation function shall return \tcode{void}.
+If the function is a destroying operator delete
+declared in class type \tcode{C},
+the type of its first parameter shall be \tcode{C*};
+otherwise, the type of its first
 parameter shall be \tcode{void*}. A deallocation function may have more
 than one parameter.
 \indextext{deallocation function!usual}%
-A \defn{usual deallocation function} is a deallocation function that has:
+A \defn{usual deallocation function} is a deallocation function
+whose parameters after the first are
 \begin{itemize}
 \item
-exactly one parameter; or
+optionally, a parameter of type \tcode{std::destroying_delete_t}, then
 \item
-exactly two parameters,
-the type of the second being either
-\tcode{std::align_val_t} or
-\tcode{std::size_t}%
+optionally, a parameter of type \tcode{std::size_t}%
 \footnote{The global \tcode{operator delete(void*, std::size_t)}
 precludes use of an
 allocation function \tcode{void operator new(std::size_t, std::size_t)} as a placement
-allocation function~(\ref{diff.cpp11.basic}).}; or
+allocation function~(\ref{diff.cpp11.basic}).}, then
 \item
-exactly three parameters,
-the type of the second being \tcode{std::size_t}
-and
-the type of the third being \tcode{std::align_val_t}.
+optionally, a parameter of type \tcode{std::align_val_t}.
 \end{itemize}
+A destroying operator delete shall be a usual deallocation function.
 A deallocation function may be an instance of a function
 template. Neither the first parameter nor the return type shall depend
-on a template parameter. \begin{note} That is, a deallocation function
-template shall have a first parameter of type \tcode{void*} and a return
-type of \tcode{void} (as specified above). \end{note} A deallocation
+on a template parameter.
+A deallocation
 function template shall have two or more function parameters. A template
 instance is never a usual deallocation function, regardless of its
 signature.

source/expressions.tex

@@ -4310,7 +4310,10 @@
 \pnum
 \indextext{\idxcode{delete}!undefined}%
 In a single-object delete expression, if the static type of the object to be
-deleted is different from its dynamic type, the static type shall be a base
+deleted is different from its dynamic type
+and the selected deallocation function (see below)
+is not a destroying operator delete,
+the static type shall be a base
 class of the dynamic type of the object to be deleted and the static type shall
 have a virtual destructor or the behavior is undefined. In an array delete
 expression, if the dynamic type of the object to be deleted differs from its
@@ -4329,7 +4332,10 @@
 \pnum
 \indextext{\idxcode{delete}!destructor and}%
 If the value of the operand of the \grammarterm{delete-expression} is not a
-null pointer value, the \grammarterm{delete-expression} will invoke the
+null pointer value
+and the selected deallocation function (see below)
+is not a destroying operator delete,
+the \grammarterm{delete-expression} will invoke the
 destructor (if any) for the object or the elements of the array being
 deleted. In the case of an array, the elements will be destroyed in
 order of decreasing address (that is, in reverse order of the completion
@@ -4395,19 +4401,25 @@
 the function to be called is selected as follows:
 \begin{itemize}
 \item
+If any of the deallocation functions is a destroying operator delete,
+all deallocation functions that are not destroying operator deletes
+are eliminated from further consideration.
+\item
 If the type has new-extended alignment,
 a function with a parameter of type \tcode{std::align_val_t} is preferred;
 otherwise a function without such a parameter is preferred.
-If exactly one preferred function is found,
-that function is selected and the selection process terminates.
-If more than one preferred function is found,
+If any preferred functions are found,
 all non-preferred functions are eliminated from further consideration.
 \item
+If exactly one function remains,
+that function is selected and the selection process terminates.
+\item
 If the deallocation functions have class scope,
 the one without a parameter of type \tcode{std::size_t} is selected.
 \item
-If the type is complete and if, for the second alternative (delete
-array) only, the operand is a pointer to a class type with a
+If the type is complete
+and if, for an array delete expression only,
+the operand is a pointer to a class type with a
 non-trivial destructor or a (possibly multi-dimensional) array thereof,
 the function with a parameter of type \tcode{std::size_t} is selected.
 \item
@@ -4417,31 +4429,54 @@
 \end{itemize}
 
 \pnum
+For a single-object delete expression,
+the deleted object is
+the object denoted by the operand
+if its static type does not have a virtual destructor,
+and its most-derived object otherwise.
+\begin{note}
+If the deallocation function is not a destroying operator delete
+and the deleted object is not the most derived object in the former case,
+the behavior is undefined,
+as stated above.
+\end{note}
+For an array delete expression,
+the deleted object is
+the array object.
 When a \grammarterm{delete-expression}
 is executed, the selected deallocation function shall be called with
-the address of the most-derived object in a single-object delete expression, or
-the address of the object suitably adjusted for the array allocation
+the address of the deleted object
+in a single-object delete expression, or
+the address of the deleted object
+suitably adjusted for the array allocation
 overhead\iref{expr.new} in an array delete expression,
 as its first argument.
+\begin{note}
+Any cv-qualifiers in the type of the deleted object
+are ignored when forming this argument.
+\end{note}
+If a destroying operator delete is used,
+an unspecified value
+is passed as the argument
+corresponding to the parameter of type \tcode{std::destroying_delete_t}.
 If a deallocation function
 with a parameter of type \tcode{std::align_val_t}
 is used,
-the alignment of the type of the object to be deleted
+the alignment of the type of the deleted object
 is passed as the corresponding argument.
 If a deallocation function
 with a parameter of type \tcode{std::size_t} is used,
-the size
-of the most-derived type, or
-of the array plus allocation overhead, respectively,
-is passed as the corresponding argument.%
-\footnote{If the static type of the object to be deleted is complete
-and is different from the dynamic type, and the destructor is not virtual, the size might
-be incorrect, but that case is already undefined, as stated above.}
+the size of the deleted object
+in a single-object delete expression, or
+of the array plus allocation overhead
+in an array delete expression,
+is passed as the corresponding argument.
 \begin{note}
-If this results in a call to a usual deallocation function, and either
+If this results in a call to a replaceable deallocation function,
+and either
 the first argument was not the result of
-a prior call to a usual allocation function or
-the second argument was not the corresponding argument in said call,
+a prior call to a replaceable allocation function or
+the second or third argument was not the corresponding argument in said call,
 the behavior is undefined~(\ref{new.delete.single}, \ref{new.delete.array}).
 \end{note}
 

source/special.tex

@@ -1186,7 +1186,7 @@
 \indextext{\idxcode{delete}!destructor and}%
 \indextext{destructor!explicit call}%
 In each case, the context of the invocation is the context of the construction of
-the object. A destructor is also invoked implicitly through use of a
+the object. A destructor may also be invoked implicitly through use of a
 \grammarterm{delete-expression}\iref{expr.delete} for a constructed object allocated
 by a \grammarterm{new-expression}\iref{expr.new}; the context of the invocation is the
 \grammarterm{delete-expression}.
@@ -1370,8 +1370,8 @@
 \grammarterm{delete-expression}
 is used to deallocate an object of class
 \tcode{T}
-or array thereof, the static and dynamic types of the object shall be
-identical and the deallocation function's name is looked up in the scope of
+or array thereof,
+the deallocation function's name is looked up in the scope of
 \tcode{T}.
 If this lookup fails to find the name, general deallocation function
 lookup\iref{expr.delete} continues.
@@ -1409,8 +1409,8 @@
 \grammarterm{delete-expression}
 refers to an object of class type,
 because the deallocation function actually called is looked up in the scope of
-the class that is the dynamic type of the object,
-if the destructor is virtual, the effect is the same.
+the class that is the dynamic type of the object
+if the destructor is virtual, the effect is the same in that case.
 For example,
 \begin{codeblock}
 struct B {
@@ -1422,15 +1422,30 @@
   void operator delete(void*);
 };
 
+struct E : B {
+  void log_deletion();
+  void operator delete(E *p, std::destroying_delete_t) {
+    p->log_deletion();
+    p->~E();
+    ::operator delete(p);
+  }
+};
+
 void f() {
   B* bp = new D;
   delete bp;        // 1: uses \tcode{D::operator delete(void*)}
+  bp = new E;
+  delete bp;        // 2: uses \tcode{E::operator delete(E*, std::destroying_delete_t)}
 }
 \end{codeblock}
-Here, storage for the non-array object of class
+Here, storage for the object of class
 \tcode{D}
 is deallocated by
 \tcode{D::operator delete()},
+and
+the object of class \tcode{E} is destroyed
+and its storage is deallocated
+by \tcode{E::operator delete()},
 due to the virtual destructor.
 \end{note}
 \begin{note}

source/support.tex

@@ -1822,13 +1822,20 @@
 \rSec2[new.syn]{Header \tcode{<new>} synopsis}
 \indexhdr{new}%
 \indexlibrary{\idxcode{align_val_t}}%
+\indexlibrary{\idxcode{destroying_delete_t}}%
+\indexlibrary{\idxcode{destroying_delete}}%
 \indexlibrary{\idxcode{nothrow_t}}%
 \indexlibrary{\idxcode{nothrow}}%
 \begin{codeblock}
 namespace std {
   class bad_alloc;
   class bad_array_new_length;
 
+  struct destroying_delete_t {
+    explicit destroying_delete_t() = default;
+  };
+  inline constexpr destroying_delete_t destroying_delete{};
+
   enum class align_val_t : size_t {};
 
   struct nothrow_t { explicit nothrow_t() = default; };