[libc++] Implement std::inplace_vector<T, N>

Author: MitalAshok

libcxx/docs/FeatureTestMacroTable.rst

@@ -440,7 +440,7 @@ Status
     ---------------------------------------------------------- -----------------
     ``__cpp_lib_hazard_pointer``                               *unimplemented*
     ---------------------------------------------------------- -----------------
-    ``__cpp_lib_inplace_vector``                               *unimplemented*
+    ``__cpp_lib_inplace_vector``                               ``202406L``
     ---------------------------------------------------------- -----------------
     ``__cpp_lib_is_virtual_base_of``                           *unimplemented*
     ---------------------------------------------------------- -----------------

libcxx/docs/Status/Cxx2cPapers.csv

@@ -69,7 +69,7 @@
 "`P3168R2 <https://wg21.link/P3168R2>`__","Give ``std::optional`` Range Support","2024-06 (St. Louis)","","","|ranges|"
 "`P3217R0 <https://wg21.link/P3217R0>`__","Adjoints to 'Enabling list-initialization for algorithms': find_last","2024-06 (St. Louis)","","",""
 "`P2985R0 <https://wg21.link/P2985R0>`__","A type trait for detecting virtual base classes","2024-06 (St. Louis)","","",""
-"`P0843R14 <https://wg21.link/P0843R14>`__","``inplace_vector``","2024-06 (St. Louis)","","",""
+"`P0843R14 <https://wg21.link/P0843R14>`__","``inplace_vector``","2024-06 (St. Louis)","|Complete|","20.0",""
 "`P3235R3 <https://wg21.link/P3235R3>`__","``std::print`` more types faster with less memory","2024-06 (St. Louis)","","","|format| |DR|"
 "`P2968R2 <https://wg21.link/P2968R2>`__","Make ``std::ignore`` a first-class object","2024-06 (St. Louis)","|Complete|","19.0",""
 "`P2075R6 <https://wg21.link/P2075R6>`__","Philox as an extension of the C++ RNG engines","2024-06 (St. Louis)","","",""

libcxx/include/CMakeLists.txt

