libstdc++: Fix constraints on std::compare_three_way

My "simplification" of std::compare_three_way's constraints in commit
f214ffb3 was incorrect, because
std::three_way_comparable_with imposes additional restrictions beyond
the <=> expression being valid.

	* libsupc++/compare (compare_three_way): Fix constraint so that
	BUILTIN-PTR-THREE-WAY does not require three_way_comparable_with.
	* testsuite/18_support/comparisons/object/builtin-ptr-three-way.cc:
	New test.

libstdc++-v3/ChangeLog

 2020-04-14  Jonathan Wakely  <jwakely@redhat.com>
 
+	* libsupc++/compare (compare_three_way): Fix constraint so that
+	BUILTIN-PTR-THREE-WAY does not require three_way_comparable_with.
+	* testsuite/18_support/comparisons/object/builtin-ptr-three-way.cc:
+	New test.
+
 	PR libstdc++/94562
 	* include/bits/shared_ptr.h (operator<=>): Define for C++20.
 	* include/bits/shared_ptr_base.h (operator<=>): Likewise.

libstdc++-v3/libsupc++/compare

@@ -481,13 +481,14 @@ namespace std
     // BUILTIN-PTR-THREE-WAY(T, U)
     template<typename _Tp, typename _Up>
       concept __3way_builtin_ptr_cmp
-	= three_way_comparable_with<_Tp, _Up>
+	= requires(_Tp&& __t, _Up&& __u)
+	  { static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
 	  && convertible_to<_Tp, const volatile void*>
 	  && convertible_to<_Up, const volatile void*>
 	  && ! requires(_Tp&& __t, _Up&& __u)
-	     { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
+	  { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
 	  && ! requires(_Tp&& __t, _Up&& __u)
-	     { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
+	  { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
   } // namespace __detail
 
   // [cmp.object], typename compare_three_way
@@ -495,6 +496,7 @@ namespace std
   {
     template<typename _Tp, typename _Up>
       requires three_way_comparable_with<_Tp, _Up>
+      || __detail::__3way_builtin_ptr_cmp<_Tp, _Up>
       constexpr auto
       operator()(_Tp&& __t, _Up&& __u) const
       noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))

libstdc++-v3/testsuite/18_support/comparisons/object/builtin-ptr-three-way.cc

+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <compare>
+
+void
+test01()
+{
+  struct X
+  {
+    operator int() const { return 0; }
+    operator long*() const { return nullptr; }
+  } x;
+
+  // Not three-way-comparable because of ambiguous conversion to int or long*:
+  static_assert( ! std::three_way_comparable<X> );
+
+  // And therefore X is not three-way-comparable-with anything else
+  // (because std::three_way_comparable_with<X, Y> requires that both
+  // three_way_comparable<X> and three_way_comparable<Y> are true).
+  static_assert( ! std::three_way_comparable_with<X, long*> );
+
+  long l;
+  // But <=> is valid and resolves to a builtin operator comparing pointers:
+  auto c = &l <=> x;
+  // So std::compare_three_way should be usable:
+  auto c2 = std::compare_three_way()(&l, x);
+}