Functions: refactor virtual array data structures

When a function is executed for many elements (e.g. per point) it is often the case
that some parameters are different for every element and other parameters are
the same (there are some more less common cases). To simplify writing such
functions one can use a "virtual array". This is a data structure that has a value
for every index, but might not be stored as an actual array internally. Instead, it
might be just a single value or is computed on the fly. There are various tradeoffs
involved when using this data structure which are mentioned in `BLI_virtual_array.hh`.
It is called "virtual", because it uses inheritance and virtual methods.

Furthermore, there is a new virtual vector array data structure, which is an array
of vectors. Both these types have corresponding generic variants, which can be used
when the data type is not known at compile time. This is typically the case when
building a somewhat generic execution system. The function system used these virtual
data structures before, but now they are more versatile.

I've done this refactor in preparation for the attribute processor and other features of
geometry nodes. I moved the typed virtual arrays to blenlib, so that they can be used
independent of the function system.

One open question for me is whether all the generic data structures (and `CPPType`)
should be moved to blenlib as well. They are well isolated and don't really contain
any business logic. That can be done later if necessary.

6 files changed, 123 insertions, 484 deletions

diff --git a/source/blender/functions/tests/FN_array_spans_test.cc b/source/blender/functions/tests/FN_array_spans_test.cc
deleted file mode 100644
index af2bc0aad91..00000000000
--- a/source/blender/functions/tests/FN_array_spans_test.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-/* Apache License, Version 2.0 */
-
-#include "testing/testing.h"
-
-#include "FN_array_spans.hh"
-#include "FN_generic_vector_array.hh"
-
-#include "BLI_array.hh"
-
-namespace blender::fn::tests {
-
-TEST(virtual_array_span, EmptyConstructor)
-{
-  VArraySpan<int> span;
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_TRUE(span.is_empty());
-
-  GVArraySpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 0);
-}
-
-TEST(virtual_array_span, SingleArrayConstructor)
-{
-  std::array<int, 4> values = {3, 4, 5, 6};
-  VArraySpan<int> span{Span<int>(values), 3};
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0].size(), 4);
-  EXPECT_EQ(span[1].size(), 4);
-  EXPECT_EQ(span[2].size(), 4);
-  EXPECT_EQ(span[0][0], 3);
-  EXPECT_EQ(span[0][1], 4);
-  EXPECT_EQ(span[0][2], 5);
-  EXPECT_EQ(span[0][3], 6);
-  EXPECT_EQ(span[1][3], 6);
-  EXPECT_EQ(span[2][1], 4);
-
-  GVArraySpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0].size(), 4);
-  EXPECT_EQ(converted[1].size(), 4);
-  EXPECT_EQ(converted[1][2], &values[2]);
-}
-
-TEST(virtual_array_span, MultipleArrayConstructor)
-{
-  std::array<int, 4> values0 = {1, 2, 3, 4};
-  std::array<int, 2> values1 = {6, 7};
-  std::array<int, 1> values2 = {8};
-  std::array<const int *, 3> starts = {values0.data(), values1.data(), values2.data()};
-  std::array<int64_t, 3> sizes{static_cast<int64_t>(values0.size()),
-                               static_cast<int64_t>(values1.size()),
-                               static_cast<int64_t>(values2.size())};
-
-  VArraySpan<int> span{starts, sizes};
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0].size(), 4);
-  EXPECT_EQ(span[1].size(), 2);
-  EXPECT_EQ(span[2].size(), 1);
-  EXPECT_EQ(&span[0][0], values0.data());
-  EXPECT_EQ(&span[1][0], values1.data());
-  EXPECT_EQ(&span[2][0], values2.data());
-  EXPECT_EQ(span[2][0], 8);
-  EXPECT_EQ(span[1][1], 7);
-
-  GVArraySpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0].size(), 4);
-  EXPECT_EQ(converted[1].size(), 2);
-  EXPECT_EQ(converted[2].size(), 1);
-  EXPECT_EQ(converted[0][0], values0.data());
-  EXPECT_EQ(converted[1][1], values1.data() + 1);
-}
-
-TEST(generic_virtual_array_span, TypeConstructor)
-{
-  GVArraySpan span{CPPType::get<int32_t>()};
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_TRUE(span.is_empty());
-
-  VArraySpan converted = span.typed<int>();
-  EXPECT_EQ(converted.size(), 0);
-}
-
-TEST(generic_virtual_array_span, GSpanConstructor)
-{
-  std::array<std::string, 3> values = {"hello", "world", "test"};
-  GVArraySpan span{GSpan(CPPType::get<std::string>(), values.data(), 3), 5};
-  EXPECT_EQ(span.size(), 5);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0][0], values.data());
-  EXPECT_EQ(span[1][0], values.data());
-  EXPECT_EQ(span[4][0], values.data());
-  EXPECT_EQ(span[0].size(), 3);
-  EXPECT_EQ(span[2].size(), 3);
-  EXPECT_EQ(*(std::string *)span[3][1], "world");
-
-  VArraySpan converted = span.typed<std::string>();
-  EXPECT_EQ(converted.size(), 5);
-  EXPECT_EQ(converted[0][0], "hello");
-  EXPECT_EQ(converted[1][0], "hello");
-  EXPECT_EQ(converted[4][0], "hello");
-  EXPECT_EQ(converted[0].size(), 3);
-  EXPECT_EQ(converted[2].size(), 3);
-}
-
-TEST(generic_virtual_array_span, IsSingleArray1)
-{
-  Array<int> values = {5, 6, 7};
-  GVArraySpan span{GSpan(values.as_span()), 4};
-  EXPECT_TRUE(span.is_single_array());
-
-  VArraySpan converted = span.typed<int>();
-  EXPECT_TRUE(converted.is_single_array());
-}
-
-TEST(generic_virtual_array_span, IsSingleArray2)
-{
-  GVectorArray vectors{CPPType::get<int32_t>(), 3};
-  GVectorArrayRef<int> vectors_ref = vectors;
-  vectors_ref.append(1, 4);
-
-  GVArraySpan span = vectors;
-  EXPECT_FALSE(span.is_single_array());
-
-  VArraySpan converted = span.typed<int>();
-  EXPECT_FALSE(converted.is_single_array());
-}
-
-}  // namespace blender::fn::tests
diff --git a/source/blender/functions/tests/FN_generic_span_test.cc b/source/blender/functions/tests/FN_generic_span_test.cc
new file mode 100644
index 00000000000..81057ee9c4f
--- /dev/null
+++ b/source/blender/functions/tests/FN_generic_span_test.cc
@@ -0,0 +1,53 @@
+/* Apache License, Version 2.0 */
+
+#include "testing/testing.h"
+
+#include "FN_generic_span.hh"
+
+namespace blender::fn::tests {
+
+TEST(generic_span, TypeConstructor)
+{
+  GSpan span(CPPType::get<float>());
+  EXPECT_EQ(span.size(), 0);
+  EXPECT_EQ(span.typed<float>().size(), 0);
+  EXPECT_TRUE(span.is_empty());
+}
+
+TEST(generic_span, BufferAndSizeConstructor)
+{
+  int values[4] = {6, 7, 3, 2};
+  void *buffer = (void *)values;
+  GSpan span(CPPType::get<int32_t>(), buffer, 4);
+  EXPECT_EQ(span.size(), 4);
+  EXPECT_FALSE(span.is_empty());
+  EXPECT_EQ(span.typed<int>().size(), 4);
+  EXPECT_EQ(span[0], &values[0]);
+  EXPECT_EQ(span[1], &values[1]);
+  EXPECT_EQ(span[2], &values[2]);
+  EXPECT_EQ(span[3], &values[3]);
+}
+
+TEST(generic_mutable_span, TypeConstructor)
+{
+  GMutableSpan span(CPPType::get<int32_t>());
+  EXPECT_EQ(span.size(), 0);
+  EXPECT_TRUE(span.is_empty());
+}
+
+TEST(generic_mutable_span, BufferAndSizeConstructor)
+{
+  int values[4] = {4, 7, 3, 5};
+  void *buffer = (void *)values;
+  GMutableSpan span(CPPType::get<int32_t>(), buffer, 4);
+  EXPECT_EQ(span.size(), 4);
+  EXPECT_FALSE(span.is_empty());
+  EXPECT_EQ(span.typed<int>().size(), 4);
+  EXPECT_EQ(values[2], 3);
+  *(int *)span[2] = 10;
+  EXPECT_EQ(values[2], 10);
+  span.typed<int>()[2] = 20;
+  EXPECT_EQ(values[2], 20);
+}
+
+}  // namespace blender::fn::tests
diff --git a/source/blender/functions/tests/FN_generic_vector_array_test.cc b/source/blender/functions/tests/FN_generic_vector_array_test.cc
index 77ec05f12dc..3e78aef4841 100644
--- a/source/blender/functions/tests/FN_generic_vector_array_test.cc
+++ b/source/blender/functions/tests/FN_generic_vector_array_test.cc
@@ -1,101 +1,43 @@
 /* Apache License, Version 2.0 */
 
