1 files changed, 29 insertions, 29 deletions

diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh
index e6683693a0a..9cce8bb7401 100644
--- a/source/blender/functions/FN_multi_function_params.hh
+++ b/source/blender/functions/FN_multi_function_params.hh
@@ -34,7 +34,7 @@ namespace blender::fn {
 class MFParamsBuilder {
  private:
   const MFSignature *signature_;
-  uint min_array_size_;
+  int64_t min_array_size_;
   Vector<GVSpan> virtual_spans_;
   Vector<GMutableSpan> mutable_spans_;
   Vector<GVArraySpan> virtual_array_spans_;
@@ -43,12 +43,12 @@ class MFParamsBuilder {
   friend class MFParams;
 
  public:
-  MFParamsBuilder(const MFSignature &signature, uint min_array_size)
+  MFParamsBuilder(const MFSignature &signature, int64_t min_array_size)
       : signature_(&signature), min_array_size_(min_array_size)
   {
   }
 
-  MFParamsBuilder(const class MultiFunction &fn, uint min_array_size);
+  MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size);
 
   template<typename T> void add_readonly_single_input(const T *value)
   {
@@ -96,21 +96,21 @@ class MFParamsBuilder {
     vector_arrays_.append(&vector_array);
   }
 
-  GMutableSpan computed_array(uint param_index)
+  GMutableSpan computed_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
                     MFParamType::SingleOutput,
                     MFParamType::SingleMutable));
-    uint data_index = signature_->data_index(param_index);
+    int data_index = signature_->data_index(param_index);
     return mutable_spans_[data_index];
   }
 
-  GVectorArray &computed_vector_array(uint param_index)
+  GVectorArray &computed_vector_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
                     MFParamType::VectorOutput,
                     MFParamType::VectorMutable));
-    uint data_index = signature_->data_index(param_index);
+    int data_index = signature_->data_index(param_index);
     return *vector_arrays_[data_index];
   }
 
@@ -119,13 +119,13 @@ class MFParamsBuilder {
   {
     UNUSED_VARS_NDEBUG(param_type);
 #ifdef DEBUG
-    uint param_index = this->current_param_index();
+    int param_index = this->current_param_index();
     MFParamType expected_type = signature_->param_types[param_index];
     BLI_assert(expected_type == param_type);
 #endif
   }
 
-  uint current_param_index() const
+  int current_param_index() const
   {
     return virtual_spans_.size() + mutable_spans_.size() + virtual_array_spans_.size() +
            vector_arrays_.size();
@@ -141,75 +141,75 @@ class MFParams {
   {
   }
 
-  template<typename T> VSpan<T> readonly_single_input(uint param_index, StringRef name = "")
+  template<typename T> VSpan<T> readonly_single_input(int param_index, StringRef name = "")
   {
     return this->readonly_single_input(param_index, name).typed<T>();
   }
-  GVSpan readonly_single_input(uint param_index, StringRef name = "")
+  GVSpan readonly_single_input(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleInput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->virtual_spans_[data_index];
   }
 
   template<typename T>
-  MutableSpan<T> uninitialized_single_output(uint param_index, StringRef name = "")
+  MutableSpan<T> uninitialized_single_output(int param_index, StringRef name = "")
   {
     return this->uninitialized_single_output(param_index, name).typed<T>();
   }
-  GMutableSpan uninitialized_single_output(uint param_index, StringRef name = "")
+  GMutableSpan uninitialized_single_output(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleOutput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
 
-  template<typename T> VArraySpan<T> readonly_vector_input(uint param_index, StringRef name = "")
+  template<typename T> VArraySpan<T> readonly_vector_input(int param_index, StringRef name = "")
   {
     return this->readonly_vector_input(param_index, name).typed<T>();
   }
-  GVArraySpan readonly_vector_input(uint param_index, StringRef name = "")
+  GVArraySpan readonly_vector_input(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorInput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->virtual_array_spans_[data_index];
   }
 
-  template<typename T> GVectorArrayRef<T> vector_output(uint param_index, StringRef name = "")
+  template<typename T> GVectorArrayRef<T> vector_output(int param_index, StringRef name = "")
   {
     return this->vector_output(param_index, name).typed<T>();
   }
-  GVectorArray &vector_output(uint param_index, StringRef name = "")
+  GVectorArray &vector_output(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorOutput);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
 
-  template<typename T> MutableSpan<T> single_mutable(uint param_index, StringRef name = "")
+  template<typename T> MutableSpan<T> single_mutable(int param_index, StringRef name = "")
   {
     return this->single_mutable(param_index, name).typed<T>();
   }
-  GMutableSpan single_mutable(uint param_index, StringRef name = "")
+  GMutableSpan single_mutable(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::SingleMutable);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
 
-  template<typename T> GVectorArrayRef<T> vector_mutable(uint param_index, StringRef name = "")
+  template<typename T> GVectorArrayRef<T> vector_mutable(int param_index, StringRef name = "")
   {
     return this->vector_mutable(param_index, name).typed<T>();
   }
-  GVectorArray &vector_mutable(uint param_index, StringRef name = "")
+  GVectorArray &vector_mutable(int param_index, StringRef name = "")
   {
     this->assert_correct_param(param_index, name, MFParamType::VectorMutable);
-    uint data_index = builder_->signature_->data_index(param_index);
+    int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
 
  private:
-  void assert_correct_param(uint param_index, StringRef name, MFParamType param_type)
+  void assert_correct_param(int param_index, StringRef name, MFParamType param_type)
   {
     UNUSED_VARS_NDEBUG(param_index, name, param_type);
 #ifdef DEBUG
@@ -220,7 +220,7 @@ class MFParams {
 #endif
   }
 
-  void assert_correct_param(uint param_index, StringRef name, MFParamType::Category category)
+  void assert_correct_param(int param_index, StringRef name, MFParamType::Category category)
   {
     UNUSED_VARS_NDEBUG(param_index, name, category);
 #ifdef DEBUG