[libc++] Avoid -Wzero-as-null-pointer-constant in operator<=>

Issue #43670 describes a situation where the following comparison
will issue a warning when -Wzero-as-null-pointer-constant is enabled:

    #include <compare>
    auto b = (1 <=> 2) < 0;

This code uses operator<(strong_ordering, Unspecified), which is
specified by the Standard to only work with a literal 0. In the
library, this is achieved by constructing Unspecified from a pointer,
which works but has the downside of triggering the warning.

This patch uses an alternative implementation where we require that
the operator is used exactly with an int of value 0 (known at compile-time),
however that value can technically be an expression like `1 - 1`, which
makes us a bit less strict than what's specified in the Standard.

Fixes #43670

Author: ldionne

libcxx/include/__compare/ordering.h

@@ -30,14 +30,17 @@ class partial_ordering;
 class weak_ordering;
 class strong_ordering;
 
-template <class _Tp, class... _Args>
-inline constexpr bool __one_of_v = (is_same_v<_Tp, _Args> || ...);
-
 struct _CmpUnspecifiedParam {
-  _LIBCPP_HIDE_FROM_ABI constexpr _CmpUnspecifiedParam(int _CmpUnspecifiedParam::*) noexcept {}
-
-  template <class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>>
-  _CmpUnspecifiedParam(_Tp) = delete;
+  template <class _Tp, class = __enable_if_t<is_same_v<_Tp, int>>>
+  _LIBCPP_HIDE_FROM_ABI consteval _CmpUnspecifiedParam(_Tp __zero) noexcept {
+    // If anything other than 0 is provided, the behavior is undefined.
+    // We catch this case by making this function consteval and making the program ill-formed if
+    // a value other than 0 is provided. This technically also accepts things that are not
+    // literal 0s like `1 - 1`. The alternative is to use the fact that a pointer can be
+    // constructed from literal 0, but this conflicts with `-Wzero-as-null-pointer-constant`.
+    if (__zero != 0)
+      __builtin_trap();
+  }
 };
 
 class partial_ordering {
@@ -269,7 +272,8 @@ inline constexpr strong_ordering strong_ordering::greater(_OrdResult::__greater)
 /// The types partial_ordering, weak_ordering, and strong_ordering are
 /// collectively termed the comparison category types.
 template <class _Tp>
-concept __comparison_category = __one_of_v<_Tp, partial_ordering, weak_ordering, strong_ordering>;
+concept __comparison_category =
+    is_same_v<_Tp, partial_ordering> || is_same_v<_Tp, weak_ordering> || is_same_v<_Tp, strong_ordering>;
 
 #endif // _LIBCPP_STD_VER >= 20
 

libcxx/test/std/language.support/cmp/cmp.categories.pre/reject-other-than-literal-zero.verify.cpp

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// In MSVC mode, there's a slightly different number of errors printed for
+// each of these, so it doesn't add up to the exact expected count of 18.
+// XFAIL: msvc
+
+// <compare>
+
+// Ensure we reject all cases where an argument other than a literal 0 is used
+// for a comparison against a comparison category type.
+
+// Also ensure that we don't warn about providing a null pointer constant when
+// comparing an ordering type against literal 0, since one of the common
+// implementation strategies is to use a pointer as the "unspecified type".
+// ADDITIONAL_COMPILE_FLAGS: -Wzero-as-null-pointer-constant
+
+#include <compare>
+
+#include "test_macros.h"
+
+#define TEST_FAIL(v, op)                                                                                               \
+  do {                                                                                                                 \
+    void(v op 0L);                                                                                                     \
+    void(0L op v);                                                                                                     \
+    void(v op 1);                                                                                                      \
+    void(1 op v);                                                                                                      \
+    void(v op nullptr);                                                                                                \
+    void(nullptr op v);                                                                                                \
+  } while (false)
+
+#define TEST_PASS(v, op)                                                                                               \
+  do {                                                                                                                 \
+    void(v op 0);                                                                                                      \
+    void(0 op v);                                                                                                      \
+    LIBCPP_ONLY(void(v op(1 - 1)));                                                                                    \
+    LIBCPP_ONLY(void((1 - 1) op v));                                                                                   \
+  } while (false)
+
+template <typename T>
+void test_category(T v) {
+  TEST_FAIL(v, ==);  // expected-error 18 {{}}
+  TEST_FAIL(v, !=);  // expected-error 18 {{}}
+  TEST_FAIL(v, <);   // expected-error 18 {{}}
+  TEST_FAIL(v, <=);  // expected-error 18 {{}}
+  TEST_FAIL(v, >);   // expected-error 18 {{}}
+  TEST_FAIL(v, >=);  // expected-error 18 {{}}
+  TEST_FAIL(v, <=>); // expected-error 18 {{}}
+
+  TEST_PASS(v, ==);
+  TEST_PASS(v, !=);
+  TEST_PASS(v, <);
+  TEST_PASS(v, >);
+  TEST_PASS(v, <=);
+  TEST_PASS(v, >=);
+  TEST_PASS(v, <=>);
+}
+
+void f() {
+  test_category(std::strong_ordering::equivalent);
+  test_category(std::weak_ordering::equivalent);
+  test_category(std::partial_ordering::equivalent);
+}