BLI: rename resource collector to resource scope

Differential Revision: https://developer.blender.org/D10857

4 files changed, 75 insertions, 83 deletions

diff --git a/source/blender/functions/FN_multi_function_network_optimization.hh b/source/blender/functions/FN_multi_function_network_optimization.hh
index 6d0165643ce..96664fa368e 100644
--- a/source/blender/functions/FN_multi_function_network_optimization.hh
+++ b/source/blender/functions/FN_multi_function_network_optimization.hh
@@ -18,12 +18,12 @@
 
 #include "FN_multi_function_network.hh"
 
-#include "BLI_resource_collector.hh"
+#include "BLI_resource_scope.hh"
 
 namespace blender::fn::mf_network_optimization {
 
 void dead_node_removal(MFNetwork &network);
-void constant_folding(MFNetwork &network, ResourceCollector &resources);
+void constant_folding(MFNetwork &network, ResourceScope &scope);
 void common_subnetwork_elimination(MFNetwork &network);
 
 }  // namespace blender::fn::mf_network_optimization
diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh
index 2d3a8dd650e..72ebc0d9b94 100644
--- a/source/blender/functions/FN_multi_function_params.hh
+++ b/source/blender/functions/FN_multi_function_params.hh
@@ -25,7 +25,7 @@
  * the function. `MFParams` is then used inside the called function to access the parameters.
  */
 
-#include "BLI_resource_collector.hh"
+#include "BLI_resource_scope.hh"
 
 #include "FN_generic_vector_array.hh"
 #include "FN_generic_virtual_vector_array.hh"
