libstdc++: Do not use SFINAE for propagate_const conversions [PR107525]

As the PR notes, the current conversion operators are defined as
function templates so that we can use SFINAE. But this changes how they
are considered for overload resolution. This moves those operators into
base classes that can be specialized so the operators are obsent unless
the constraints are satisfied.

libstdc++-v3/ChangeLog:

	PR libstdc++/107525
	* include/experimental/propagate_const (operator element_type*()):
	Move into base class that can be partially specilized to iompose
	constraints.
	(operator const element_type*()): Likewise.
	* testsuite/experimental/propagate_const/observers/107525.cc: New test.

diff --git a/libstdc++-v3/include/experimental/propagate_const b/libstdc++-v3/include/experimental/propagate_const
index 258ef6f..12b0f27 100644 (file)
--- a/libstdc++-v3/include/experimental/propagate_const
+++ b/libstdc++-v3/include/experimental/propagate_const
@@ -50,6 +50,48 @@ namespace experimental
 {
 inline namespace fundamentals_v2
 {
+  template<typename _Tp>
+    using __propagate_const_elem_type
+      = remove_reference_t<decltype(*std::declval<_Tp&>())>;
+
+  template<typename _Tp,
+          typename _Elem = __propagate_const_elem_type<_Tp>,
+          bool = is_convertible<const _Tp, const _Elem*>::value>
+    struct __propagate_const_conversion_c
+    { };
+
+  template<typename _Tp, typename _Elem>
+    struct __propagate_const_conversion_c<_Tp, _Elem, true>
+    {
+      constexpr operator const _Elem*() const;
+    };
+
+  template<typename _Tp,
+          typename _Elem = __propagate_const_elem_type<_Tp>,
+          bool = is_convertible<_Tp, _Elem*>::value>
+    struct __propagate_const_conversion_nc
+    { };
+
+  template<typename _Tp, typename _Elem>
+    struct __propagate_const_conversion_nc<_Tp, _Elem, true>
+    {
+      constexpr operator _Elem*();
+    };
+
+  // Base class of propagate_const<T> when T is a class type.
+  template <typename _Tp>
+    struct __propagate_const_conversions
+    : __propagate_const_conversion_c<_Tp>, __propagate_const_conversion_nc<_Tp>
+    { };
+
+  // Base class of propagate_const<T> when T is a pointer type.
+  template<typename _Tp>
+    struct __propagate_const_conversions<_Tp*>
+    {
+      constexpr operator const _Tp*() const noexcept;
+      constexpr operator _Tp*() noexcept;
+    };
+
   /**
    * @defgroup propagate_const Const-propagating wrapper
    * @ingroup libfund-ts
@@ -63,10 +105,10 @@ inline namespace fundamentals_v2
 
   /// Const-propagating wrapper.
   template <typename _Tp>
-    class propagate_const
+    class propagate_const : public __propagate_const_conversions<_Tp>
     {
     public:
-      typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
+      using element_type = __propagate_const_elem_type<_Tp>;
 
     private:
       template <typename _Up>
@@ -186,16 +228,6 @@ inline namespace fundamentals_v2
        return get();
       }
 
-      template <typename _Up = _Tp,
-               typename enable_if<__or_<is_pointer<_Up>,
-                                        is_convertible<_Up,
-                                                       const element_type*>
-                                        >::value, bool>::type = true>
-      constexpr operator const element_type*() const
-      {
-       return get();
-      }
-
       constexpr const element_type& operator*() const
       {
        return *get();
@@ -212,16 +244,6 @@ inline namespace fundamentals_v2
        return get();
       }
 
-      template <typename _Up = _Tp,
-               typename enable_if<__or_<is_pointer<_Up>,
-                                        is_convertible<_Up,
-                                                       const element_type*>
-                                        >::value, bool>::type = true>
-      constexpr operator element_type*()
-      {
-       return get();
-      }
-
       constexpr element_type& operator*()
       {
        return *get();
@@ -430,6 +452,28 @@ inline namespace fundamentals_v2
       return __pt._M_t;
     }
 
+  template<typename _Tp>
+    constexpr
+    __propagate_const_conversions<_Tp*>::operator const _Tp*() const noexcept
+    { return static_cast<const propagate_const<_Tp*>*>(this)->get(); }
+
+  template<typename _Tp>
+    constexpr
+    __propagate_const_conversions<_Tp*>::operator _Tp*() noexcept
+    { return static_cast<propagate_const<_Tp*>*>(this)->get(); }
+
+  template<typename _Tp, typename _Elem>
+    constexpr
+    __propagate_const_conversion_c<_Tp, _Elem, true>::
+    operator const _Elem*() const
+    { return static_cast<const propagate_const<_Tp>*>(this)->get(); }
+
+  template<typename _Tp, typename _Elem>
+    constexpr
+    __propagate_const_conversion_nc<_Tp, _Elem, true>::
+    operator _Elem*()
+    { return static_cast<propagate_const<_Tp>*>(this)->get(); }
+
   /// @} group propagate_const
 } // namespace fundamentals_v2
 } // namespace experimental

diff --git a/libstdc++-v3/testsuite/experimental/propagate_const/observers/107525.cc b/libstdc++-v3/testsuite/experimental/propagate_const/observers/107525.cc
new file mode 100644 (file)
index 0000000..e7ecff7
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/propagate_const/observers/107525.cc
@@ -0,0 +1,47 @@
+// { dg-do run { target c++14 } }
+
+#include <experimental/propagate_const>
+#include <testsuite_hooks.h>
+
+using std::experimental::propagate_const;
+
+void
+test_base_conversion()
+{
+  struct Base { };
+  struct Derived : Base { };
+
+  static_assert(std::is_convertible<propagate_const<Derived*>, Base*>::value,
+      "PR libstdc++/107525 - SFINAE breaks conversion operators");
+  static_assert(std::is_convertible<const propagate_const<Derived*>, const Base*>::value,
+      "PR libstdc++/107525 - SFINAE breaks conversion operators");
+}
+
+void
+test_const_conversion()
+{
+  struct X
+  {
+    int* p = nullptr;
+
+    int& operator*() const { return *p; }
+    int* operator->() const { return p; }
+    int* get() const { return p; }
+
+    operator int*() { return p; }
+    operator const int*() const = delete;
+  };
+
+  static_assert(!std::is_convertible_v<const X, const int*>,
+               "Cannot convert const X to const int*");
+  // So should not be able to convert const propagate_const<X> to const int*.
+  static_assert(!std::is_convertible_v<const propagate_const<X>, const int*>,
+               "So should not be able to convert const propagate_const<X> to "
+               "const int* (although this is not what LFTSv3 says)");
+}
+
+int main()
+{
+  test_base_conversion();
+  test_const_conversion();
+}