[libc++] Make __debug_less::operator() constexpr

[thomasanderson]

Summary

This is a followup to [1] which added a new __debug_less::operator() overload.
[2] added _LIBCPP_CONSTEXPR_AFTER_CXX17 to the original
__debug_less::operator() between the time of writing [1] and landing it. This
change adds _LIBCPP_CONSTEXPR_AFTER_CXX17 to the new overload too.

[1] https://reviews.llvm.org/rL358423
[2] https://reviews.llvm.org/rL358252

[EricWF]

We should apply this to both versions of __do_compare_assert and to the call operator taking non-const arguments as well.

And can you add additional tests that create and call the debug comparator in a constexpr context in C++17?

[thomasanderson]

In D60724#1467868, @EricWF wrote:

We should apply this to both versions of __do_compare_assert and to the call operator taking non-const arguments as well.

They're already constexpr

And can you add additional tests that create and call the debug comparator in a constexpr context in C++17?

Done

[EricWF]

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

278

constexpr bool test_constexpr() {
    std::less<> cmp;
    __debug_less<std::less<> > dcmp(cmp);
    assert(dcmp(1, 2));
    assert(!dcmp(1, 1));
    return true;
}
static_assert(test_constexpr(), "");

[EricWF]

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

278

I think the suggested test is cleaner. No need to sprinkle constexpr on every variable.
Just have a constexpr function and invoke it in a constant expression.

[thomasanderson]

Address comments

libcxx/include/algorithm

 template <class _Compare>
 struct __debug_less
 {
     _Compare &__comp_;
     _LIBCPP_CONSTEXPR_AFTER_CXX17
     __debug_less(_Compare& __c) : __comp_(__c) {}
 
     template <class _Tp, class _Up>
+    _LIBCPP_CONSTEXPR_AFTER_CXX17
     bool operator()(const _Tp& __x,  const _Up& __y)
     {
         bool __r = __comp_(__x, __y);
         if (__r)
             __do_compare_assert(0, __y, __x);
         return __r;
     }
 

libcxx/test/libcxx/algorithms/debug_less.pass.cpp

void test_value_categories() {
     int lvalue = 42;
     const int const_lvalue = 101;
 
     assert(dl(lvalue, const_lvalue));
     assert(dl(/*rvalue*/1, lvalue));
     assert(dl(static_cast<int&&>(1), static_cast<const int&&>(2)));
 }
 
+#if TEST_STD_VER > 17
+struct ConstexprComparator {
+    constexpr bool operator()(int const& lhs, int const& rhs) const {
+        return lhs < rhs;
+    }
+};
+
+void test_constexpr() {
+    auto compare = ConstexprComparator{};
+    constexpr bool b1 = __debug_less{compare}(1, 2);
+    assert(b1);
+    constexpr int i1 = 1;
+    constexpr int i2 = 2;
+    constexpr bool b2 = __debug_less{compare}(i2, i1);
+    assert(!b2);
+}
+#endif
+
 int main(int, char**) {
     test_passing();
     test_failing();
     test_upper_and_lower_bound();
     test_non_const_arg_cmp();
     test_value_iterator();
     test_value_categories();
+#if TEST_STD_VER > 17
+    test_constexpr();
+#endif
     return 0;
 }