[libc++][PMR] Deprecate the implementation in std::experimental

[philnik]

Summary

This commit deprecates <experimental/memory_resource> since we now ship the non-experimental
version of it. Per the libc++ policy [1], we are deprecating the experimental feature in
upcoming LLVM 16 and will remove it entirely in LLVM 18.

[1]: https://libcxx.llvm.org/DesignDocs/ExperimentalFeatures.html#id4

[Mordante]

Thanks for patch! Please update the release notes with this deprecation.

[ldionne]

LGTM but I agree we need to add a release note.

[philnik]

• Rebased
• Added release note

[philnik]

Rebased

[EricWF]

Needs description.

Do not commit without one.

The description should include *why* these were deprecated, (so mention the policy, or the bit of the standard that deprecates them.)

[philnik]

Rebased

[ldionne]

LGTM w/ a suggested rewording of the release note. Thanks for adding a link to the policy in the commit message. Also, the commit message could be reworded to

This commit deprecates <experimental/memory_resource> since we now ship the non-experimental
version of it. Per the libc++ policy [1], we are deprecating the experimental feature in
upcoming LLVM 16 and will remove it entirely in LLVM 18.

[1]: https://libcxx.llvm.org/DesignDocs/ExperimentalFeatures.html#id4

This should minimize the amount of work that someone has to do in order to understand what's the change and the context around it.

libcxx/docs/ReleaseNotes.rst

95–96

libcxx/docs/ReleaseNotes.rst

- The functions ``to_chars`` and ``from_chars`` for integral types are
   available starting with C++17. Libc++ offered these functions in C++11 and
   C++14 as an undocumented extension. This extension makes it hard to implement
   the C++23 paper that makes these functions ``constexpr``, therefore the
   extension has been removed.
 
 - The ``_LIBCPP_ENABLE_CXX03_FUNCTION`` macro that allowed re-enabling the now-deprecated C++03 implementation of
   ``std::function`` has been removed. Users who need to use ``std::function`` should switch to C++11 and above.
 
+- The contents of ``<experimental/memory_resource>`` are now deprecated. Use ``<memory_resource>`` instead.
+  The implementation in ``<experimental/memory_resource>`` will be removed in LLVM 18.
+
 Upcoming Deprecations and Removals
 ----------------------------------
 
 API Changes
 -----------
 - The comparison operators on ``thread::id`` are now defined as free-standing
   functions instead of as hidden friends, in conformance with the C++ standard.
   Also see `issue 56187 <https://github.com/llvm/llvm-project/issues/56187>`_.

libcxx/include/experimental/memory_resource

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
+#define _LIBCPP_DEPCREATED_MEMORY_RESOURCE(name)                                                                       \
+  _LIBCPP_DEPRECATED_("'std::experimental::pmr::" name                                                                 \
+                      "' is deprecated and will be removed in LLVM 18. Use 'std::pmr::" name "' instead.")
+
 #ifndef _LIBCPP_CXX03_LANG
 
 // Round __s up to next multiple of __a.
 inline _LIBCPP_INLINE_VISIBILITY
 size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
 {
     _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
     return (__s + __a - 1) & ~(__a - 1);
 }
 
 // 8.5, memory.resource
