[libcxx] Add support for std::reinterpret_pointer_cast

[ldionne]

Summary

Add the implementation of std::reinterpret_pointer_cast.

[mclow.lists]

You have no tests.
If you had tests, you would probably have noticed that you typed _UP when you meant _Up

[MU001999]

Fix UP to Up

[mclow.lists]

Still no tests. This will not be committed w/o tests.

[MU001999]

Add the test

[ldionne]

It looks like this has been implemented in ce195fb22b542c20745e3ed46d1516e8b4e3a76f.

[ldionne]

@MU001999 I'm sorry we were not quicker to review this one, and look forward to doing better on your future contributions.

include/memory

     shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const& r) noexcept;
 template<class T, class U>
     shared_ptr<T> const_pointer_cast(shared_ptr<U> const& r) noexcept;
+template<class T, class U>
+    shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U> const& r) noexcept;
 
 // shared_ptr I/O:
 template<class E, class T, class Y>

     return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
 }
 
+template<class _Tp, class _Up>
+shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
+{
+    return shared_ptr<_Tp>(__r, reinterpret_cast<_Tp*>(__r.get()));
+}
+
 #ifndef _LIBCPP_NO_RTTI
 
 template<class _Dp, class _Tp>

test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.cast/reinterpret_pointer_cast.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
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+
+// shared_ptr
+
+// template<class T, class U> shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r);
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+
+#include "test_macros.h"
+
+struct B
+{
+    static int count;
+
+    B() {++count;}
+    B(const B&) {++count;}
+    virtual ~B() {--count;}
+};
+
+int B::count = 0;
+
+struct A
+    : public B
+{
+    static int count;
+
+    A() {++count;}
+    A(const A&) {++count;}
+    ~A() {--count;}
+};
+
+int A::count = 0;
+
+int main(int, char**)
+{
+    {
+        const std::shared_ptr<A> pA(new A);
+        std::shared_ptr<B> pB = std::reinterpret_pointer_cast<B>(pA);
+        assert(pB.get() == pA.get());
+        assert(!pB.owner_before(pA) && !pA.owner_before(pB));
+    }
+    {
+        const std::shared_ptr<B> pA(new A);
+        std::shared_ptr<A> pB = std::reinterpret_pointer_cast<A>(pA);
+        assert(pB.get() == pA.get());
+        assert(!pB.owner_before(pA) && !pA.owner_before(pB));
+    }
+    {
+        const std::shared_ptr<A> pA;
+        std::shared_ptr<B> pB = std::reinterpret_pointer_cast<B>(pA);
+        assert(pB.get() == pA.get());
+        assert(!pB.owner_before(pA) && !pA.owner_before(pB));
+    }
+    {
+        const std::shared_ptr<B> pA;
+        std::shared_ptr<A> pB = std::reinterpret_pointer_cast<A>(pA);
+        assert(pB.get() == pA.get());
+        assert(!pB.owner_before(pA) && !pA.owner_before(pB));
+    }
+
+  return 0;
+}