Index: docs/UsingLibcxx.rst =================================================================== --- docs/UsingLibcxx.rst +++ docs/UsingLibcxx.rst @@ -248,6 +248,14 @@ warning saying that `std::auto_ptr` is deprecated. If the macro is defined, no warning will be emitted. By default, this macro is not defined. +**_LIBCPP_ENABLE_DESTROYING_DELETE_EXT**: + This macro enables library support for C++20's destroying delete as an extension in older dialects. + When the macro is enabled, ```` always declares ``std::destroying_delete_t`` and + ``std::destroying_delete``. Note that the compiler must also support destroying delete as an + extension in order for the language feature to actually be used. All versions of Clang that support + destroying delete support using it in older dialects. + + C++17 Specific Configuration Macros ----------------------------------- **_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES**: Index: include/new =================================================================== --- include/new +++ include/new @@ -33,6 +33,10 @@ }; enum class align_val_t : size_t {}; // C++17 +struct destroying_delete_t { + explicit destroying_delete_t() = default; +}; +inline constexpr destroying_delete_t destroying_delete{}; struct nothrow_t {}; extern const nothrow_t nothrow; typedef void (*new_handler)(); @@ -158,6 +162,23 @@ #endif #endif +#if _LIBCPP_STD_VER > 17 || defined(_LIBCPP_ENABLE_DESTROYING_DELETE_EXT) +struct destroying_delete_t { +#ifndef _LIBCPP_CXX03_LANG + explicit destroying_delete_t() = default; +#endif +}; +#ifndef _LIBCPP_CXX03_LANG +_LIBCPP_INLINE_VAR constexpr destroying_delete_t destroying_delete{}; +#else +const destroying_delete_t destroying_delete = {}; +#endif + +#if defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L +#define __cpp_lib_destroying_delete 201806L +#endif +#endif // _LIBCPP_HAS_NO_LIBRARY_DESTROYING_DELETE + } // std #if defined(_LIBCPP_CXX03_LANG) Index: test/libcxx/language.support/support.dynamic/destroying_delete_extension.pass.cpp =================================================================== --- /dev/null +++ test/libcxx/language.support/support.dynamic/destroying_delete_extension.pass.cpp @@ -0,0 +1,95 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Test that when _LIBCPP_ENABLE_DESTROYING_DELETE_EXT is defined the library +// declares `std::destroying_delete_t` and `std::destroying_delete`. +// Additionally test that when the compiler supports destroying delete as an +// extension, then destroying delete works as if it were C++20 + +// MODULES_DEFINES: _LIBCPP_ENABLE_DESTROYING_DELETE_EXT +#define _LIBCPP_ENABLE_DESTROYING_DELETE_EXT + +#include + +#include +#include "test_macros.h" +#if TEST_STD_VER >= 11 +#include "test_convertible.hpp" +#endif + +struct A { + void *data; + A(); + ~A(); + + static A* New(); + void operator delete(A*, std::destroying_delete_t); +}; + +bool A_constructed = false; +bool A_destroyed = false; +bool A_destroying_deleted = false; + +A::A() { + A_constructed = true; +} + +A::~A() { + A_destroyed = true; +} + +A* A::New() { + return new(::operator new(sizeof(A))) A(); +} + +void A::operator delete(A* a, std::destroying_delete_t) { + A_destroying_deleted = true; + ::operator delete(a); +} + +// Test that we only define __cpp_lib_destroying_delete when the compiler +// provides the extension too. +#ifdef __cpp_impl_destroying_delete +# ifndef __cpp_lib_destroying_delete +# error "Expected __cpp_lib_destroying_delete to be defined" +# elif __cpp_lib_destroying_delete < 201806L +# error "Unexpected value of __cpp_lib_destroying_delete" +# endif +#endif // !defined(__cpp_impl_destroying_delete) + + + +void test_destroying_delete_library_extension() { + ASSERT_SAME_TYPE(decltype(std::destroying_delete), const std::destroying_delete_t); + static_assert(std::is_default_constructible::value, ""); +#if TEST_STD_VER > 03 + constexpr auto copy = std::destroying_delete; + ((void)copy); + static_assert(!test_convertible(), ""); +#endif +} + +void test_destroying_delete_language_extension() { + // Ensure that we call the destroying delete and not the destructor. + A* ap = A::New(); + assert(A_constructed); + delete ap; +#ifdef __cpp_lib_destroying_delete + assert(!A_destroyed); + assert(A_destroying_deleted); +#else + assert(A_destroyed); + assert(!A_destroying_deleted); +#endif +} + +int main() { + test_destroying_delete_library_extension(); + test_destroying_delete_language_extension(); +} Index: test/std/language.support/support.dynamic/destroying_delete_t.pass.cpp =================================================================== --- /dev/null +++ test/std/language.support/support.dynamic/destroying_delete_t.pass.cpp @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// struct destroying_delete_t { +// explicit destroying_delete_t() = default; +// }; +// inline constexpr destroying_delete_t destroying_delete{}; + +// UNSUPPORTED: c++98, c++03 + +#include + +#include +#include "test_macros.h" + +struct A { + void *data; + A(); + ~A(); + + static A* New(); + void operator delete(A*, std::destroying_delete_t); +}; + +bool A_constructed = false; +bool A_destroyed = false; +bool A_destroying_deleted = false; + +A::A() { + A_constructed = true; +} + +A::~A() { + A_destroyed = true; +} + +A* A::New() { + return new(::operator new(sizeof(A))) A(); +} + +void A::operator delete(A* a, std::destroying_delete_t) { + A_destroying_deleted = true; + ::operator delete(a); +} + +#ifndef __cpp_lib_destroying_delete +#error "Expected __cpp_lib_destroying_delete to be defined" +#elif __cpp_lib_destroying_delete < 201806L +#error "Unexpected value of __cpp_lib_destroying_delete" +#endif + +int main() { + // Ensure that we call the destroying delete and not the destructor. + A* ap = A::New(); + assert(A_constructed); + delete ap; + assert(!A_destroyed); + assert(A_destroying_deleted); +}