This patch resolves issue 2724.

[zoecarver]

Summary

I did not mark it complete in the status because I have only updated the
expiremental library thus far.

[zoecarver]

Ping :)

[zoecarver]

@ldionne ping. This is a super simple patch.

[ldionne]

This went under the radar.

[zoecarver]

I also renamed protected_members.fail.cpp to private_members.fail.cpp.

libcxx/include/experimental/memory_resource

public:
     void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
         { do_deallocate(__p, __bytes, __align); }
 
     _LIBCPP_INLINE_VISIBILITY
     bool is_equal(memory_resource const & __other) const _NOEXCEPT
         { return do_is_equal(__other); }
 
 // 8.5.3, memory.resource.priv
-protected:
+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
 bool operator==(memory_resource const & __lhs,
public:
     __resource_adaptor_imp &
     operator=(__resource_adaptor_imp const &) = default;
 
     _LIBCPP_INLINE_VISIBILITY
     allocator_type get_allocator() const
     { return __alloc_; }
 
 // 8.7.3, memory.resource.adaptor.mem
-protected:
+private:
     virtual void * do_allocate(size_t __bytes, size_t)
     {
         if (__bytes > __max_size()) {
             __throw_length_error(
                 "std::experimental::pmr::resource_adaptor<T>::do_allocate(size_t bytes, size_t align)"
                 " 'bytes' exceeds maximum supported size");
         }
         size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
private:
     }
 
     virtual bool do_is_equal(memory_resource const & __other) const _NOEXCEPT {
         __resource_adaptor_imp const * __p
           = dynamic_cast<__resource_adaptor_imp const *>(&__other);
         return __p  ? __alloc_ == __p->__alloc_ : false;
     }
 
-private:
     _LIBCPP_INLINE_VISIBILITY
     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_END_NAMESPACE_LFTS_PMR
 
 _LIBCPP_POP_MACROS
 
 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */

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);          /* protected */
-// memory_resource::do_deallocate(void*, size_t, size_t); /* protected */
-// memory_resource::do_is_equal(memory_resource const&);  /* protected */
+// 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 */
 
 #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 protected member}}
-    m->do_deallocate(nullptr, 0, 0); // expected-error{{'do_deallocate' is a protected member}}
-    m->do_is_equal(*m); // expected-error{{'do_is_equal' is a protected member}}
+    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;
 }