-#include "FN_generic_vector_array.hh"
-
 #include "testing/testing.h"
 
+#include "FN_generic_vector_array.hh"
+
 namespace blender::fn::tests {
 
-TEST(generic_vector_array, Constructor)
+TEST(generic_vector_array, Construct)
 {
-  GVectorArray vectors{CPPType::get<int32_t>(), 3};
-  EXPECT_EQ(vectors.size(), 3);
-  EXPECT_EQ(vectors.lengths().size(), 3);
-  EXPECT_EQ(vectors.starts().size(), 3);
-  EXPECT_EQ(vectors.lengths()[0], 0);
-  EXPECT_EQ(vectors.lengths()[1], 0);
-  EXPECT_EQ(vectors.lengths()[2], 0);
-  EXPECT_EQ(vectors.type(), CPPType::get<int32_t>());
+  GVectorArray vector_array{CPPType::get<int>(), 4};
+  EXPECT_EQ(vector_array.size(), 4);
+  EXPECT_FALSE(vector_array.is_empty());
 }
 
 TEST(generic_vector_array, Append)
 {
-  GVectorArray vectors{CPPType::get<std::string>(), 3};
-  std::string value = "hello";
-  vectors.append(0, &value);
-  value = "world";
-  vectors.append(0, &value);
-  vectors.append(2, &value);
-
-  EXPECT_EQ(vectors.lengths()[0], 2);
-  EXPECT_EQ(vectors.lengths()[1], 0);
-  EXPECT_EQ(vectors.lengths()[2], 1);
-  EXPECT_EQ(vectors[0].size(), 2);
-  EXPECT_EQ(vectors[0].typed<std::string>()[0], "hello");
-  EXPECT_EQ(vectors[0].typed<std::string>()[1], "world");
-  EXPECT_EQ(vectors[2].typed<std::string>()[0], "world");
-}
-
-TEST(generic_vector_array, AsArraySpan)
-{
-  GVectorArray vectors{CPPType::get<int32_t>(), 3};
-  int value = 3;
-  vectors.append(0, &value);
-  vectors.append(0, &value);
-  value = 5;
-  vectors.append(2, &value);
-  vectors.append(2, &value);
-  vectors.append(2, &value);
-
-  GVArraySpan span = vectors;
-  EXPECT_EQ(span.type(), CPPType::get<int32_t>());
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_EQ(span[0].size(), 2);
-  EXPECT_EQ(span[1].size(), 0);
-  EXPECT_EQ(span[2].size(), 3);
-  EXPECT_EQ(span[0].typed<int>()[1], 3);
-  EXPECT_EQ(span[2].typed<int>()[0], 5);
-}
-
-TEST(generic_vector_array, TypedRef)
-{
-  GVectorArray vectors{CPPType::get<int32_t>(), 4};
-  GVectorArrayRef<int> ref = vectors.typed<int>();
-  ref.append(0, 2);
-  ref.append(0, 6);
-  ref.append(0, 7);
-  ref.append(2, 1);
-  ref.append(2, 1);
-  ref.append(3, 5);
-  ref.append(3, 6);
-
-  EXPECT_EQ(ref[0].size(), 3);
-  EXPECT_EQ(vectors[0].size(), 3);
-  EXPECT_EQ(ref[0][0], 2);
-  EXPECT_EQ(ref[0][1], 6);
-  EXPECT_EQ(ref[0][2], 7);
-  EXPECT_EQ(ref[1].size(), 0);
-  EXPECT_EQ(ref[2][0], 1);
-  EXPECT_EQ(ref[2][1], 1);
-  EXPECT_EQ(ref[3][0], 5);
-  EXPECT_EQ(ref[3][1], 6);
+  GVectorArray vector_array{CPPType::get<int>(), 3};
+  int value1 = 2;
+  vector_array.append(1, &value1);
+  vector_array.append(1, &value1);
+  int value2 = 3;
+  vector_array.append(0, &value2);
+  vector_array.append(1, &value2);
+
+  EXPECT_EQ(vector_array[0].size(), 1);
+  EXPECT_EQ(vector_array[1].size(), 3);
+  EXPECT_EQ(vector_array[2].size(), 0);
 }
 
 TEST(generic_vector_array, Extend)
 {
-  GVectorArray vectors{CPPType::get<int32_t>(), 3};
-  GVectorArrayRef<int> ref = vectors;
-
-  ref.extend(1, {5, 6, 7});
-  ref.extend(0, {3});
-
-  EXPECT_EQ(vectors[0].size(), 1);
-  EXPECT_EQ(vectors[1].size(), 3);
-  EXPECT_EQ(vectors[2].size(), 0);
-  EXPECT_EQ(ref[1][0], 5);
-  EXPECT_EQ(ref[1][1], 6);
-  EXPECT_EQ(ref[1][2], 7);
-  EXPECT_EQ(ref[0][0], 3);
+  GVectorArray vector_array{CPPType::get<int>(), 3};
+  vector_array.extend(0, Span<int>({1, 4, 6, 4}));
+  vector_array.extend(1, Span<int>());
+  vector_array.extend(0, Span<int>({10, 20, 30}));
+
+  EXPECT_EQ(vector_array[0].size(), 7);
+  EXPECT_EQ(vector_array[1].size(), 0);
+  EXPECT_EQ(vector_array[2].size(), 0);
 }
 
 }  // namespace blender::fn::tests