@@ -35,7 +35,7 @@ namespace blender::fn {
 
 class MFParamsBuilder {
  private:
-  ResourceCollector resources_;
+  ResourceScope scope_;
   const MFSignature *signature_;
   int64_t min_array_size_;
   Vector<const GVArray *> virtual_arrays_;
@@ -55,13 +55,13 @@ class MFParamsBuilder {
 
   template<typename T> void add_readonly_single_input(const T *value, StringRef expected_name = "")
   {
-    this->add_readonly_single_input(resources_.construct<GVArrayForSingleValueRef>(
+    this->add_readonly_single_input(scope_.construct<GVArrayForSingleValueRef>(
                                         __func__, CPPType::get<T>(), min_array_size_, value),
                                     expected_name);
   }
   void add_readonly_single_input(const GSpan span, StringRef expected_name = "")
   {
-    this->add_readonly_single_input(resources_.construct<GVArrayForGSpan>(__func__, span),
+    this->add_readonly_single_input(scope_.construct<GVArrayForGSpan>(__func__, span),
                                     expected_name);
   }
   void add_readonly_single_input(const GVArray &ref, StringRef expected_name = "")
@@ -74,7 +74,7 @@ class MFParamsBuilder {
   void add_readonly_vector_input(const GVectorArray &vector_array, StringRef expected_name = "")
   {
     this->add_readonly_vector_input(
-        resources_.construct<GVVectorArrayForGVectorArray>(__func__, vector_array), expected_name);
+        scope_.construct<GVVectorArrayForGVectorArray>(__func__, vector_array), expected_name);
   }
   void add_readonly_vector_input(const GVVectorArray &ref, StringRef expected_name = "")
   {
@@ -136,9 +136,9 @@ class MFParamsBuilder {
     return *vector_arrays_[data_index];
   }
 
-  ResourceCollector &resources()
+  ResourceScope &resource_scope()
   {
-    return resources_;
+    return scope_;
   }
 
  private:
@@ -177,7 +177,7 @@ class MFParams {
   template<typename T> const VArray<T> &readonly_single_input(int param_index, StringRef name = "")
   {
     const GVArray &array = this->readonly_single_input(param_index, name);
-    return builder_->resources_.construct<VArrayForGVArray<T>>(__func__, array);
+    return builder_->scope_.construct<VArrayForGVArray<T>>(__func__, array);
   }
   const GVArray &readonly_single_input(int param_index, StringRef name = "")
   {
@@ -202,7 +202,7 @@ class MFParams {
   const VVectorArray<T> &readonly_vector_input(int param_index, StringRef name = "")
   {
     const GVVectorArray &vector_array = this->readonly_vector_input(param_index, name);
-    return builder_->resources_.construct<VVectorArrayForGVVectorArray<T>>(__func__, vector_array);
+    return builder_->scope_.construct<VVectorArrayForGVVectorArray<T>>(__func__, vector_array);
   }
   const GVVectorArray &readonly_vector_input(int param_index, StringRef name = "")
   {
diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc
index daa0a42963a..86ac4f6a179 100644
--- a/source/blender/functions/intern/multi_function_network_evaluation.cc
+++ b/source/blender/functions/intern/multi_function_network_evaluation.cc
@@ -37,7 +37,7 @@
 
 #include "FN_multi_function_network_evaluation.hh"
 
-#include "BLI_resource_collector.hh"
+#include "BLI_resource_scope.hh"
 #include "BLI_stack.hh"
 
 namespace blender::fn {
@@ -70,13 +70,10 @@ class MFNetworkEvaluationStorage {
   void add_vector_output_from_caller(const MFOutputSocket &socket, GVectorArray &vector_array);
 
   /* Get input buffers for function node evaluations. */
-  const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceCollector &resources);
-  const GVArray &get_single_input__single(const MFInputSocket &socket,
-                                          ResourceCollector &resources);
-  const GVVectorArray &get_vector_input__full(const MFInputSocket &socket,
-                                              ResourceCollector &resources);
-  const GVVectorArray &get_vector_input__single(const MFInputSocket &socket,
-                                                ResourceCollector &resources);
+  const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceScope &scope);
+  const GVArray &get_single_input__single(const MFInputSocket &socket, ResourceScope &scope);
+  const GVVectorArray &get_vector_input__full(const MFInputSocket &socket, ResourceScope &scope);
+  const GVVectorArray &get_vector_input__single(const MFInputSocket &socket, ResourceScope &scope);
 
   /* Get output buffers for function node evaluations. */
   GMutableSpan get_single_output__full(const MFOutputSocket &socket);
@@ -87,16 +84,16 @@ class MFNetworkEvaluationStorage {
   /* Get mutable buffers for function node evaluations. */
   GMutableSpan get_mutable_single__full(const MFInputSocket &input,
                                         const MFOutputSocket &output,
-                                        ResourceCollector &resources);
+                                        ResourceScope &scope);
   GMutableSpan get_mutable_single__single(const MFInputSocket &input,
                                           const MFOutputSocket &output,
-                                          ResourceCollector &resources);
+                                          ResourceScope &scope);
   GVectorArray &get_mutable_vector__full(const MFInputSocket &input,
                                          const MFOutputSocket &output,
-                                         ResourceCollector &resources);
+                                         ResourceScope &scope);
   GVectorArray &get_mutable_vector__single(const MFInputSocket &input,
                                            const MFOutputSocket &output,
-                                           ResourceCollector &resources);
+                                           ResourceScope &scope);
 
   /* Mark a node as being done with evaluation. This might free temporary buffers that are no
    * longer needed. */
@@ -277,20 +274,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
     /* The function output would be the same for all elements. Therefore, it is enough to call the
      * function only on a single element. This can avoid many duplicate computations. */
     MFParamsBuilder params{function, 1};
-    ResourceCollector &resources = params.resources();
+    ResourceScope &scope = params.resource_scope();
 
     for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          const GVArray &values = storage.get_single_input__single(socket, resources);
+          const GVArray &values = storage.get_single_input__single(socket, scope);
           params.add_readonly_single_input(values);
           break;
         }
         case MFParamType::VectorInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          const GVVectorArray &values = storage.get_vector_input__single(socket, resources);
+          const GVVectorArray &values = storage.get_vector_input__single(socket, scope);
           params.add_readonly_vector_input(values);
           break;
         }
@@ -309,14 +306,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
         case MFParamType::SingleMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GMutableSpan values = storage.get_mutable_single__single(input, output, resources);
+          GMutableSpan values = storage.get_mutable_single__single(input, output, scope);
           params.add_single_mutable(values);
           break;
         }
         case MFParamType::VectorMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GVectorArray &values = storage.get_mutable_vector__single(input, output, resources);
+          GVectorArray &values = storage.get_mutable_vector__single(input, output, scope);
           params.add_vector_mutable(values);
           break;
         }
@@ -327,20 +324,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
   }
   else {
     MFParamsBuilder params{function, storage.mask().min_array_size()};
-    ResourceCollector &resources = params.resources();
+    ResourceScope &scope = params.resource_scope();
 
     for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          const GVArray &values = storage.get_single_input__full(socket, resources);
+          const GVArray &values = storage.get_single_input__full(socket, scope);
           params.add_readonly_single_input(values);
           break;
         }
         case MFParamType::VectorInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          const GVVectorArray &values = storage.get_vector_input__full(socket, resources);
+          const GVVectorArray &values = storage.get_vector_input__full(socket, scope);
           params.add_readonly_vector_input(values);
           break;
         }
@@ -359,14 +356,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
         case MFParamType::SingleMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GMutableSpan values = storage.get_mutable_single__full(input, output, resources);
+          GMutableSpan values = storage.get_mutable_single__full(input, output, scope);
           params.add_single_mutable(values);
           break;
         }
         case MFParamType::VectorMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GVectorArray &values = storage.get_mutable_vector__full(input, output, resources);
+          GVectorArray &values = storage.get_mutable_vector__full(input, output, scope);
           params.add_vector_mutable(values);
           break;
         }