-class _LIBCPP_TYPE_VIS memory_resource
+class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("memory_resource") _LIBCPP_TYPE_VIS memory_resource
 {
     static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
 
 // 8.5.2, memory.resource.public
 public:
     virtual ~memory_resource() = default;
 
     _LIBCPP_INLINE_VISIBILITY

 // 8.5.3, memory.resource.priv
 private:
     virtual void* do_allocate(size_t, size_t) = 0;
     virtual void do_deallocate(void*, size_t, size_t) = 0;
     virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
 };
 
 // 8.5.4, memory.resource.eq
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(memory_resource const & __lhs,
                 memory_resource const & __rhs) _NOEXCEPT
 {
     return &__lhs == &__rhs || __lhs.is_equal(__rhs);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(memory_resource const & __lhs,
                 memory_resource const & __rhs) _NOEXCEPT
 {
     return !(__lhs == __rhs);
 }
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("new_delete_resource()") _LIBCPP_FUNC_VIS
 memory_resource * new_delete_resource() _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("null_memory_resource()") _LIBCPP_FUNC_VIS
 memory_resource * null_memory_resource() _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("get_default_resource()") _LIBCPP_FUNC_VIS
 memory_resource * get_default_resource() _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("set_default_resource()") _LIBCPP_FUNC_VIS
 memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
 
 // 8.6, memory.polymorphic.allocator.class
 
 // 8.6.1, memory.polymorphic.allocator.overview
 template <class _ValueType>
-class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
+class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("polymorphic_allocator") _LIBCPP_TEMPLATE_VIS polymorphic_allocator
 {
 public:
     typedef _ValueType value_type;
 
     // 8.6.2, memory.polymorphic.allocator.ctor
     _LIBCPP_INLINE_VISIBILITY
     polymorphic_allocator() _NOEXCEPT
       : __res_(_VSTD_LFTS_PMR::get_default_resource())
size_t __max_size() const _NOEXCEPT
         { return numeric_limits<size_t>::max() / sizeof(value_type); }
 
     memory_resource * __res_;
 };
 
 // 8.6.4, memory.polymorphic.allocator.eq
 
 template <class _Tp, class _Up>
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(const polymorphic_allocator&, const polymorphic_allocator&)")
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(polymorphic_allocator<_Tp> const & __lhs,
                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
 {
     return *__lhs.resource() == *__rhs.resource();
 }
 
 template <class _Tp, class _Up>
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(const polymorphic_allocator&, const polymorphic_allocator&)")
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
                 polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
 {
     return !(__lhs == __rhs);
 }
 
 // 8.7, memory.resource.adaptor
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 // 8.7.1, memory.resource.adaptor.overview
 template <class _CharAlloc>
 class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
   : public memory_resource
 {
     using _CTraits = allocator_traits<_CharAlloc>;
     static_assert(is_same<typename _CTraits::value_type, char>::value
                && is_same<typename _CTraits::pointer, char*>::value
size_t __max_size() const _NOEXCEPT {
         return numeric_limits<size_t>::max() - _MaxAlign;
     }
 };
 
 template <class _Alloc>
 using resource_adaptor = __resource_adaptor_imp<
     typename allocator_traits<_Alloc>::template rebind_alloc<char>
   >;
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20

libcxx/include/experimental/regex

 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _BiDirIter>
 using match_results =
     _VSTD::match_results<_BiDirIter,
         polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>;
 
-typedef match_results<const char*> cmatch;
-typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("cmatch") typedef match_results<const char*> cmatch;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("smatch") typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef match_results<const wchar_t*> wcmatch;
-typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wcmatch") typedef match_results<const wchar_t*> wcmatch;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wsmatch") typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
 #endif
 
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_REGEX */

libcxx/include/experimental/string

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
 
 #ifndef _LIBCPP_CXX03_LANG
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+
 template <class _CharT, class _Traits = char_traits<_CharT>>
 using basic_string =
     _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
 
-typedef basic_string<char> string;
-typedef basic_string<char16_t> u16string;
-typedef basic_string<char32_t> u32string;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("string") typedef basic_string<char> string;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u16string") typedef basic_string<char16_t> u16string;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u32string") typedef basic_string<char32_t> u32string;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef basic_string<wchar_t> wstring;
+_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wstring") typedef basic_string<wchar_t> wstring;
 #endif
 
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_LFTS_PMR
 
 #endif /* _LIBCPP_EXPERIMENTAL_STRING */

libcxx/src/experimental/memory_resource.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <experimental/memory_resource>
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+
 #ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
 #  include <atomic>
 #elif !defined(_LIBCPP_HAS_NO_THREADS)
 #  include <mutex>
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif

libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/assert.deallocate.pass.cpp

 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "test_memory_resource.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/libcxx/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // test_memory_resource requires RTTI for dynamic_cast
 // UNSUPPORTED: no-rtti
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2, class ...Args1, class ...Args2>
 // void polymorphic_allocator<T>::construct(pair<T1, T2>*, piecewise_construct_t
 //                                          tuple<Args1...> x, tuple<Args2...>)
 

libcxx/test/libcxx/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/assert.deallocate.pass.cpp

 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: c++03
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{10.9|10.10|10.11|10.12|10.13|10.14|10.15|11.0|12.0}}
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_ASSERTIONS=1
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "test_memory_resource.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/libcxx/experimental/memory/memory.resource.global/global_memory_resource_lifetime.pass.cpp

 
 // memory_resource * new_delete_resource()
 
 // The lifetime of the value returned by 'new_delete_resource()' should
 // never end, even very late into program termination. This test constructs
 // attempts to use 'new_delete_resource()' very late in program termination
 // to detect lifetime issues.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 