diff --git a/source/blender/functions/tests/FN_multi_function_network_test.cc b/source/blender/functions/tests/FN_multi_function_network_test.cc
index f226e0eac2e..70da0315b93 100644
--- a/source/blender/functions/tests/FN_multi_function_network_test.cc
+++ b/source/blender/functions/tests/FN_multi_function_network_test.cc
@@ -76,12 +76,9 @@ class ConcatVectorsFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    GVectorArrayRef<int> a = params.vector_mutable<int>(0);
-    VArraySpan<int> b = params.readonly_vector_input<int>(1);
-
-    for (int64_t i : mask) {
-      a.extend(i, b[i]);
-    }
+    GVectorArray &a = params.vector_mutable(0);
+    const GVVectorArray &b = params.readonly_vector_input(1);
+    a.extend(mask, b);
   }
 };
 
@@ -96,8 +93,8 @@ class AppendFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    GVectorArrayRef<int> vectors = params.vector_mutable<int>(0);
-    VSpan<int> values = params.readonly_single_input<int>(1);
+    GVectorArray_TypedMutableRef<int> vectors = params.vector_mutable<int>(0);
+    const VArray<int> &values = params.readonly_single_input<int>(1);
 
     for (int64_t i : mask) {
       vectors.append(i, values[i]);
@@ -116,14 +113,13 @@ class SumVectorFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    VArraySpan<int> vectors = params.readonly_vector_input<int>(0);
+    const VVectorArray<int> &vectors = params.readonly_vector_input<int>(0);
     MutableSpan<int> sums = params.uninitialized_single_output<int>(1);
 
     for (int64_t i : mask) {
       int sum = 0;
-      VSpan<int> vector = vectors[i];
-      for (int j = 0; j < vector.size(); j++) {
-        sum += vector[j];
+      for (int j : IndexRange(vectors.get_vector_size(i))) {
+        sum += vectors.get_vector_element(i, j);
       }
       sums[i] = sum;
     }
@@ -141,8 +137,8 @@ class CreateRangeFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    VSpan<int> sizes = params.readonly_single_input<int>(0, "Size");
-    GVectorArrayRef<int> ranges = params.vector_output<int>(1, "Range");
+    const VArray<int> &sizes = params.readonly_single_input<int>(0, "Size");
+    GVectorArray_TypedMutableRef<int> ranges = params.vector_output<int>(1, "Range");
 
     for (int64_t i : mask) {
       int size = sizes[i];
@@ -199,7 +195,8 @@ TEST(multi_function_network, Test2)
     Array<int> output_value_2(5, -1);
 
     MFParamsBuilder params(network_fn, 5);
-    params.add_readonly_vector_input(GVArraySpan(input_value_1.as_span(), 5));
+    GVVectorArrayForSingleGSpan inputs_1{input_value_1.as_span(), 5};
+    params.add_readonly_vector_input(inputs_1);
     params.add_readonly_single_input(&input_value_2);
     params.add_vector_output(output_value_1);
     params.add_uninitialized_single_output(output_value_2.as_mutable_span());
@@ -222,9 +219,9 @@ TEST(multi_function_network, Test2)
   }
   {
     GVectorArray input_value_1(CPPType::get<int32_t>(), 3);
-    GVectorArrayRef<int> input_value_ref_1 = input_value_1;
-    input_value_ref_1.extend(0, {3, 4, 5});
-    input_value_ref_1.extend(1, {1, 2});
+    GVectorArray_TypedMutableRef<int> input_value_1_ref{input_value_1};
+    input_value_1_ref.extend(0, {3, 4, 5});
+    input_value_1_ref.extend(1, {1, 2});
 
     Array<int> input_value_2 = {4, 2, 3};
 
diff --git a/source/blender/functions/tests/FN_multi_function_test.cc b/source/blender/functions/tests/FN_multi_function_test.cc
index cc023bce597..3ed60665149 100644
--- a/source/blender/functions/tests/FN_multi_function_test.cc
+++ b/source/blender/functions/tests/FN_multi_function_test.cc
@@ -20,8 +20,8 @@ class AddFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    VSpan<int> a = params.readonly_single_input<int>(0, "A");
-    VSpan<int> b = params.readonly_single_input<int>(1, "B");
+    const VArray<int> &a = params.readonly_single_input<int>(0, "A");
+    const VArray<int> &b = params.readonly_single_input<int>(1, "B");
     MutableSpan<int> result = params.uninitialized_single_output<int>(2, "Result");
 
     for (int64_t i : mask) {
@@ -63,7 +63,7 @@ class AddPrefixFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    VSpan<std::string> prefixes = params.readonly_single_input<std::string>(0, "Prefix");
+    const VArray<std::string> &prefixes = params.readonly_single_input<std::string>(0, "Prefix");
     MutableSpan<std::string> strings = params.single_mutable<std::string>(1, "Strings");
 
     for (int64_t i : mask) {
@@ -110,13 +110,13 @@ class CreateRangeFunction : public MultiFunction {
 
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
-    VSpan<uint> sizes = params.readonly_single_input<uint>(0, "Size");
-    GVectorArrayRef<uint> ranges = params.vector_output<uint>(1, "Range");
+    const VArray<uint> &sizes = params.readonly_single_input<uint>(0, "Size");
+    GVectorArray &ranges = params.vector_output(1, "Range");
 
     for (int64_t i : mask) {
       uint size = sizes[i];
       for (uint j : IndexRange(size)) {
-        ranges.append(i, j);
+        ranges.append(i, &j);
       }
     }
   }
@@ -127,7 +127,7 @@ TEST(multi_function, CreateRangeFunction)
   CreateRangeFunction fn;
 
   GVectorArray ranges(CPPType::get<uint>(), 5);
-  GVectorArrayRef<uint> ranges_ref(ranges);
+  GVectorArray_TypedMutableRef<uint> ranges_ref{ranges};
   Array<uint> sizes = {3, 0, 6, 1, 4};
 
   MFParamsBuilder params(fn, ranges.size());
@@ -138,11 +138,11 @@ TEST(multi_function, CreateRangeFunction)
 
   fn.call({0, 1, 2, 3}, params, context);
 
-  EXPECT_EQ(ranges_ref[0].size(), 3);
-  EXPECT_EQ(ranges_ref[1].size(), 0);
-  EXPECT_EQ(ranges_ref[2].size(), 6);
-  EXPECT_EQ(ranges_ref[3].size(), 1);
-  EXPECT_EQ(ranges_ref[4].size(), 0);
+  EXPECT_EQ(ranges[0].size(), 3);
+  EXPECT_EQ(ranges[1].size(), 0);
+  EXPECT_EQ(ranges[2].size(), 6);
+  EXPECT_EQ(ranges[3].size(), 1);
+  EXPECT_EQ(ranges[4].size(), 0);
 
   EXPECT_EQ(ranges_ref[0][0], 0);
   EXPECT_EQ(ranges_ref[0][1], 1);
@@ -163,10 +163,13 @@ class GenericAppendFunction : public MultiFunction {
   void call(IndexMask mask, MFParams params, MFContext UNUSED(context)) const override
   {
     GVectorArray &vectors = params.vector_mutable(0, "Vector");
-    GVSpan values = params.readonly_single_input(1, "Value");
+    const GVArray &values = params.readonly_single_input(1, "Value");
 
     for (int64_t i : mask) {
-      vectors.append(i, values[i]);
+      BUFFER_FOR_CPP_TYPE_VALUE(values.type(), buffer);
+      values.get(i, buffer);
+      vectors.append(i, buffer);
+      values.type().destruct(buffer);
     }
   }
 };
@@ -176,7 +179,7 @@ TEST(multi_function, GenericAppendFunction)
   GenericAppendFunction fn(CPPType::get<int32_t>());
 
   GVectorArray vectors(CPPType::get<int32_t>(), 4);
-  GVectorArrayRef<int> vectors_ref(vectors);
+  GVectorArray_TypedMutableRef<int> vectors_ref{vectors};
   vectors_ref.append(0, 1);
   vectors_ref.append(0, 2);
   vectors_ref.append(2, 6);
@@ -190,10 +193,10 @@ TEST(multi_function, GenericAppendFunction)
 
   fn.call(IndexRange(vectors.size()), params, context);
 
-  EXPECT_EQ(vectors_ref[0].size(), 3);
-  EXPECT_EQ(vectors_ref[1].size(), 1);
-  EXPECT_EQ(vectors_ref[2].size(), 2);
-  EXPECT_EQ(vectors_ref[3].size(), 1);
+  EXPECT_EQ(vectors[0].size(), 3);
+  EXPECT_EQ(vectors[1].size(), 1);
+  EXPECT_EQ(vectors[2].size(), 2);
+  EXPECT_EQ(vectors[3].size(), 1);
 
   EXPECT_EQ(vectors_ref[0][0], 1);
   EXPECT_EQ(vectors_ref[0][1], 2);
@@ -342,11 +345,11 @@ TEST(multi_function, CustomMF_GenericConstantArray)
   CustomMF_GenericConstantArray fn{GSpan(Span(values))};
   EXPECT_EQ(fn.param_name(0), "[3, 4, 5, 6, ]");
 
-  GVectorArray g_vector_array{CPPType::get<int32_t>(), 4};
-  GVectorArrayRef<int> vector_array = g_vector_array;
+  GVectorArray vector_array{CPPType::get<int32_t>(), 4};
+  GVectorArray_TypedMutableRef<int> vector_array_ref{vector_array};
 
-  MFParamsBuilder params(fn, g_vector_array.size());
-  params.add_vector_output(g_vector_array);
+  MFParamsBuilder params(fn, vector_array.size());
+  params.add_vector_output(vector_array);
 
   MFContextBuilder context;
 
@@ -357,10 +360,10 @@ TEST(multi_function, CustomMF_GenericConstantArray)
   EXPECT_EQ(vector_array[2].size(), 4);
   EXPECT_EQ(vector_array[3].size(), 4);
   for (int i = 1; i < 4; i++) {
-    EXPECT_EQ(vector_array[i][0], 3);
-    EXPECT_EQ(vector_array[i][1], 4);
-    EXPECT_EQ(vector_array[i][2], 5);
-    EXPECT_EQ(vector_array[i][3], 6);
+    EXPECT_EQ(vector_array_ref[i][0], 3);
+    EXPECT_EQ(vector_array_ref[i][1], 4);
+    EXPECT_EQ(vector_array_ref[i][2], 5);
+    EXPECT_EQ(vector_array_ref[i][3], 6);
   }
 }
 
diff --git a/source/blender/functions/tests/FN_spans_test.cc b/source/blender/functions/tests/FN_spans_test.cc
deleted file mode 100644
index fbcf1fda71e..00000000000
--- a/source/blender/functions/tests/FN_spans_test.cc
+++ /dev/null
@@ -1,222 +0,0 @@
-/* Apache License, Version 2.0 */
-
-#include "testing/testing.h"
-
-#include "FN_spans.hh"
-
-namespace blender::fn::tests {
-
-TEST(generic_span, TypeConstructor)
-{
-  GSpan span(CPPType::get<float>());
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_EQ(span.typed<float>().size(), 0);
-  EXPECT_TRUE(span.is_empty());
-}
-
-TEST(generic_span, BufferAndSizeConstructor)
-{
-  int values[4] = {6, 7, 3, 2};
-  void *buffer = (void *)values;
-  GSpan span(CPPType::get<int32_t>(), buffer, 4);
-  EXPECT_EQ(span.size(), 4);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span.typed<int>().size(), 4);
-  EXPECT_EQ(span[0], &values[0]);
-  EXPECT_EQ(span[1], &values[1]);
-  EXPECT_EQ(span[2], &values[2]);
-  EXPECT_EQ(span[3], &values[3]);
-}
-
-TEST(generic_mutable_span, TypeConstructor)
-{
-  GMutableSpan span(CPPType::get<int32_t>());
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_TRUE(span.is_empty());
-}
-
-TEST(generic_mutable_span, BufferAndSizeConstructor)
-{
-  int values[4] = {4, 7, 3, 5};
-  void *buffer = (void *)values;
-  GMutableSpan span(CPPType::get<int32_t>(), buffer, 4);
-  EXPECT_EQ(span.size(), 4);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span.typed<int>().size(), 4);
-  EXPECT_EQ(values[2], 3);
-  *(int *)span[2] = 10;
-  EXPECT_EQ(values[2], 10);
-  span.typed<int>()[2] = 20;
-  EXPECT_EQ(values[2], 20);
-}
-
-TEST(virtual_span, EmptyConstructor)
-{
-  VSpan<int> span;
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_TRUE(span.is_empty());
-  EXPECT_FALSE(span.is_single_element());
-  EXPECT_TRUE(span.is_full_array());
-
-  GVSpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 0);
-}
-
-TEST(virtual_span, SpanConstructor)
-{
-  std::array<int, 5> values = {7, 3, 8, 6, 4};
-  Span<int> span = values;
-  VSpan<int> virtual_span = span;
-  EXPECT_EQ(virtual_span.size(), 5);
-  EXPECT_FALSE(virtual_span.is_empty());
-  EXPECT_EQ(virtual_span[0], 7);
-  EXPECT_EQ(virtual_span[2], 8);
-  EXPECT_EQ(virtual_span[3], 6);
-  EXPECT_FALSE(virtual_span.is_single_element());
-  EXPECT_TRUE(virtual_span.is_full_array());
-
-  GVSpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 5);
-}
-
-TEST(virtual_span, PointerSpanConstructor)
-{
-  int x0 = 3;
-  int x1 = 6;
-  int x2 = 7;
-  std::array<const int *, 3> pointers = {&x0, &x2, &x1};
-  VSpan<int> span = Span<const int *>(pointers);
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0], 3);
-  EXPECT_EQ(span[1], 7);
-  EXPECT_EQ(span[2], 6);
-  EXPECT_EQ(&span[1], &x2);
-  EXPECT_FALSE(span.is_single_element());
-  EXPECT_FALSE(span.is_full_array());
-
-  GVSpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0], &x0);
-  EXPECT_EQ(converted[1], &x2);
-  EXPECT_EQ(converted[2], &x1);
-}
-
-TEST(virtual_span, SingleConstructor)
-{
-  int value = 5;
-  VSpan<int> span = VSpan<int>::FromSingle(&value, 3);
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0], 5);
-  EXPECT_EQ(span[1], 5);
-  EXPECT_EQ(span[2], 5);
-  EXPECT_EQ(&span[0], &value);
-  EXPECT_EQ(&span[1], &value);
-  EXPECT_EQ(&span[2], &value);
-  EXPECT_TRUE(span.is_single_element());
-  EXPECT_FALSE(span.is_full_array());
-
-  GVSpan converted(span);
-  EXPECT_EQ(converted.type(), CPPType::get<int>());
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0], &value);
-  EXPECT_EQ(converted[1], &value);
-  EXPECT_EQ(converted[2], &value);
-}
-
-TEST(generic_virtual_span, TypeConstructor)
-{
-  GVSpan span(CPPType::get<int32_t>());
-  EXPECT_EQ(span.size(), 0);
-  EXPECT_TRUE(span.is_empty());
-  EXPECT_FALSE(span.is_single_element());
-  EXPECT_TRUE(span.is_full_array());
-
-  VSpan<int> converted = span.typed<int>();
-  EXPECT_EQ(converted.size(), 0);
-}
-
-TEST(generic_virtual_span, GenericSpanConstructor)
-{
-  int values[4] = {3, 4, 5, 6};
-  GVSpan span{GSpan(CPPType::get<int32_t>(), values, 4)};
-  EXPECT_EQ(span.size(), 4);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0], &values[0]);
-  EXPECT_EQ(span[1], &values[1]);
-  EXPECT_EQ(span[2], &values[2]);
-  EXPECT_EQ(span[3], &values[3]);
-  EXPECT_FALSE(span.is_single_element());
-  EXPECT_TRUE(span.is_full_array());
-
-  int materialized[4] = {0};
-  span.materialize_to_uninitialized(materialized);
-  EXPECT_EQ(materialized[0], 3);
-  EXPECT_EQ(materialized[1], 4);
-  EXPECT_EQ(materialized[2], 5);
-  EXPECT_EQ(materialized[3], 6);
-
-  VSpan<int> converted = span.typed<int>();
-  EXPECT_EQ(converted.size(), 4);
-  EXPECT_EQ(converted[0], 3);
-  EXPECT_EQ(converted[1], 4);
-  EXPECT_EQ(converted[2], 5);
-  EXPECT_EQ(converted[3], 6);
-}
-
-TEST(generic_virtual_span, SpanConstructor)
-{
-  std::array<int, 3> values = {6, 7, 8};
-  GVSpan span{Span<int>(values)};
-  EXPECT_EQ(span.type(), CPPType::get<int32_t>());
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_EQ(span[0], &values[0]);
-  EXPECT_EQ(span[1], &values[1]);
-  EXPECT_EQ(span[2], &values[2]);
-  EXPECT_FALSE(span.is_single_element());
-  EXPECT_TRUE(span.is_full_array());
-
-  int materialized[3] = {0};
-  span.materialize_to_uninitialized(materialized);
-  EXPECT_EQ(materialized[0], 6);
-  EXPECT_EQ(materialized[1], 7);
-  EXPECT_EQ(materialized[2], 8);
-
-  VSpan<int> converted = span.typed<int>();
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0], 6);
-  EXPECT_EQ(converted[1], 7);
-  EXPECT_EQ(converted[2], 8);
-}
-
-TEST(generic_virtual_span, SingleConstructor)
-{
-  int value = 5;
-  GVSpan span = GVSpan::FromSingle(CPPType::get<int32_t>(), &value, 3);
-  EXPECT_EQ(span.size(), 3);
-  EXPECT_FALSE(span.is_empty());
-  EXPECT_EQ(span[0], &value);
-  EXPECT_EQ(span[1], &value);
-  EXPECT_EQ(span[2], &value);
-  EXPECT_TRUE(span.is_single_element());
-  EXPECT_EQ(span.as_single_element(), &value);
-  EXPECT_FALSE(span.is_full_array());
-
-  int materialized[3] = {0};
-  span.materialize_to_uninitialized({1, 2}, materialized);
-  EXPECT_EQ(materialized[0], 0);
-  EXPECT_EQ(materialized[1], 5);
-  EXPECT_EQ(materialized[2], 5);
-
-  VSpan<int> converted = span.typed<int>();
-  EXPECT_EQ(converted.size(), 3);
-  EXPECT_EQ(converted[0], 5);
-  EXPECT_EQ(converted[1], 5);
-  EXPECT_EQ(converted[2], 5);
-}
-
-}  // namespace blender::fn::tests