@@ -400,19 +397,19 @@ bool MFNetworkEvaluator::can_do_single_value_evaluation(const MFFunctionNode &fu
 BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs(
     MFParams params, Storage &storage, Span<const MFInputSocket *> remaining_outputs) const
 {
-  ResourceCollector resources;
+  ResourceScope scope;
   for (const MFInputSocket *socket : remaining_outputs) {
     int param_index = inputs_.size() + outputs_.first_index_of(socket);
 
     switch (socket->data_type().category()) {
       case MFDataType::Single: {
-        const GVArray &values = storage.get_single_input__full(*socket, resources);
+        const GVArray &values = storage.get_single_input__full(*socket, scope);
         GMutableSpan output_values = params.uninitialized_single_output(param_index);
         values.materialize_to_uninitialized(storage.mask(), output_values.data());
         break;
       }
       case MFDataType::Vector: {
-        const GVVectorArray &values = storage.get_vector_input__full(*socket, resources);
+        const GVVectorArray &values = storage.get_vector_input__full(*socket, scope);
         GVectorArray &output_values = params.vector_output(param_index);
         output_values.extend(storage.mask(), values);
         break;
@@ -796,7 +793,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp
 
 GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputSocket &input,
                                                                   const MFOutputSocket &output,
-                                                                  ResourceCollector &resources)
+                                                                  ResourceScope &scope)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -810,7 +807,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
     GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
-    const GVArray &virtual_array = this->get_single_input__full(input, resources);
+    const GVArray &virtual_array = this->get_single_input__full(input, scope);
     virtual_array.materialize_to_uninitialized(mask_, span.data());
     return span;
   }
@@ -825,7 +822,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
     }
   }
 
-  const GVArray &virtual_array = this->get_single_input__full(input, resources);
+  const GVArray &virtual_array = this->get_single_input__full(input, scope);
   void *new_buffer = MEM_mallocN_aligned(min_array_size_ * type.size(), type.alignment(), AT);
   GMutableSpan new_array_ref(type, new_buffer, min_array_size_);
   virtual_array.materialize_to_uninitialized(mask_, new_array_ref.data());
@@ -838,7 +835,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
 
 GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInputSocket &input,
                                                                     const MFOutputSocket &output,
-                                                                    ResourceCollector &resources)
+                                                                    ResourceScope &scope)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -853,7 +850,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
     GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
     BLI_assert(span.size() == 1);
-    const GVArray &virtual_array = this->get_single_input__single(input, resources);
+    const GVArray &virtual_array = this->get_single_input__single(input, scope);
     virtual_array.get_single_to_uninitialized(span[0]);
     return span;
   }
@@ -869,7 +866,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
     }
   }
 
-  const GVArray &virtual_array = this->get_single_input__single(input, resources);
+  const GVArray &virtual_array = this->get_single_input__single(input, scope);
 
   void *new_buffer = allocator_.allocate(type.size(), type.alignment());
   virtual_array.get_single_to_uninitialized(new_buffer);
@@ -883,7 +880,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
 
 GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInputSocket &input,
                                                                    const MFOutputSocket &output,
-                                                                   ResourceCollector &resources)
+                                                                   ResourceScope &scope)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -897,7 +894,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputVector);
     GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
-    const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources);
+    const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope);
     vector_array.extend(mask_, virtual_vector_array);
     return vector_array;
   }
@@ -912,7 +909,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
     }
   }
 
-  const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources);
+  const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope);
 
   GVectorArray *new_vector_array = new GVectorArray(base_type, min_array_size_);
   new_vector_array->extend(mask_, virtual_vector_array);
@@ -926,7 +923,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
 
 GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInputSocket &input,
                                                                      const MFOutputSocket &output,