libcxx/test/libcxx/experimental/memory/memory.resource.global/new_delete_resource_lifetime.pass.cpp

 
 // memory_resource * new_delete_resource()
 
 // The lifetime of the value returned by 'new_delete_resource()' should
 // never end, even very late into program termination. This test constructs
 // attempts to use 'new_delete_resource()' very late in program termination
 // to detect lifetime issues.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator operator=(polymorphic_allocator const &) = delete
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**)
 {
     typedef ex::polymorphic_allocator<void> T;
     static_assert(!std::is_copy_assignable<T>::value, "");
     static_assert(!std::is_move_assignable<T>::value, "");
 
   return 0;
 }

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator const &);
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/default.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator() noexcept
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/memory_resource_convert.pass.cpp

 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator<T>::polymorphic_allocator(memory_resource *)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.ctor/other_alloc.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U>
 // polymorphic_allocator<T>::polymorphic_allocator(polymorphic_allocator<U> const &);
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/equal.pass.cpp

 
 // template <class T> class polymorphic_allocator;
 
 // template <class T, class U>
 // bool operator==(
 //      polymorphic_allocator<T> const &
 //    , polymorphic_allocator<U> const &) noexcept
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.eq/not_equal.pass.cpp

 
 // template <class T> class polymorphic_allocator;
 
 // template <class T>
 // bool operator!=(
 //      polymorphic_allocator<T> const &
 //    , polymorphic_allocator<T> const &) noexcept
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/allocate.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::allocate(size_t n)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <limits>
 #include <memory>
 #include <exception>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 #include "uses_alloc_types.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> const&)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, pair<U1, U2> &&)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class P1, class P2, class U1, class U2>
 // void polymorphic_allocator<T>::construct(pair<P1, P2>*, U1&&, U2&&)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2, class ...Args1, class ...Args2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
 //                                          tuple<Args1...>, tuple<Args2...>)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <utility>
 #include <tuple>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp

 // <memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U1, class U2, class ...Args1, class ...Args2>
 // void polymorphic_allocator<T>::construct(pair<U1, U2>*, piecewise_construct_t
 //                                          tuple<Args1...>, tuple<Args2...>)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U, class ...Args>
 // void polymorphic_allocator<T>::construct(U *, Args &&...)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
 #include "test_memory_resource.h"
 #include "uses_alloc_types.h"

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/deallocate.pass.cpp

 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // T* polymorphic_allocator<T>::deallocate(T*, size_t size)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/destroy.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // template <class U>
 // void polymorphic_allocator<T>::destroy(U * ptr);
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <new>
 #include <cassert>
 #include <cstdlib>
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/resource.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // memory_resource *
 // polymorphic_allocator<T>::resource() const
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 

