[libc++] Fix std::to_address(arr)

[• Quuxplusone]

Summary

There were basically two bugs here:

• When C++20 to_address is called on int arr[10], then const _Ptr& becomes a reference to a const array, and then we dispatch to __to_address<const int(&)[10]>, which, oops, gives us a const int* result instead of an int* result. Solution: We need to provide the two standard-specified overloads of std::to_address in exactly the same way that we provide two overloads of __to_address.
• When __to_address is called on a pointer type, __to_address(const _Ptr&) is disabled so we successfully avoid trying to instantiate pointer_traits of that pointer type. But when it's called on an array type, __to_address(const _Ptr&) is not disabled for array types, so we go ahead and instantiate pointer_traits<int[10]>, which goes boom. Solution: We need to disable __to_address(const _Ptr&) for both pointer and array types.

Maybe we should disable it for function types too? Those are supposed not to work, but it'd affect the wording of the error message we gave. [This has now been done.]

[Mordante]

Maybe we should disable it for function types too? Those are supposed not to work, but it'd affect the wording of the error message we gave.

I think that would be an Quality of Implementation improvement, so I would like to see that change. But not a blocker to land the current fix. LGTM, provided the build passes.

libcxx/include/__memory/pointer_traits.h

171

Looking at this static assert I feel it's intended this assertion's error message should be shown when a function pointer is used.

[• Quuxplusone]

Disable the const _Ptr& overload for function types, as well as array types. Turns out we already got the nice error message for std::to_address(f), but we would give the ugly __pointer_traits_element_type spew if you did std::__to_address(f). This is now fixed, and put a test on it.

[Mordante]

Thanks for the update. LGTM!

libcxx/include/__memory/pointer_traits.h

 // to_address
 
 template <class _Pointer, class = void>
 struct __to_address_helper;
 
 template <class _Tp>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _Tp* __to_address(_Tp* __p) _NOEXCEPT {
     static_assert(!is_function<_Tp>::value, "_Tp is a function type");
     return __p;
 }
 
 // enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
-template <class _Pointer, class = _EnableIf<!is_pointer<_Pointer>::value> >
+template <class _Pointer, class = _EnableIf<
+    !is_pointer<_Pointer>::value && !is_array<_Pointer>::value && !is_function<_Pointer>::value
+> >
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 typename decay<decltype(__to_address_helper<_Pointer>::__call(declval<const _Pointer&>()))>::type
 __to_address(const _Pointer& __p) _NOEXCEPT {
     return __to_address_helper<_Pointer>::__call(__p);
 }
 
 template <class _Pointer, class>
 struct __to_address_helper {
struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))> {
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     static decltype(pointer_traits<_Pointer>::to_address(declval<const _Pointer&>()))
     __call(const _Pointer& __p) _NOEXCEPT {
         return pointer_traits<_Pointer>::to_address(__p);
     }
 };
 
 #if _LIBCPP_STD_VER > 17
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY constexpr
+auto to_address(_Tp *__p) noexcept {
+    return _VSTD::__to_address(__p);
+}
+
 template <class _Pointer>
 inline _LIBCPP_INLINE_VISIBILITY constexpr
 auto to_address(const _Pointer& __p) noexcept {
     return _VSTD::__to_address(__p);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address.pass.cpp

TEST_CONSTEXPR_CXX14 bool test() {
     P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil;
     assert(std::__to_address(p8a) == p8_nil);
     ASSERT_SAME_TYPE(decltype(std::__to_address(p8a)), decltype(p8_nil));
 
     P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil;
     assert(std::__to_address(p8b) == p8_nil);
     ASSERT_SAME_TYPE(decltype(std::__to_address(p8b)), decltype(p8_nil));
 
+    int p9[2] = {};
+    assert(std::__to_address(p9) == p9);
+    ASSERT_SAME_TYPE(decltype(std::__to_address(p9)), int*);
+
+    const int p10[2] = {};
+    assert(std::__to_address(p10) == p10);
+    ASSERT_SAME_TYPE(decltype(std::__to_address(p10)), const int*);
+
     return true;
 }
 
 int main(int, char**) {
     test();
 #if TEST_STD_VER >= 14
     static_assert(test(), "");
 #endif
     return 0;
 }

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address_on_funcptr.verify.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>
+
+// template <class T> constexpr T* __to_address(T* p) noexcept;
+//     Mandates: T is not a function type.
+
+#include <memory>
+
+int (*pf)();
+
+void test() {
+    (void)std::__to_address(pf); // expected-error@*:* {{is a function type}}
+}

libcxx/test/libcxx/utilities/memory/pointer.conversion/to_address_on_function.verify.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>
+
+// template <class T> constexpr T* __to_address(T* p) noexcept;
+//     Mandates: T is not a function type.
+
+#include <memory>
+
+int f();
+
+void test() {
+    (void)std::__to_address(f); // expected-error@*:* {{is a function type}}
+}

libcxx/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp

constexpr bool test() {
     P8::FancyPtrA<Holder<Incomplete> > p8a = p8_nil;
     assert(std::to_address(p8a) == p8_nil);
     ASSERT_SAME_TYPE(decltype(std::to_address(p8a)), decltype(p8_nil));
 
     P8::FancyPtrB<Holder<Incomplete> > p8b = p8_nil;
     assert(std::to_address(p8b) == p8_nil);
     ASSERT_SAME_TYPE(decltype(std::to_address(p8b)), decltype(p8_nil));
 
+    int p9[2] = {};
+    assert(std::to_address(p9) == p9);
+    ASSERT_SAME_TYPE(decltype(std::to_address(p9)), int*);
+
+    const int p10[2] = {};
+    assert(std::to_address(p10) == p10);
+    ASSERT_SAME_TYPE(decltype(std::to_address(p10)), const int*);
+
+    int (*p11)() = nullptr;
+    assert(std::to_address(&p11) == &p11);
+    ASSERT_SAME_TYPE(decltype(std::to_address(&p11)), int(**)());
+
     return true;
 }
 
 int main(int, char**) {
     test();
     static_assert(test());
     return 0;
 }

libcxx/test/std/utilities/memory/pointer.conversion/to_address_on_funcptr.verify.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>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template <class T> constexpr T* to_address(T* p) noexcept;
+//     Mandates: T is not a function type.
+
+#include <memory>
+
+int (*pf)();
+
+void test() {
+    (void)std::to_address(pf); // expected-error@*:* {{is a function type}}
+}

libcxx/test/std/utilities/memory/pointer.conversion/to_address_on_function.verify.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>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// template <class T> constexpr T* to_address(T* p) noexcept;
+//     Mandates: T is not a function type.
+
+#include <memory>
+
+int f();
+
+void test() {
+    (void)std::to_address(f); // expected-error@*:* {{is a function type}}
+}