-                                                                     ResourceCollector &resources)
+                                                                     ResourceScope &scope)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -941,7 +938,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
     BLI_assert(to_any_value->type == ValueType::OutputVector);
     GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
     BLI_assert(vector_array.size() == 1);
-    const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources);
+    const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope);
     vector_array.extend({0}, virtual_vector_array);
     return vector_array;
   }
@@ -956,7 +953,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
     }
   }
 
-  const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources);
+  const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope);
 
   GVectorArray *new_vector_array = new GVectorArray(base_type, 1);
   new_vector_array->extend({0}, virtual_vector_array);
@@ -968,7 +965,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
 }
 
 const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &socket,
-                                                                  ResourceCollector &resources)
+                                                                  ResourceScope &scope)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -977,11 +974,11 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS
   if (any_value->type == ValueType::OwnSingle) {
     OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     if (value->is_single_allocated) {
-      return resources.construct<GVArrayForSingleValueRef>(
+      return scope.construct<GVArrayForSingleValueRef>(
           __func__, value->span.type(), min_array_size_, value->span.data());
     }
 
-    return resources.construct<GVArrayForGSpan>(__func__, value->span);
+    return scope.construct<GVArrayForGSpan>(__func__, value->span);
   }
   if (any_value->type == ValueType::InputSingle) {
     InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
@@ -990,15 +987,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS
   if (any_value->type == ValueType::OutputSingle) {
     OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
-    return resources.construct<GVArrayForGSpan>(__func__, value->span);
+    return scope.construct<GVArrayForGSpan>(__func__, value->span);
   }
 
   BLI_assert(false);
-  return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
+  return scope.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
 }
 
 const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket &socket,
-                                                                    ResourceCollector &resources)
+                                                                    ResourceScope &scope)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -1007,7 +1004,7 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu
   if (any_value->type == ValueType::OwnSingle) {
     OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     BLI_assert(value->span.size() == 1);
-    return resources.construct<GVArrayForGSpan>(__func__, value->span);
+    return scope.construct<GVArrayForGSpan>(__func__, value->span);
   }
   if (any_value->type == ValueType::InputSingle) {
     InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
@@ -1018,15 +1015,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu
     OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
     BLI_assert(value->span.size() == 1);
-    return resources.construct<GVArrayForGSpan>(__func__, value->span);
+    return scope.construct<GVArrayForGSpan>(__func__, value->span);
   }
 
   BLI_assert(false);