@@ -947,6 +947,7 @@ set(files
   functional
   future
   initializer_list
+  inplace_vector
   inttypes.h
   iomanip
   ios

libcxx/include/__configuration/abi.h

@@ -134,7 +134,8 @@
 //
 // Supported containers:
 // - `span`;
-// - `string_view`.
+// - `string_view`;
+// - `inplace_vector`.
 // #define _LIBCPP_ABI_BOUNDED_ITERATORS
 
 // Changes the iterator type of `basic_string` to a bounded iterator that keeps track of whether it's within the bounds

libcxx/include/__iterator/wrap_iter.h

@@ -107,6 +107,10 @@ class __wrap_iter {
   friend class _LIBCPP_TEMPLATE_VIS span;
   template <class _Tp, size_t _Size>
   friend struct array;
+#if _LIBCPP_STD_VER >= 26
+  template <class _Tp, size_t _Capacity>
+  friend class inplace_vector;
+#endif
 };
 
 template <class _Iter1>

libcxx/include/inplace_vector

@@ -103,6 +103,10 @@ module std_initializer_list [system] {
   header "initializer_list"
   export *
 }
+module std_inplace_vector [system] {
+  header "inplace_vector"
+  export *
+}
 module std_iomanip [system] {
   header "iomanip"
   export *

libcxx/include/module.modulemap

@@ -530,7 +530,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_function_ref                         202306L
 // # define __cpp_lib_generate_random                      202403L
 // # define __cpp_lib_hazard_pointer                       202306L
-// # define __cpp_lib_inplace_vector                       202406L
+# define __cpp_lib_inplace_vector                       202406L
 // # define __cpp_lib_is_virtual_base_of                   202406L
 // # define __cpp_lib_is_within_lifetime                   202306L
 // # define __cpp_lib_linalg                               202311L

libcxx/include/version

@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++23
+
+// <vector>
+
+//       reference operator[](size_type __i);
+// const_reference operator[](size_type __i) const;
+//
+//       reference at(size_type __i);
+// const_reference at(size_type __i) const;
+//
+//       reference front();
+// const_reference front() const;
+//
+//       reference back();
+// const_reference back() const;
+// libc++ marks these as 'noexcept' (except 'at')
+
+#include <vector>
+#include <cassert>
+#include <stdexcept>
+
+#include "min_allocator.h"
+#include "test_macros.h"
+
+template <class C>
+TEST_CONSTEXPR_CXX20 C make(int size, int start) {
+  C c;
+  for (int i = 0; i < size; ++i)
+    c.push_back(start + i);
+  return c;
+}
+
+template <class Vector>
+TEST_CONSTEXPR_CXX20 void test_get_basic(Vector& c, int start_value) {
+  const int n = static_cast<int>(c.size());
+  for (int i = 0; i < n; ++i)
+    assert(c[i] == start_value + i);
+  for (int i = 0; i < n; ++i)
+    assert(c.at(i) == start_value + i);
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  if !consteval {
+    try {
+      TEST_IGNORE_NODISCARD c.at(n);
+      assert(false);
+    } catch (const std::out_of_range&) {
+    }
+  }
+#endif
+
+  assert(c.front() == start_value);
+  assert(c.back() == start_value + n - 1);
+}
+
+template <class Vector>
+TEST_CONSTEXPR_CXX20 void test_get() {
+  int start_value  = 35;
+  Vector c         = make<Vector>(10, start_value);
+  const Vector& cc = c;
+  test_get_basic(c, start_value);
+  test_get_basic(cc, start_value);
+}
+
+template <class Vector>
+TEST_CONSTEXPR_CXX20 void test_set() {
+  int start_value = 35;
+  const int n     = 10;
+  Vector c        = make<Vector>(n, start_value);
+
+  for (int i = 0; i < n; ++i) {
+    assert(c[i] == start_value + i);
+    c[i] = start_value + i + 1;
+    assert(c[i] == start_value + i + 1);
+  }
+  for (int i = 0; i < n; ++i) {
+    assert(c.at(i) == start_value + i + 1);
+    c.at(i) = start_value + i + 2;
+    assert(c.at(i) == start_value + i + 2);
+  }
+
+  assert(c.front() == start_value + 2);
+  c.front() = start_value + 3;
+  assert(c.front() == start_value + 3);
+
+  assert(c.back() == start_value + n + 1);
+  c.back() = start_value + n + 2;
+  assert(c.back() == start_value + n + 2);
+}
+
+template <class Vector>
+TEST_CONSTEXPR_CXX20 void test() {
+  test_get<Vector>();
+  test_set<Vector>();
+
+  Vector c;
+  const Vector& cc = c;
+  ASSERT_SAME_TYPE(typename Vector::reference, decltype(c[0]));
+  ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc[0]));
+
+  ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.at(0)));
+  ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.at(0)));
+
+  ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.front()));
+  ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.front()));
+
+  ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.back()));
+  ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.back()));
+}
+
+TEST_CONSTEXPR_CXX20 bool tests() {
+  test<std::vector<int> >();
+#if TEST_STD_VER >= 11
+  test<std::vector<int, min_allocator<int> > >();
+  test<std::vector<int, safe_allocator<int> > >();
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  tests();
+#if TEST_STD_VER > 17
+  static_assert(tests());
+#endif
+  return 0;
+}

libcxx/test/std/containers/sequences/inplace.vector/access.pass.cpp