libcxx/test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/select_on_container_copy_construction.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class T> class polymorphic_allocator
 
 // polymorphic_allocator
 // polymorphic_allocator<T>::select_on_container_copy_construction() const
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_copy.pass.cpp

 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc const &)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/alloc_move.pass.cpp

 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp(Alloc &&)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.ctor/default.pass.cpp

 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
 // resource_adaptor_imp<Alloc>::resource_adaptor_imp() = default;
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <memory>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_allocate_and_deallocate.pass.cpp

 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
 // void * do_allocate(size_t size, size_t align)
 // void   do_deallocate(void*, size_t, size_t)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <memory>
 #include <exception>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_memory_resource.h"

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.mem/do_is_equal.pass.cpp

 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
 // bool do_is_equal(memory_resource const &) const noexcept;
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <memory>
 #include <cassert>
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp

 
 // test_memory_resource requires RTTI for dynamic_cast
 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // template <class Alloc> class resource_adaptor_imp;
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_deque_synop.pass.cpp

 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using deque =
 //     ::std::deque<T, polymorphic_allocator<T>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/deque>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_forward_list_synop.pass.cpp

 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using forward_list =
 //     ::std::forward_list<T, polymorphic_allocator<T>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/forward_list>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_list_synop.pass.cpp

 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using list =
 //     ::std::list<T, polymorphic_allocator<T>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/list>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_map_synop.pass.cpp

 //     ::std::map<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
 //
 // template <class K, class V, class Compare = less<Key> >
 // using multimap =
 //     ::std::multimap<K, V, Compare, polymorphic_allocator<pair<const K, V>>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/map>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_regex_synop.pass.cpp

 //
 //  typedef match_results<const char*> cmatch;
 //  typedef match_results<const wchar_t*> wcmatch;
 //  typedef match_results<string::const_iterator> smatch;
 //  typedef match_results<wstring::const_iterator> wsmatch;
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/regex>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;
 

libcxx/test/std/experimental/memory/memory.resource.aliases/header_set_synop.pass.cpp

 //     ::std::set<V, Compare, polymorphic_allocator<V>>
 //
 // template <class V, class Compare = less<V> >
 // using multiset =
 //     ::std::multiset<V, Compare, polymorphic_allocator<V>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/set>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_string_synop.pass.cpp

 //
 // typedef ... string
 // typedef ... u16string
 // typedef ... u32string
 // typedef ... wstring
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/string>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "constexpr_char_traits.h"
 
 #include "test_macros.h"

libcxx/test/std/experimental/memory/memory.resource.aliases/header_unordered_map_synop.pass.cpp

 //     ::std::unordered_map<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
 //
 // template <class K, class V,  class H = hash<K>, class P = equal_to<K> >
 // using unordered_multimap =
 //     ::std::unordered_multimap<K, V, H, P, polymorphic_allocator<pair<const K, V>>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/unordered_map>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_unordered_set_synop.pass.cpp

 //     ::std::unordered_set<V, H, P, polymorphic_allocator<V>>
 //
 // template <class V,  class H = hash<V>, class P = equal_to<V> >
 // using unordered_multiset =
 //     ::std::unordered_multiset<V, H, P, polymorphic_allocator<V>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/unordered_set>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.aliases/header_vector_synop.pass.cpp

 
 // namespace std { namespace experimental { namespace pmr {
 // template <class T>
 // using vector =
 //     ::std::vector<T, polymorphic_allocator<T>>
 //
 // }}} // namespace std::experimental::pmr
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/vector>
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 namespace pmr = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource.global/default_resource.pass.cpp

 
 // Aligned allocation is required by std::experimental::pmr, but it was not provided
 // before macosx10.13 and as a result we get linker errors when deploying to older than
 // macosx10.13.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 //-----------------------------------------------------------------------------
 // TESTING memory_resource * get_default_resource() noexcept;
 //         memory_resource * set_default_resource(memory_resource*) noexcept;
 //
 // Concerns:
 //  A) 'get_default_resource()' returns a non-null memory_resource pointer.
 //  B) 'get_default_resource()' returns the value set by the last call to
 //     'set_default_resource(...)' and 'new_delete_resource()' if no call

