Add Vec::as_slice and Slice::to_vec conversions

danakj · danakj · commit bc76dd220cc7 · 2023-03-02T23:48:50.000-05:00
diff --git a/subdoc/lib/gen/files.h b/subdoc/lib/gen/files.h
@@ -72,7 +72,7 @@ inline std::filesystem::path construct_html_file_path_for_namespace(
   // The namespace path includes the namespace element itself, so drop
   // that one.
   sus::Slice<const Namespace> short_namespace_path =
-      element.namespace_path.as_ref()["1.."_r];
+      element.namespace_path.as_slice()["1.."_r];
 
   std::string file_name = [&]() {
     if (element.namespace_name.which() == Namespace::Tag::Global) {
diff --git a/subdoc/lib/gen/generate_function.cc b/subdoc/lib/gen/generate_function.cc
@@ -47,8 +47,8 @@ void generate_function(HtmlWriter::OpenDiv& section_div,
         return_type_link.add_href(
             construct_html_file_path(
                 std::filesystem::path(),
-                element.return_type_element->namespace_path.as_ref(),
-                element.return_type_element->record_path.as_ref(),
+                element.return_type_element->namespace_path.as_slice(),
+                element.return_type_element->record_path.as_slice(),
                 element.return_type_element->name)
                 .string());
       }
@@ -80,12 +80,12 @@ void generate_function(HtmlWriter::OpenDiv& section_div,
         one_param_link.add_class("type-name");
         one_param_link.add_title(p.type_name);
         if (p.type_element.is_some()) {
-          one_param_link.add_href(
-              construct_html_file_path(std::filesystem::path(),
-                                       p.type_element->namespace_path.as_ref(),
-                                       p.type_element->record_path.as_ref(),
-                                       p.type_element->name)
-                  .string());
+          one_param_link.add_href(construct_html_file_path(
+                                      std::filesystem::path(),
+                                      p.type_element->namespace_path.as_slice(),
+                                      p.type_element->record_path.as_slice(),
+                                      p.type_element->name)
+                                      .string());
         }
         one_param_link.write_text(p.short_type_name);
         write_comma = true;
diff --git a/subdoc/lib/gen/generate_namespace.cc b/subdoc/lib/gen/generate_namespace.cc
@@ -35,7 +35,7 @@ std::string namespace_display_name(const NamespaceElement& element) noexcept {
   // The namespace path includes the namespace we're generating for, so drop
   // that one.
   sus::Slice<const Namespace> short_namespace_path =
-      element.namespace_path.as_ref()["1.."_r];
+      element.namespace_path.as_slice()["1.."_r];
 
   // For display in the html, we use the full path name of the namespace.
   return namespace_with_path_to_string(short_namespace_path,
@@ -180,7 +180,7 @@ void generate_namespace(const NamespaceElement& element,
         });
 
     generate_namespace_namespaces(mref(namespace_div), element,
-                                  sorted.as_ref());
+                                  sorted.as_slice());
   }
 
   {
@@ -210,9 +210,9 @@ void generate_namespace(const NamespaceElement& element,
           return a.at<1>() <=> b.at<1>();
         });
 
-    generate_namespace_records(mref(namespace_div), element, classes.as_ref(),
+    generate_namespace_records(mref(namespace_div), element, classes.as_slice(),
                                RecordType::Class);
-    generate_namespace_records(mref(namespace_div), element, unions.as_ref(),
+    generate_namespace_records(mref(namespace_div), element, unions.as_slice(),
                                RecordType::Union);
   }
 
@@ -229,7 +229,8 @@ void generate_namespace(const NamespaceElement& element,
           return a.at<1>() <=> b.at<1>();
         });
 
-    generate_namespace_functions(mref(namespace_div), element, sorted.as_ref());
+    generate_namespace_functions(mref(namespace_div), element,
+                                 sorted.as_slice());
   }
 
   // Recurse into namespaces and records.
diff --git a/subdoc/lib/gen/generate_record.cc b/subdoc/lib/gen/generate_record.cc
@@ -50,7 +50,7 @@ void generate_record_overview(HtmlWriter::OpenDiv& record_div,
       {
         // TODO: This code gets duplicated a lot, share it.
 
-        for (const Namespace &n : element.namespace_path.iter().rev()) {
+        for (const Namespace& n : element.namespace_path.iter().rev()) {
           switch (n) {
             case Namespace::Tag::Global: break;
             case Namespace::Tag::Anonymous: {
@@ -68,7 +68,7 @@ void generate_record_overview(HtmlWriter::OpenDiv& record_div,
               break;
           }
         }
-        for (std::string_view record_name: element.record_path.iter().rev()) {
+        for (std::string_view record_name : element.record_path.iter().rev()) {
           {
             auto record_anchor = full_type_span.open_a();
             record_anchor.write_text(record_name);
@@ -157,10 +157,11 @@ void generate_record_fields(HtmlWriter::OpenDiv& record_div,
         field_type_link.add_title(fe.type_name);
         if (fe.type_element.is_some()) {
           field_type_link.add_href(
-              construct_html_file_path(std::filesystem::path(),
-                                       fe.type_element->namespace_path.as_ref(),
-                                       fe.type_element->record_path.as_ref(),
-                                       fe.type_element->name)
+              construct_html_file_path(
+                  std::filesystem::path(),
+                  fe.type_element->namespace_path.as_slice(),
+                  fe.type_element->record_path.as_slice(),
+                  fe.type_element->name)
                   .string());
         }
         field_type_link.write_text(fe.short_type_name);
@@ -221,14 +222,14 @@ void generate_record_methods(HtmlWriter::OpenDiv& record_div,
 void generate_record(const RecordElement& element,
                      const Options& options) noexcept {
   const std::filesystem::path path = construct_html_file_path(
-      options.output_root, element.namespace_path.as_ref(),
-      element.record_path.as_ref(), element.name);
+      options.output_root, element.namespace_path.as_slice(),
+      element.record_path.as_slice(), element.name);
   std::filesystem::create_directories(path.parent_path());
   auto html = HtmlWriter(open_file_for_writing(path).unwrap());
 
   {
     std::ostringstream title;
-    for (const Namespace& n: element.namespace_path.iter().rev()) {
+    for (const Namespace& n : element.namespace_path.iter().rev()) {
       switch (n) {
         case Namespace::Tag::Global: break;
         case Namespace::Tag::Anonymous:
@@ -241,7 +242,7 @@ void generate_record(const RecordElement& element,
           break;
       }
     }
-    for (std::string_view record_name: element.record_path.iter().rev()) {
+    for (std::string_view record_name : element.record_path.iter().rev()) {
       title << record_name;
       title << "::";
     }
@@ -285,9 +286,9 @@ void generate_record(const RecordElement& element,
       });
 
   generate_record_fields(mref(record_div), element, true,
-                         sorted_static_fields.as_ref());
+                         sorted_static_fields.as_slice());
   generate_record_fields(mref(record_div), element, false,
-                         sorted_fields.as_ref());
+                         sorted_fields.as_slice());
 
   sus::Vec<SortedFunctionByName> sorted_static_methods;
   sus::Vec<SortedFunctionByName> sorted_methods;
@@ -314,9 +315,9 @@ void generate_record(const RecordElement& element,
       });
 
   generate_record_methods(mref(record_div), element, true,
-                          sorted_static_methods.as_ref());
+                          sorted_static_methods.as_slice());
   generate_record_methods(mref(record_div), element, false,
-                          sorted_methods.as_ref());
+                          sorted_methods.as_slice());
 
   for (const auto& [key, subrecord] : element.records) {
     generate_record(subrecord, options);
@@ -344,8 +345,8 @@ void generate_record_reference(HtmlWriter::OpenDiv& section_div,
       name_link.add_class("type-name");
       name_link.add_href(
           construct_html_file_path(std::filesystem::path(),
-                                   element.namespace_path.as_ref(),
-                                   element.record_path.as_ref(), element.name)
+                                   element.namespace_path.as_slice(),
+                                   element.record_path.as_slice(), element.name)
               .string());
       name_link.write_text(element.name);
     }
diff --git a/subdoc/tests/subdoc_gen_test.h b/subdoc/tests/subdoc_gen_test.h
@@ -44,7 +44,7 @@ class SubDocGenTest : public testing::Test {
 
     auto run_options = subdoc::RunOptions();
 
-    auto result = subdoc::run_test(sus::move(content), args.as_ref(),
+    auto result = subdoc::run_test(sus::move(content), args.as_slice(),
                                    sus::move(run_options));
     if (!result.is_ok()) return false;
 
diff --git a/subdoc/tests/subdoc_test.h b/subdoc/tests/subdoc_test.h
@@ -35,7 +35,7 @@ class SubDocTest : public testing::Test {
     auto args = sus::Vec<std::string>::with_capacity(1u);
     args.push(std::string(subdoc::tests::cpp_version_flag(cpp_version_)));
 
-    return subdoc::run_test(sus::move(content), args.as_ref(), options);
+    return subdoc::run_test(sus::move(content), args.as_slice(), options);
   }
 
   auto run_code(std::string content) noexcept {
diff --git a/subspace/containers/slice.h b/subspace/containers/slice.h
@@ -18,13 +18,15 @@
 
 #include <algorithm>  // Replace std::sort.
 #include <concepts>
+#include <type_traits>
 
 #include "subspace/assertions/check.h"
 #include "subspace/construct/into.h"
 #include "subspace/containers/__private/slice_iter.h"
 #include "subspace/fn/callable.h"
 #include "subspace/iter/iterator_defn.h"
 #include "subspace/marker/unsafe.h"
+#include "subspace/mem/clone.h"
 #include "subspace/num/unsigned_integer.h"
 #include "subspace/ops/ord.h"
 #include "subspace/ops/range.h"
@@ -36,6 +38,9 @@
 
 namespace sus::containers {
 
+template <class T>
+class Vec;
+
 /// A dynamically-sized view into a contiguous sequence, `[T]`.
 ///
 /// Contiguous here means that elements are laid out so that every element is
@@ -44,14 +49,19 @@ namespace sus::containers {
 /// Slices are a view into a block of memory represented as a pointer and a
 /// length.
 template <class T>
-class Slice {
+class [[sus_trivial_abi]] Slice {
  public:
-  Slice() : Slice(nullptr, 0_usize) {}
+  static_assert(!std::is_reference_v<T>,
+                "Slice holds references, so the type parameter can not also be "
+                "a reference");
+
+  constexpr Slice() : Slice(nullptr, 0_usize) {}
 
   static constexpr inline Slice from_raw_parts(::sus::marker::UnsafeFnMarker,
                                                T* data,
                                                ::sus::usize len) noexcept {
-    ::sus::check(len.primitive_value <= static_cast<size_t>(isize::MAX_PRIMITIVE));
+    ::sus::check(len.primitive_value <=
+                 static_cast<size_t>(isize::MAX_PRIMITIVE));
     return Slice(data, len);
   }
 
@@ -314,13 +324,34 @@ class Slice {
     return SliceIterMut<T&>::with(data_, len_);
   }
 
+  Vec<std::remove_const_t<T>> to_vec() const&
+    requires(::sus::mem::Clone<T>);
+
  private:
   constexpr Slice(T* data, usize len) noexcept : data_(data), len_(len) {}
 
   T* data_;
   ::sus::usize len_;
+
+  sus_class_trivially_relocatable(::sus::marker::unsafe_fn, decltype(data_),
+                                  decltype(len_));
+
+  // Slice does not satisfy NeverValueField because it requires that the default
+  // constructor is trivial, but Slice's default constructor needs to initialize
+  // its fields.
 };
 
+template <class T>
+Vec<std::remove_const_t<T>> Slice<T>::to_vec() const&
+  requires(::sus::mem::Clone<T>)
+{
+  auto v = Vec<std::remove_const_t<T>>::with_capacity(len_);
+  for (::sus::usize i; i < len_; i += 1u) {
+    v.push(::sus::clone(data_[size_t{i}]));
+  }
+  return v;
+}
+
 // Implicit for-ranged loop iteration via `Slice::iter()`.
 using ::sus::iter::__private::begin;
 using ::sus::iter::__private::end;
diff --git a/subspace/containers/slice_unittest.cc b/subspace/containers/slice_unittest.cc
@@ -498,4 +498,44 @@ TEST(Slice, Default) {
   EXPECT_TRUE(s.is_empty());
 }
 
+TEST(Slice, ToVec) {
+  sus::Array<i32, 6> array = sus::array(3, 4, 2, 1, 6, 5);
+  auto slice =
+      sus::Slice<const i32>::from_raw_parts(unsafe_fn, array.as_ptr(), 6u);
+  EXPECT_EQ(array.as_ptr(), slice.as_ptr());
+  sus::Vec<i32> vec = slice.to_vec();
+  // The Vec is a new allocation.
+  EXPECT_NE(vec.as_ptr(), slice.as_ptr());
+  // And it has all the same content, cloned.
+  EXPECT_EQ(vec.len(), 6u);
+  EXPECT_EQ(vec[0u], 3);
+  EXPECT_EQ(vec[1u], 4);
+  EXPECT_EQ(vec[2u], 2);
+  EXPECT_EQ(vec[3u], 1);
+  EXPECT_EQ(vec[4u], 6);
+  EXPECT_EQ(vec[5u], 5);
+
+  // Verify Clone is used, not just Copy.
+  struct Cloner {
+    i32 i;
+
+    Cloner(i32 i) : i(i) {}
+
+    Cloner(Cloner&&) = default;
+    Cloner& operator=(Cloner&&) = default;
+
+    Cloner clone() const noexcept { return Cloner(i + 1); }
+  };
+  static_assert(sus::mem::Clone<Cloner>);
+  static_assert(!sus::mem::Copy<Cloner>);
+  sus::Array<Cloner, 2> v = sus::array(Cloner(1), Cloner(2));
+  sus::Vec<Cloner> v2 =
+      sus::Slice<const Cloner>::from_raw_parts(unsafe_fn, v.as_ptr(), 2u)
+          .to_vec();
+  EXPECT_NE(v.as_ptr(), v2.as_ptr());
+  EXPECT_EQ(v.len(), v2.len());
+  EXPECT_EQ(v[0u].i + 1, v2[0u].i);
+  EXPECT_EQ(v[1u].i + 1, v2[1u].i);
+}
+
 }  // namespace
diff --git a/subspace/containers/vec.h b/subspace/containers/vec.h
@@ -434,25 +434,25 @@ class Vec {
   }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort]
-  void sort() { as_mut().sort(); }
+  void sort() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_by]
   template <class F, int&...,
             class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_by(F compare) {
-    as_mut().sort_by(sus::move(compare));
+    as_mut_slice().sort_by(sus::move(compare));
   }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_unstable]
-  void sort_unstable() { as_mut().sort(); }
+  void sort_unstable() { as_mut_slice().sort(); }
 
   /// #[doc.inherit=[n]sus::[n]containers::[r]Slice::[f]sort_unstable_by]
   template <class F, int&...,
             class R = std::invoke_result_t<F, const T&, const T&>>
     requires(::sus::ops::Ordering<R>)
   void sort_unstable_by(F compare) {
-    as_mut().sort_by(sus::move(compare));
+    as_mut_slice().sort_by(sus::move(compare));
   }
 
   /// Returns a const pointer to the first element in the vector.
@@ -478,18 +478,18 @@ class Vec {
 
   // Returns a slice that references all the elements of the vector as const
   // references.
-  constexpr Slice<const T> as_ref() const& noexcept {
+  constexpr Slice<const T> as_slice() const& noexcept {
     check(!is_moved_from());
     // SAFETY: The `len_` is the number of elements in the Vec, and the pointer
     // is to the start of the Vec, so this Slice covers a valid range.
     return Slice<const T>::from_raw_parts(::sus::marker::unsafe_fn, storage_,
                                           len_);
   }
-  constexpr Slice<const T> as_ref() && = delete;
+  constexpr Slice<const T> as_slice() && = delete;
 
   // Returns a slice that references all the elements of the vector as mutable
   // references.
-  constexpr Slice<T> as_mut() & noexcept {
+  constexpr Slice<T> as_mut_slice() & noexcept {
     check(!is_moved_from());
     // SAFETY: The `len_` is the number of elements in the Vec, and the pointer
     // is to the start of the Vec, so this Slice covers a valid range.
@@ -568,6 +568,10 @@ class Vec {
   sus_class_trivially_relocatable_if_types(::sus::marker::unsafe_fn,
                                            decltype(storage_), decltype(len_),
                                            decltype(capacity_));
+
+  // Slice does not satisfy NeverValueField because it requires that the default
+  // constructor is trivial, but Slice's default constructor needs to initialize
+  // its fields.
 };
 
 // Implicit for-ranged loop iteration via `Vec::iter()`.
diff --git a/subspace/containers/vec_unittest.cc b/subspace/containers/vec_unittest.cc

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ class SubDocTest : public testing::Test {`
`35`	`35`	`auto args = sus::Vec<std::string>::with_capacity(1u);`
`36`	`36`	`args.push(std::string(subdoc::tests::cpp_version_flag(cpp_version_)));`
`37`	`37`
`38`		`- return subdoc::run_test(sus::move(content), args.as_ref(), options);`
	`38`	`+ return subdoc::run_test(sus::move(content), args.as_slice(), options);`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`auto run_code(std::string content) noexcept {`