@@ -0,0 +1,129 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// bool operator==(const vector& lhs, const vector& rhs);
+// bool operator!=(const vector& lhs, const vector& rhs);
+// bool operator< (const vector& lhs, const vector& rhs);
+// bool operator<=(const vector& lhs, const vector& rhs);
+// bool operator> (const vector& lhs, const vector& rhs);
+// bool operator>=(const vector& lhs, const vector& rhs);
+
+#include <vector>
+#include <cassert>
+
+#include "test_comparisons.h"
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  {
+    const std::vector<int> c1, c2;
+    assert(testComparisons(c1, c2, true, false));
+  }
+  {
+    const std::vector<int> c1(1, 1), c2(1, 2);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    const std::vector<int> c1, c2(1, 2);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    int items1[3] = {1, 2, 1};
+    int items2[3] = {1, 2, 2};
+    const std::vector<int> c1(items1, items1 + 3);
+    const std::vector<int> c2(items2, items2 + 3);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    int items1[3] = {3, 2, 3};
+    int items2[3] = {3, 1, 3};
+    const std::vector<int> c1(items1, items1 + 3);
+    const std::vector<int> c2(items2, items2 + 3);
+
+    assert(testComparisons(c1, c2, false, false));
+  }
+  {
+    int items1[2] = {1, 2};
+    int items2[3] = {1, 2, 0};
+    const std::vector<int> c1(items1, items1 + 2);
+    const std::vector<int> c2(items2, items2 + 3);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    int items1[3] = {1, 2, 0};
+    const std::vector<int> c1(items1, items1 + 3);
+    const std::vector<int> c2(1, 3);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    const std::vector<LessAndEqComp> c1, c2;
+    assert(testComparisons(c1, c2, true, false));
+  }
+  {
+    const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
+    const std::vector<LessAndEqComp> c2(1, LessAndEqComp(1));
+    assert(testComparisons(c1, c2, true, false));
+  }
+  {
+    const std::vector<LessAndEqComp> c1(1, LessAndEqComp(1));
+    const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    const std::vector<LessAndEqComp> c1;
+    const std::vector<LessAndEqComp> c2(1, LessAndEqComp(2));
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(2)};
+    LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(1)};
+    const std::vector<LessAndEqComp> c1(items1, items1 + 3);
+    const std::vector<LessAndEqComp> c2(items2, items2 + 3);
+    assert(testComparisons(c1, c2, false, false));
+  }
+  {
+    LessAndEqComp items1[3] = {LessAndEqComp(3), LessAndEqComp(3), LessAndEqComp(3)};
+    LessAndEqComp items2[3] = {LessAndEqComp(3), LessAndEqComp(2), LessAndEqComp(3)};
+    const std::vector<LessAndEqComp> c1(items1, items1 + 3);
+    const std::vector<LessAndEqComp> c2(items2, items2 + 3);
+    assert(testComparisons(c1, c2, false, false));
+  }
+  {
+    LessAndEqComp items1[2] = {LessAndEqComp(1), LessAndEqComp(2)};
+    LessAndEqComp items2[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
+    const std::vector<LessAndEqComp> c1(items1, items1 + 2);
+    const std::vector<LessAndEqComp> c2(items2, items2 + 3);
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    LessAndEqComp items1[3] = {LessAndEqComp(1), LessAndEqComp(2), LessAndEqComp(0)};
+    const std::vector<LessAndEqComp> c1(items1, items1 + 3);
+    const std::vector<LessAndEqComp> c2(1, LessAndEqComp(3));
+    assert(testComparisons(c1, c2, false, true));
+  }
+  {
+    assert((std::vector<int>() == std::vector<int>()));
+    assert(!(std::vector<int>() != std::vector<int>()));
+    assert(!(std::vector<int>() < std::vector<int>()));
+    assert((std::vector<int>() <= std::vector<int>()));
+    assert(!(std::vector<int>() > std::vector<int>()));
+    assert((std::vector<int>() >= std::vector<int>()));
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
+  return 0;
+}

libcxx/test/std/containers/sequences/inplace.vector/compare.pass.cpp

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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, c++23
+
+// <inplace_vector>
+
+// class inplace_vector
+
+//   constexpr auto operator<=>(const inplace_vector& x,
+//                              const inplace_vector& y);
+
+// FIXME: check if the auto is valid
+
+#include <cassert>
+#include <inplace_vector>
+
+#include "test_container_comparisons.h"
+
+template <typename T>
+using inplace_vector_size_10 = std::inplace_vector<T, 10>;
+
+// TODO: test inplace_vector<T, 0> still has a valid definition
+// TODO: modify so that the checks work in constexpr
+
+int main(int, char**) {
+  assert(test_sequence_container_spaceship<inplace_vector_size_10>());
+  // static_assert(test_sequence_container_spaceship<inplace_vector_size_10>());
+  return 0;
+}