libcxx/test/std/experimental/memory/memory.resource.global/new_delete_resource.pass.cpp

 // before macosx10.13 and as a result we get linker errors when deploying to older than
 // macosx10.13.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
 // memory_resource * new_delete_resource()
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.resource.global/null_memory_resource.pass.cpp

 // before macosx10.13 and as a result we get linker errors when deploying to older than
 // macosx10.13.
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // <experimental/memory_resource>
 
 // memory_resource * null_memory_resource()
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 

libcxx/test/std/experimental/memory/memory.resource/construct.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // Check that memory_resource is not constructible
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**)
 {
     ex::memory_resource m; // expected-error {{variable type 'ex::memory_resource' is an abstract class}}
 
   return 0;
 }

libcxx/test/std/experimental/memory/memory.resource/memory.resource.eq/equal.pass.cpp

 
 // test_memory_resource requires RTTI for dynamic_cast
 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // bool operator==(memory_resource const &, memory_resource const &) noexcept;
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_memory_resource.h"
 
 namespace ex = std::experimental::pmr;

libcxx/test/std/experimental/memory/memory.resource/memory.resource.eq/not_equal.pass.cpp

 
 // test_memory_resource requires RTTI for dynamic_cast
 // UNSUPPORTED: no-rtti
 
 // <experimental/memory_resource>
 
 // bool operator!=(memory_resource const &, memory_resource const &) noexcept;
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.resource/memory.resource.priv/private_members.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <experimental/memory_resource>
 
 // memory_resource::do_allocate(size_t, size_t);          /* private */
 // memory_resource::do_deallocate(void*, size_t, size_t); /* private */
 // memory_resource::do_is_equal(memory_resource const&);  /* private */
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**) {
     ex::memory_resource *m = ex::new_delete_resource();
     m->do_allocate(0, 0); // expected-error{{'do_allocate' is a private member}}
     m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a private member}}
     m->do_is_equal(*m); // expected-error{{'do_is_equal' is a private member}}
 
   return 0;
 }

libcxx/test/std/experimental/memory/memory.resource/memory.resource.public/allocate.pass.cpp

 // Concerns:
 //  A) 'memory_resource' contains a member 'allocate' with the required
 //     signature, including the default alignment parameter.
 //  B) The return type of 'allocate' is 'void*'.
 //  C) 'allocate' is not marked as 'noexcept'.
 //  D) Invoking 'allocate' invokes 'do_allocate' with the same arguments.
 //  E) If 'do_allocate' throws then 'allocate' propagates that exception.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_memory_resource.h"
 

libcxx/test/std/experimental/memory/memory.resource/memory.resource.public/deallocate.pass.cpp

 //
 // Concerns:
 //  A) 'memory_resource' contains a member 'deallocate' with the required
 //     signature, including the default alignment parameter.
 //  B) The return type of 'deallocate' is 'void'.
 //  C) 'deallocate' is not marked as 'noexcept'.
 //  D) Invoking 'deallocate' invokes 'do_deallocate' with the same arguments.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cstddef>
 #include <cassert>
 
 #include "test_memory_resource.h"
 

libcxx/test/std/experimental/memory/memory.resource/memory.resource.public/dtor.pass.cpp

 //------------------------------------------------------------------------------
 // TESTING virtual ~memory_resource()
 //
 // Concerns:
 //  A) 'memory_resource' is destructible.
 //  B) The destructor is implicitly marked noexcept.
 //  C) The destructor is marked virtual.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 

libcxx/test/std/experimental/memory/memory.resource/memory.resource.public/is_equal.pass.cpp

 // Concerns:
 //   A) 'memory_resource' provides a function 'is_equal' with the required
 //      signature.
 //   B) 'is_equal' is noexcept.
 //   C) 'do_is_equal' is called using the same arguments passed to 'is_equal'
 //      and the resulting value is returned.
 //   D) 'do_is_equal' is called on the LHS object and not the RHS object.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <experimental/memory_resource>
 #include <type_traits>
 #include <cassert>
 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 
 using std::experimental::pmr::memory_resource;