@@ -35,6 +35,7 @@
#include <bits/move.h>
#if __cplusplus > 201703L
+#include <concepts>
#define __cpp_lib_constexpr_memory 201811L
namespace __gnu_debug { struct _Safe_iterator_base; }
#endif
@@ -45,55 +46,119 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
class __undefined;
- // Given Template<T, ...> return T, otherwise invalid.
+ // For a specialization `SomeTemplate<T, Types...>` the member `type` is T,
+ // otherwise `type` is `__undefined`.
template<typename _Tp>
struct __get_first_arg
{ using type = __undefined; };
- template<template<typename, typename...> class _Template, typename _Tp,
+ template<template<typename, typename...> class _SomeTemplate, typename _Tp,
typename... _Types>
- struct __get_first_arg<_Template<_Tp, _Types...>>
+ struct __get_first_arg<_SomeTemplate<_Tp, _Types...>>
{ using type = _Tp; };
- template<typename _Tp>
- using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
-
- // Given Template<T, ...> and U return Template<U, ...>, otherwise invalid.
+ // For a specialization `SomeTemplate<T, Args...>` and a type `U` the member
+ // `type` is `SomeTemplate<U, Args...>`, otherwise there is no member `type`.
template<typename _Tp, typename _Up>
struct __replace_first_arg
{ };
- template<template<typename, typename...> class _Template, typename _Up,
+ template<template<typename, typename...> class _SomeTemplate, typename _Up,
typename _Tp, typename... _Types>
- struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
- { using type = _Template<_Up, _Types...>; };
+ struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up>
+ { using type = _SomeTemplate<_Up, _Types...>; };
- template<typename _Tp, typename _Up>
- using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
-
- template<typename _Tp>
- using __make_not_void
- = __conditional_t<is_void<_Tp>::value, __undefined, _Tp>;
-
- /**
- * @brief Uniform interface to all pointer-like types
- * @ingroup pointer_abstractions
- */
+#if __cpp_concepts
+ // When concepts are supported detection of _Ptr::element_type is done
+ // by a requires-clause, so __ptr_traits_elem_t only needs to do this:
template<typename _Ptr>
- struct pointer_traits
+ using __ptr_traits_elem_t = typename __get_first_arg<_Ptr>::type;
+#else
+ // Detect the element type of a pointer-like type.
+ template<typename _Ptr, typename = void>
+ struct __ptr_traits_elem : __get_first_arg<_Ptr>
+ { };
+
+ // Use _Ptr::element_type if is a valid type.
+ template<typename _Ptr>
+ struct __ptr_traits_elem<_Ptr, __void_t<typename _Ptr::element_type>>
+ { using type = typename _Ptr::element_type; };
+
+ template<typename _Ptr>
+ using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type;
+#endif
+
+ // Define pointer_traits<P>::pointer_to.
+ template<typename _Ptr, typename _Elt, bool = is_void<_Elt>::value>
+ struct __ptr_traits_ptr_to
+ {
+ using pointer = _Ptr;
+ using element_type = _Elt;
+
+ /**
+ * @brief Obtain a pointer to an object
+ * @param __r A reference to an object of type `element_type`
+ * @return `pointer::pointer_to(__e)`
+ * @pre `pointer::pointer_to(__e)` is a valid expression.
+ */
+ static pointer
+ pointer_to(element_type& __e)
+#if __cpp_lib_concepts
+ requires requires {
+ { pointer::pointer_to(__e) } -> convertible_to<pointer>;
+ }
+#endif
+ { return pointer::pointer_to(__e); }
+ };
+
+ // Do not define pointer_traits<P>::pointer_to if element type is void.
+ template<typename _Ptr, typename _Elt>
+ struct __ptr_traits_ptr_to<_Ptr, _Elt, true>
+ { };
+
+ // Partial specialization defining pointer_traits<T*>::pointer_to(T&).
+ template<typename _Tp>
+ struct __ptr_traits_ptr_to<_Tp*, _Tp, false>
+ {
+ using pointer = _Tp*;
+ using element_type = _Tp;
+
+ /**
+ * @brief Obtain a pointer to an object
+ * @param __r A reference to an object of type `element_type`
+ * @return `addressof(__r)`
+ */
+ static _GLIBCXX20_CONSTEXPR pointer
+ pointer_to(element_type& __r) noexcept
+ { return std::addressof(__r); }
+ };
+
+ template<typename _Ptr, typename _Elt>
+ struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt>
{
private:
- template<typename _Tp>
- using __element_type = typename _Tp::element_type;
+ template<typename _Tp, typename = void>
+ struct __difference { using type = ptrdiff_t; };
template<typename _Tp>
- using __difference_type = typename _Tp::difference_type;
+#if __cpp_concepts
+ requires requires { typename _Tp::difference_type; }
+ struct __difference<_Tp>
+#else
+ struct __difference<_Tp, __void_t<typename _Tp::difference_type>>
+#endif
+ { using type = typename _Tp::difference_type; };
template<typename _Tp, typename _Up, typename = void>
struct __rebind : __replace_first_arg<_Tp, _Up> { };
template<typename _Tp, typename _Up>
+#if __cpp_concepts
+ requires requires { typename _Tp::template rebind<_Up>; }
+ struct __rebind<_Tp, _Up>
+#else
struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
+#endif
{ using type = typename _Tp::template rebind<_Up>; };
public:
@@ -101,31 +166,45 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using pointer = _Ptr;
/// The type pointed to.
- using element_type
- = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;
+ using element_type = _Elt;
/// The type used to represent the difference between two pointers.
- using difference_type
- = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
+ using difference_type = typename __difference<_Ptr>::type;
/// A pointer to a different type.
template<typename _Up>
using rebind = typename __rebind<_Ptr, _Up>::type;
-
- static _Ptr
- pointer_to(__make_not_void<element_type>& __e)
- { return _Ptr::pointer_to(__e); }
-
- static_assert(!is_same<element_type, __undefined>::value,
- "pointer type defines element_type or is like SomePointer<T, Args>");
};
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 3545. std::pointer_traits should be SFINAE-friendly
+ template<typename _Ptr>
+ struct __ptr_traits_impl<_Ptr, __undefined>
+ { };
+
+ /**
+ * @brief Uniform interface to all pointer-like types
+ * @ingroup pointer_abstractions
+ * @since C++11
+ */
+ template<typename _Ptr>
+ struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>>
+ { };
+
+#if __cpp_concepts
+ template<typename _Ptr> requires requires { typename _Ptr::element_type; }
+ struct pointer_traits<_Ptr>
+ : __ptr_traits_impl<_Ptr, typename _Ptr::element_type>
+ { };
+#endif
+
/**
* @brief Partial specialization for built-in pointers.
* @ingroup pointer_abstractions
+ * @since C++11
*/
template<typename _Tp>
- struct pointer_traits<_Tp*>
+ struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp>
{
/// The pointer type
typedef _Tp* pointer;
@@ -133,18 +212,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef _Tp element_type;
/// Type used to represent the difference between two pointers
typedef ptrdiff_t difference_type;
-
- template<typename _Up>
- using rebind = _Up*;
-
- /**
- * @brief Obtain a pointer to an object
- * @param __r A reference to an object of type @c element_type
- * @return @c addressof(__r)
- */
- static _GLIBCXX20_CONSTEXPR pointer
- pointer_to(__make_not_void<element_type>& __r) noexcept
- { return std::addressof(__r); }
+ /// A pointer to a different type.
+ template<typename _Up> using rebind = _Up*;
};
/// Convenience alias for rebinding pointers.
new file mode 100644
@@ -0,0 +1,120 @@
+// { dg-do compile { target c++11 } }
+
+// LWG 3545. std::pointer_traits should be SFINAE-friendly
+
+#include <memory>
+
+using std::is_same;
+
+template<typename> using void_t = void;
+
+template<template<typename> class Probe, typename T, typename = void>
+ struct has_member
+ : std::false_type { };
+
+template<template<typename> class Probe, typename T>
+ struct has_member<Probe, T, void_t<Probe<T>>>
+ : std::true_type { };
+
+template<typename T>
+ using element_type = typename T::element_type;
+template<typename T>
+ using pointer = typename T::pointer;
+template<typename T>
+ using difference_type = typename T::difference_type;
+template<typename T>
+ using rebind = typename T::template rebind<short>;
+template<typename T>
+ using pointer_to = decltype(T::pointer_to(std::declval<element_type<T>&>()));
+
+using invalid = std::pointer_traits<int>;
+invalid i; // invalid instantiation is not ill-formed
+
+static_assert( !has_member<element_type, invalid>::value, "" );
+static_assert( !has_member<pointer, invalid>::value, "" );
+static_assert( !has_member<difference_type, invalid>::value, "" );
+static_assert( !has_member<rebind, invalid>::value, "" );
+static_assert( !has_member<pointer_to, invalid>::value, "" );
+
+struct I
+{
+ // These members should not be used by pointer_traits<P>::pointer.
+ using pointer = int;
+ using difference_type = int;
+ template<typename> using rebind = int;
+};
+
+using invalid2 = std::pointer_traits<I>;
+
+static_assert( !has_member<element_type, invalid2>::value, "" );
+static_assert( !has_member<pointer, invalid2>::value, "" );
+static_assert( !has_member<difference_type, invalid2>::value, "" );
+static_assert( !has_member<rebind, invalid2>::value, "" );
+static_assert( !has_member<pointer_to, invalid2>::value, "" );
+
+struct P
+{
+ using element_type = long;
+ struct pointer { }; // should not be used by pointer_traits<P>::pointer
+
+ P pointer_to(long&) const; // not static, should not be used.
+};
+using Ptraits = std::pointer_traits<P>;
+Ptraits p;
+
+static_assert( is_same<element_type<Ptraits>, long>::value, "" );
+static_assert( is_same<pointer<Ptraits>, P>::value, "" );
+static_assert( is_same<difference_type<Ptraits>, std::ptrdiff_t>::value, "" );
+static_assert( !has_member<rebind, Ptraits>::value, "" );
+#if __cplusplus >= 202002L
+// pointer_traits<P>::pointer_to(long&) is constrained in C++20 and later.
+static_assert( !has_member<pointer_to, Ptraits>::value, "" );
+#else
+static_assert( is_same<pointer_to<Ptraits>, P>::value, "" );
+#endif
+
+struct V { using element_type = const void; };
+using Vtraits = std::pointer_traits<V>;
+Vtraits v;
+
+static_assert( is_same<element_type<Vtraits>, const void>::value, "" );
+static_assert( is_same<pointer<Vtraits>, V>::value, "" );
+static_assert( is_same<difference_type<Vtraits>, std::ptrdiff_t>::value, "" );
+static_assert( !has_member<rebind, Vtraits>::value, "" );
+static_assert( !has_member<pointer_to, Vtraits>::value, "" );
+
+template<typename T>
+struct clever_ptr
+{
+ static T obj;
+
+ static clever_ptr pointer_to(T&) { return {}; }
+ constexpr T* operator->() const { return &obj; }
+};
+
+using Ctraits = std::pointer_traits<clever_ptr<char>>;
+
+static_assert( is_same<element_type<Ctraits>, char>::value, "" );
+static_assert( is_same<pointer<Ctraits>, clever_ptr<char>>::value, "" );
+static_assert( is_same<difference_type<Ctraits>, std::ptrdiff_t>::value, "" );
+static_assert( is_same<rebind<Ctraits>, clever_ptr<short>>::value, "" );
+static_assert( is_same<pointer_to<Ctraits>, clever_ptr<char>>::value, "" );
+
+#if __cplusplus >= 202002L
+static_assert( std::to_address(clever_ptr<char>{}) == &clever_ptr<char>::obj, "" );
+
+int the_int;
+
+template<>
+struct std::pointer_traits<clever_ptr<int>>
+{
+ using element_type = int;
+ using difference_type = std::ptrdiff_t;
+ using pointer = clever_ptr<int>;
+
+ static constexpr int* to_address(pointer p) { return &the_int; }
+};
+
+// Should use pointer_traits<clever_ptr<int>>::to_address
+static_assert( std::to_address(clever_ptr<int>{}) == &the_int, "" );
+#endif
@@ -17,7 +17,7 @@
// { dg-options "-std=gnu++2a" }
// { dg-do compile { target c++2a } }
-// { dg-error "not a function pointer" "" { target *-*-* } 158 }
+// { dg-error "not a function pointer" "" { target *-*-* } 0 }
#include <memory>
new file mode 100644
@@ -0,0 +1,12 @@
+// { dg-do compile { target c++20 } }
+// { dg-options "-std=gnu++20" }
+
+#include <memory>
+
+template<typename T, bool> struct nttp_ptr
+{
+ T* operator->() const { return nullptr; }
+};
+
+// This gives an error in C++20, which the LWG 3545 resolution should fix:
+auto x = std::to_address( nttp_ptr<int, true>() );