address comment

Author: huixie90

libcxx/include/__flat_map/flat_map.h

@@ -789,20 +789,12 @@ class flat_map {
   }
 
   _LIBCPP_HIDE_FROM_ABI void swap(flat_map& __y) noexcept {
-#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#  endif
-      ranges::swap(__compare_, __y.__compare_);
-      ranges::swap(__containers_.keys, __y.__containers_.keys);
-      ranges::swap(__containers_.values, __y.__containers_.values);
-#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-      // todo: how can we tell the user that the swap is unsuccessful?
-      // need to swallow the exception because the function is noexcept
-      clear() /* noexcept */;
-      __y.clear() /*noexcept*/;
-    }
-#  endif
+    // warning: The spec has unconditional noexcept, which means that
+    // if any of the following functions throw an exception,
+    // std::terminate will be called
+    ranges::swap(__compare_, __y.__compare_);
+    ranges::swap(__containers_.keys, __y.__containers_.keys);
+    ranges::swap(__containers_.values, __y.__containers_.values);
   }
 
   _LIBCPP_HIDE_FROM_ABI void clear() noexcept {

libcxx/include/flat_map

@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
 #ifndef _LIBCPP_FLAT_MAP
 #define _LIBCPP_FLAT_MAP
 

libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.input_range.pass.cpp

@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 // UNSUPPORTED: libcpp-hardening-mode=none
@@ -18,7 +19,9 @@
 //
 
 #include <flat_map>
-#include <cassert>
+#include <functional>
+#include <memory>
+#include <vector>
 
 #include "check_assertion.h"
 

libcxx/test/libcxx/containers/containers.adaptors/flat.map/assert.sorted_unique.pass.cpp

@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
+
 // REQUIRES: has-unix-headers
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 // UNSUPPORTED: libcpp-hardening-mode=none
@@ -18,7 +19,11 @@
 //
 
 #include <flat_map>
-#include <cassert>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <utility>
+#include <vector>
 
 #include "check_assertion.h"
 

libcxx/test/std/containers/container.adaptors/NaiveStaticVector.h

@@ -9,31 +9,37 @@
 #ifndef SUPPORT_NAIVE_STATIC_VECTOR_H
 #define SUPPORT_NAIVE_STATIC_VECTOR_H
 
+#include <cstddef>
+#include <utility>
 #include "test_iterators.h"
 #include "test_macros.h"
 
-template<class T, size_t N>
+template <class T, std::size_t N>
 struct NaiveStaticVector {
   struct CapacityError {};
 
-  using value_type = T;
+  using value_type      = T;
   using difference_type = short;
-  using size_type = unsigned short;
-  using iterator = random_access_iterator<T*>;
-  using const_iterator = random_access_iterator<const T*>;
+  using size_type       = unsigned short;
+  using iterator        = random_access_iterator<T*>;
+  using const_iterator  = random_access_iterator<const T*>;
 
   explicit NaiveStaticVector() = default;
-  template<class It> explicit NaiveStaticVector(It first, It last) { while (first != last) insert(*first++); }
+  template <class It>
+  explicit NaiveStaticVector(It first, It last) {
+    while (first != last)
+      insert(*first++);
+  }
 
   // Moving-from a NaiveStaticVector leaves the source vector holding moved-from objects.
   // This is intentional (the "Naive" in the name).
   // Specifically, moving-out-of a sorted+uniqued NaiveStaticVector<MoveOnly>
   // will leave it in a non-sorted+uniqued state.
 
-  NaiveStaticVector(const NaiveStaticVector&) = default;
-  NaiveStaticVector(NaiveStaticVector&&) = default;  // deliberately don't reset size_
+  NaiveStaticVector(const NaiveStaticVector&)            = default;
+  NaiveStaticVector(NaiveStaticVector&&)                 = default; // deliberately don't reset size_
   NaiveStaticVector& operator=(const NaiveStaticVector&) = default;
-  NaiveStaticVector& operator=(NaiveStaticVector&&) = default;
+  NaiveStaticVector& operator=(NaiveStaticVector&&)      = default;
 
   iterator begin() { return iterator(data_); }
   const_iterator begin() const { return const_iterator(data_); }
@@ -45,7 +51,7 @@ struct NaiveStaticVector {
 
   void clear() { size_ = 0; }
 
-  template<class It>
+  template <class It>
   iterator insert(const_iterator pos, It first, It last) {
     iterator result = pos - cbegin() + begin();
     while (first != last) {
@@ -78,13 +84,11 @@ struct NaiveStaticVector {
     return begin() + i;
   }
 
-  iterator erase(const_iterator pos) {
-    return erase(pos, std::next(pos));
-  }
+  iterator erase(const_iterator pos) { return erase(pos, std::next(pos)); }
 
 private:
   T data_[N];
-  size_t size_ = 0;
+  std::size_t size_ = 0;
 };
 
 #endif // SUPPORT_NAIVE_STATIC_VECTOR_H

libcxx/test/std/containers/container.adaptors/flat.map.syn/sorted_unique.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// 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>
+
+// struct sorted_unique_t { explicit sorted_unique_t() = default; };
+// inline constexpr sorted_unique_t sorted_unique{};
+
+#include <cassert>
+#include <concepts>
+#include <flat_map>
+#include <type_traits>
+
+template <class T>
+void implicit_test(T) {}
+
+template <class T>
+concept HasImplicitDefaultCtor = requires { implicit_test<T>({}); };
+
+static_assert(std::is_default_constructible_v<std::sorted_unique_t>);
+static_assert(std::is_trivially_default_constructible_v<std::sorted_unique_t>);
+static_assert(!HasImplicitDefaultCtor<std::sorted_unique_t>);
+
+constexpr bool test() {
+  {
+    [[maybe_unused]] std::sorted_unique_t s;
+  }
+  {
+    [[maybe_unused]] std::same_as<const std::sorted_unique_t&> decltype(auto) s = (std::sorted_unique);
+  }
+  {
+    [[maybe_unused]] std::same_as<const std::sorted_unique_t> decltype(auto) copy = std::sorted_unique;
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+}

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/empty.pass.cpp

@@ -46,20 +46,6 @@ int main(int, char**) {
     m.clear();
     assert(m.empty());
   }
-#if 0
-  // vector<bool> is not supported
-  {
-    typedef std::flat_map<bool, bool> M;
-    M m;
-    ASSERT_SAME_TYPE(decltype(m.empty()), bool);
-    ASSERT_NOEXCEPT(m.empty());
-    assert(m.empty());
-    assert(std::as_const(m).empty());
-    m = {{false, false}};
-    assert(!m.empty());
-    m.clear();
-    assert(m.empty());
-  }
-#endif
+
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/max_size.pass.cpp

@@ -29,7 +29,7 @@ int main(int, char**) {
     using C  = std::flat_map<int, int, std::less<int>, std::vector<int, A1>, std::vector<int, A2>>;
     ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
     ASSERT_SAME_TYPE(C::size_type, std::size_t);
-    C c;
+    const C c;
     ASSERT_NOEXCEPT(c.max_size());
     ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
     assert(c.max_size() <= 10);
@@ -41,7 +41,7 @@ int main(int, char**) {
     using C  = std::flat_map<int, int, std::less<int>, std::vector<int, A2>, std::vector<int, A1>>;
     ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
     ASSERT_SAME_TYPE(C::size_type, std::size_t);
-    C c;
+    const C c;
     ASSERT_NOEXCEPT(c.max_size());
     ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
     assert(c.max_size() <= 10);
@@ -53,7 +53,7 @@ int main(int, char**) {
     ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
     ASSERT_SAME_TYPE(C::size_type, std::size_t);
     const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
-    C c;
+    const C c;
     ASSERT_NOEXCEPT(c.max_size());
     ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
     assert(c.max_size() <= max_dist);
@@ -64,7 +64,7 @@ int main(int, char**) {
     ASSERT_SAME_TYPE(C::difference_type, std::ptrdiff_t);
     ASSERT_SAME_TYPE(C::size_type, std::size_t);
     const C::size_type max_dist = static_cast<C::size_type>(std::numeric_limits<C::difference_type>::max());
-    C c;
+    const C c;
     ASSERT_NOEXCEPT(c.max_size());
     ASSERT_SAME_TYPE(decltype(c.max_size()), C::size_type);
     assert(c.max_size() <= max_dist);

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.capacity/size.pass.cpp

@@ -20,12 +20,37 @@
 
 int main(int, char**) {
   {
-    using M = std::flat_map<int, char>;
-    M m     = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
+    using M   = std::flat_map<int, char>;
+    const M m = {{1, 'a'}, {1, 'b'}, {4, 'd'}, {5, 'e'}, {5, 'h'}};
     ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
     ASSERT_NOEXCEPT(m.size());
     assert(m.size() == 3);
   }
+  {
+    using M   = std::flat_map<int, char>;
+    const M m = {{1, 'a'}};
+    ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 1);
+  }
+  {
+    using M = std::flat_map<int, char>;
+    const M m;
+    ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == 0);
+  }
+  {
+    using M = std::flat_map<int, char>;
+    M m;
+    std::size_t s = 1000000;
+    for (auto i = 0u; i < s; ++i) {
+      m.emplace(i, 'a');
+    }
+    ASSERT_SAME_TYPE(decltype(m.size()), std::size_t);
+    ASSERT_NOEXCEPT(m.size());
+    assert(m.size() == s);
+  }
 
   return 0;
 }

libcxx/test/std/containers/container.adaptors/flat.map/flat.map.cons/alloc.pass.cpp

@@ -44,7 +44,7 @@ int main(int, char**) {
     static_assert(!std::is_constructible_v<M3, const A2&>);
   }
   {
-    //explicit
+    // explicit
     using M =
         std::flat_map<int,
                       long,