-  return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
+  return scope.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
 }
 
 const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full(
-    const MFInputSocket &socket, ResourceCollector &resources)
+    const MFInputSocket &socket, ResourceScope &scope)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -1036,10 +1033,10 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full(
     OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     if (value->vector_array->size() == 1) {
       GSpan span = (*value->vector_array)[0];
-      return resources.construct<GVVectorArrayForSingleGSpan>(__func__, span, min_array_size_);
+      return scope.construct<GVVectorArrayForSingleGSpan>(__func__, span, min_array_size_);
     }
 
-    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
+    return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
   if (any_value->type == ValueType::InputVector) {
     InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
@@ -1047,16 +1044,15 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full(
   }
   if (any_value->type == ValueType::OutputVector) {
     OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
-    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
+    return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
 
   BLI_assert(false);
-  return resources.construct<GVVectorArrayForSingleGSpan>(
-      __func__, GSpan(CPPType::get<float>()), 0);
+  return scope.construct<GVVectorArrayForSingleGSpan>(__func__, GSpan(CPPType::get<float>()), 0);
 }
 
 const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single(
-    const MFInputSocket &socket, ResourceCollector &resources)
+    const MFInputSocket &socket, ResourceScope &scope)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -1065,7 +1061,7 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single(
   if (any_value->type == ValueType::OwnVector) {
     OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
-    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
+    return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
   if (any_value->type == ValueType::InputVector) {
     InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
@@ -1075,12 +1071,11 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single(
   if (any_value->type == ValueType::OutputVector) {
     OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
-    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
+    return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
 
   BLI_assert(false);
-  return resources.construct<GVVectorArrayForSingleGSpan>(
-      __func__, GSpan(CPPType::get<float>()), 0);
+  return scope.construct<GVVectorArrayForSingleGSpan>(__func__, GSpan(CPPType::get<float>()), 0);
 }
 
 /** \} */
diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc
index 6c418dee2c1..4b6b3e81393 100644
--- a/source/blender/functions/intern/multi_function_network_optimization.cc
+++ b/source/blender/functions/intern/multi_function_network_optimization.cc
@@ -219,7 +219,7 @@ static Vector<MFInputSocket *> find_constant_inputs_to_fold(
 
 static void prepare_params_for_constant_folding(const MultiFunction &network_fn,
                                                 MFParamsBuilder &params,
-                                                ResourceCollector &resources)
+                                                ResourceScope &scope)
 {
   for (int param_index : network_fn.param_indices()) {
     MFParamType param_type = network_fn.param_type(param_index);
@@ -229,8 +229,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn,
       case MFDataType::Single: {
         /* Allocates memory for a single constant folded value. */
         const CPPType &cpp_type = data_type.single_type();
-        void *buffer = resources.linear_allocator().allocate(cpp_type.size(),
-                                                             cpp_type.alignment());
+        void *buffer = scope.linear_allocator().allocate(cpp_type.size(), cpp_type.alignment());
         GMutableSpan array{cpp_type, buffer, 1};
         params.add_uninitialized_single_output(array);
         break;
@@ -238,7 +237,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn,
       case MFDataType::Vector: {
         /* Allocates memory for a constant folded vector. */
         const CPPType &cpp_type = data_type.vector_base_type();
-        GVectorArray &vector_array = resources.construct<GVectorArray>(AT, cpp_type, 1);
+        GVectorArray &vector_array = scope.construct<GVectorArray>(AT, cpp_type, 1);
         params.add_vector_output(vector_array);
         break;
       }
@@ -248,7 +247,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn,
 
 static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction &network_fn,
                                                            MFParamsBuilder &params,
-                                                           ResourceCollector &resources,
+                                                           ResourceScope &scope,
                                                            MFNetwork &network)
 {
   Array<MFOutputSocket *> folded_sockets{network_fn.param_indices().size(), nullptr};
@@ -264,15 +263,15 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction &
         const CPPType &cpp_type = data_type.single_type();
         GMutableSpan array = params.computed_array(param_index);
         void *buffer = array.data();
-        resources.add(buffer, array.type().destruct_cb(), AT);
+        scope.add(buffer, array.type().destruct_cb(), AT);
 
-        constant_fn = &resources.construct<CustomMF_GenericConstant>(AT, cpp_type, buffer);
+        constant_fn = &scope.construct<CustomMF_GenericConstant>(AT, cpp_type, buffer);
         break;
       }
       case MFDataType::Vector: {
         GVectorArray &vector_array = params.computed_vector_array(param_index);
         GSpan array = vector_array[0];
-        constant_fn = &resources.construct<CustomMF_GenericConstantArray>(AT, array);
+        constant_fn = &scope.construct<CustomMF_GenericConstantArray>(AT, array);
         break;
       }
     }
@@ -284,17 +283,15 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction &
 }
 
 static Array<MFOutputSocket *> compute_constant_sockets_and_add_folded_nodes(
-    MFNetwork &network,
-    Span<const MFInputSocket *> sockets_to_compute,
-    ResourceCollector &resources)
+    MFNetwork &network, Span<const MFInputSocket *> sockets_to_compute, ResourceScope &scope)
 {
   MFNetworkEvaluator network_fn{{}, sockets_to_compute};
 
   MFContextBuilder context;
   MFParamsBuilder params{network_fn, 1};
-  prepare_params_for_constant_folding(network_fn, params, resources);
+  prepare_params_for_constant_folding(network_fn, params, scope);
   network_fn.call({0}, params, context);
-  return add_constant_folded_sockets(network_fn, params, resources, network);
+  return add_constant_folded_sockets(network_fn, params, scope, network);
 }
 
 class MyClass {
@@ -304,7 +301,7 @@ class MyClass {
 /**
  * Find function nodes that always output the same value and replace those with constant nodes.
  */
-void constant_folding(MFNetwork &network, ResourceCollector &resources)
+void constant_folding(MFNetwork &network, ResourceScope &scope)
 {
   Vector<MFDummyNode *> temporary_nodes;
   Vector<MFInputSocket *> inputs_to_fold = find_constant_inputs_to_fold(network, temporary_nodes);
@@ -313,7 +310,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources)
   }
 
   Array<MFOutputSocket *> folded_sockets = compute_constant_sockets_and_add_folded_nodes(
-      network, inputs_to_fold, resources);
+      network, inputs_to_fold, scope);
 
   for (int i : inputs_to_fold.index_range()) {
     MFOutputSocket &original_socket = *inputs_to_fold[i]->origin();