[libc++] Make sure flat_{multi}map::key_compare handle boolean-testable correctly

libcxx/include/__flat_map/flat_map.h

@@ -847,7 +847,7 @@ class flat_map {
         __compare_(std::forward<_CompArg>(__comp)...) {}
 
   _LIBCPP_HIDE_FROM_ABI bool __is_sorted_and_unique(auto&& __key_container) const {
-    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) { return !__compare_(__x, __y); };
+    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) -> bool { return !__compare_(__x, __y); };
     return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container);
   }
 
@@ -871,7 +871,7 @@ class flat_map {
       auto __zv                  = ranges::views::zip(__containers_.keys, __containers_.values);
       auto __append_start_offset = __containers_.keys.size() - __num_of_appended;
       auto __end                 = __zv.end();
-      auto __compare_key         = [this](const auto& __p1, const auto& __p2) {
+      auto __compare_key         = [this](const auto& __p1, const auto& __p2) -> bool {
         return __compare_(std::get<0>(__p1), std::get<0>(__p2));
       };
       if constexpr (!_WasSorted) {

libcxx/include/__flat_map/flat_multimap.h

@@ -777,7 +777,7 @@ class flat_multimap {
       auto __zv                  = ranges::views::zip(__containers_.keys, __containers_.values);
       auto __append_start_offset = __containers_.keys.size() - __num_appended;
       auto __end                 = __zv.end();
-      auto __compare_key         = [this](const auto& __p1, const auto& __p2) {
+      auto __compare_key         = [this](const auto& __p1, const auto& __p2) -> bool {
         return __compare_(std::get<0>(__p1), std::get<0>(__p2));
       };
       if constexpr (!_WasSorted) {

libcxx/test/std/containers/container.adaptors/flat.map/robust_against_nonbool.compile.pass.cpp

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <flat_map>
+//
+// flat_map should support comparator that return a non-boolean
+// value as long as the returned type is implicitly convertible to bool.
+
+#include <flat_map>
+#include <vector>
+#include <ranges>
+
+#include "boolean_testable.h"
+
+void test() {
+  using Key   = StrictComparable<int>;
+  using Value = StrictComparable<int>;
+  std::flat_map<Key, Value> m1;
+  std::flat_map m2(std::from_range, m1, StrictBinaryPredicate);
+  std::flat_map m3(std::sorted_unique, m1.keys(), m1.values(), StrictBinaryPredicate);
+  std::flat_map m4(m1.begin(), m1.end(), StrictBinaryPredicate);
+  m2.insert(m1.begin(), m1.end());
+  m2.insert(std::sorted_unique, m1.begin(), m1.end());
+  m2.insert_range(m1);
+  (void)m2.at(2);
+  m3[1] = 2;
+  m3.insert_or_assign(1, 2);
+  m4.try_emplace(1, 2);
+  m2.emplace(1, 2);
+  m2.emplace_hint(m2.begin(), 1, 2);
+  for (const auto& [k, v] : m2) {
+    (void)k;
+    (void)v;
+  }
+  (void)m2.find(Key{1});
+  (void)m2.equal_range(Key{1});
+  (void)(m2 == m2);
+  m2.erase(m2.begin());
+  m2.erase(m2.begin(), m2.end());
+  std::erase_if(
+      m2, []<class T>(std::pair<const StrictComparable<T>&, const StrictComparable<T>&>) -> BooleanTestable const& {
+        return yes;
+      });
+}

libcxx/test/std/containers/container.adaptors/flat.multimap/robust_against_nonbool.compile.pass.cpp

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++20
+
+// <flat_map>
+//
+// flat_multimap should support comparator that return a non-boolean
+// value as long as the returned type is implicitly convertible to bool.
+
+#include <flat_map>
+#include <ranges>
+#include <vector>
+
+#include "boolean_testable.h"
+
+void test() {
+  using Key   = StrictComparable<int>;
+  using Value = StrictComparable<int>;
+  std::flat_multimap<Key, Value> m1;
+  std::flat_multimap m2(std::from_range, m1, StrictBinaryPredicate);
+  std::flat_multimap m3(std::sorted_equivalent, m1.keys(), m1.values(), StrictBinaryPredicate);
+  std::flat_multimap m4(m1.begin(), m1.end(), StrictBinaryPredicate);
+  m2.insert(m1.begin(), m1.end());
+  m2.insert(std::sorted_equivalent, m1.begin(), m1.end());
+  m2.insert_range(m1);
+  m2.emplace(1, 2);
+  m2.emplace_hint(m2.begin(), 1, 2);
+  for (const auto& [k, v] : m2) {
+    (void)k;
+    (void)v;
+  }
+  (void)m2.find(Key{1});
+  (void)m2.equal_range(Key{1});
+  (void)(m2 == m2);
+  m2.erase(m2.begin());
+  m2.erase(m2.begin(), m2.end());
+  std::erase_if(
+      m2, []<class T>(std::pair<const StrictComparable<T>&, const StrictComparable<T>&>) -> BooleanTestable const& {
+        return yes;
+      });
+}