Cleanup: use C++ style casts in various places

11 files changed, 115 insertions, 105 deletions

diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh
index 0cac8d82d26..a9236f73549 100644
--- a/source/blender/functions/FN_attributes_ref.hh
+++ b/source/blender/functions/FN_attributes_ref.hh
@@ -51,7 +51,7 @@ class AttributesInfoBuilder : NonCopyable, NonMovable {
 
   template<typename T> bool add(StringRef name, const T &default_value)
   {
-    return this->add(name, CPPType::get<T>(), (const void *)&default_value);
+    return this->add(name, CPPType::get<T>(), static_cast<const void *>(&default_value));
   }
 
   bool add(StringRef name, const CPPType &type, const void *default_value = nullptr);
@@ -107,7 +107,7 @@ class AttributesInfo : NonCopyable, NonMovable {
   template<typename T> const T &default_of(int index) const
   {
     BLI_assert(type_by_index_[index]->is<T>());
-    return *(T *)defaults_[index];
+    return *static_cast<T *>(defaults_[index]);
   }
 
   template<typename T> const T &default_of(StringRef name) const
@@ -203,7 +203,7 @@ class MutableAttributesRef {
   template<typename T> MutableSpan<T> get(int index) const
   {
     BLI_assert(info_->type_of(index).is<T>());
-    return MutableSpan<T>((T *)buffers_[index] + range_.start(), range_.size());
+    return MutableSpan<T>(static_cast<T *>(buffers_[index]) + range_.start(), range_.size());
   }
 
   template<typename T> MutableSpan<T> get(StringRef name) const
@@ -294,7 +294,7 @@ class AttributesRef {
   template<typename T> Span<T> get(int index) const
   {
     BLI_assert(info_->type_of(index).is<T>());
-    return Span<T>((T *)buffers_[index] + range_.start(), range_.size());
+    return Span<T>(static_cast<T *>(buffers_[index]) + range_.start(), range_.size());
   }
 
   template<typename T> Span<T> get(StringRef name) const
diff --git a/source/blender/functions/FN_cpp_type.hh b/source/blender/functions/FN_cpp_type.hh
index 2f1d3f83c63..5f3981826c5 100644
--- a/source/blender/functions/FN_cpp_type.hh
+++ b/source/blender/functions/FN_cpp_type.hh
@@ -584,35 +584,35 @@ template<typename T> void construct_default_cb(void *ptr)
 }
 template<typename T> void construct_default_n_cb(void *ptr, int64_t n)
 {
-  blender::default_construct_n((T *)ptr, n);
+  blender::default_construct_n(static_cast<T *>(ptr), n);
 }
 template<typename T> void construct_default_indices_cb(void *ptr, IndexMask mask)
 {
-  mask.foreach_index([&](int64_t i) { new ((T *)ptr + i) T; });
+  mask.foreach_index([&](int64_t i) { new (static_cast<T *>(ptr) + i) T; });
 }
 
 template<typename T> void destruct_cb(void *ptr)
 {
-  ((T *)ptr)->~T();
+  (static_cast<T *>(ptr))->~T();
 }
 template<typename T> void destruct_n_cb(void *ptr, int64_t n)
 {
-  blender::destruct_n((T *)ptr, n);
+  blender::destruct_n(static_cast<T *>(ptr), n);
 }
 template<typename T> void destruct_indices_cb(void *ptr, IndexMask mask)
 {
-  T *ptr_ = (T *)ptr;
+  T *ptr_ = static_cast<T *>(ptr);
   mask.foreach_index([&](int64_t i) { ptr_[i].~T(); });
 }
 
 template<typename T> void copy_to_initialized_cb(const void *src, void *dst)
 {
-  *(T *)dst = *(T *)src;
+  *static_cast<T *>(dst) = *static_cast<const T *>(src);
 }
 template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, int64_t n)
 {
-  const T *src_ = (const T *)src;
-  T *dst_ = (T *)dst;
+  const T *src_ = static_cast<const T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   for (int64_t i = 0; i < n; i++) {
     dst_[i] = src_[i];
@@ -621,45 +621,45 @@ template<typename T> void copy_to_initialized_n_cb(const void *src, void *dst, i
 template<typename T>
 void copy_to_initialized_indices_cb(const void *src, void *dst, IndexMask mask)
 {
-  const T *src_ = (const T *)src;
-  T *dst_ = (T *)dst;
+  const T *src_ = static_cast<const T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) { dst_[i] = src_[i]; });
 }
 
 template<typename T> void copy_to_uninitialized_cb(const void *src, void *dst)
 {
-  blender::uninitialized_copy_n((T *)src, 1, (T *)dst);
+  blender::uninitialized_copy_n(static_cast<const T *>(src), 1, static_cast<T *>(dst));
 }
 template<typename T> void copy_to_uninitialized_n_cb(const void *src, void *dst, int64_t n)
 {
-  blender::uninitialized_copy_n((T *)src, n, (T *)dst);
+  blender::uninitialized_copy_n(static_cast<const T *>(src), n, static_cast<T *>(dst));
 }
 template<typename T>
 void copy_to_uninitialized_indices_cb(const void *src, void *dst, IndexMask mask)
 {
-  const T *src_ = (const T *)src;
-  T *dst_ = (T *)dst;
+  const T *src_ = static_cast<const T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) { new (dst_ + i) T(src_[i]); });
 }
 
 template<typename T> void relocate_to_initialized_cb(void *src, void *dst)
 {
-  T *src_ = (T *)src;
-  T *dst_ = (T *)dst;
+  T *src_ = static_cast<T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   *dst_ = std::move(*src_);
   src_->~T();
 }
 template<typename T> void relocate_to_initialized_n_cb(void *src, void *dst, int64_t n)
 {
-  blender::initialized_relocate_n((T *)src, n, (T *)dst);
+  blender::initialized_relocate_n(static_cast<T *>(src), n, static_cast<T *>(dst));
 }
 template<typename T> void relocate_to_initialized_indices_cb(void *src, void *dst, IndexMask mask)
 {
-  T *src_ = (T *)src;
-  T *dst_ = (T *)dst;
+  T *src_ = static_cast<T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) {
     dst_[i] = std::move(src_[i]);
@@ -669,21 +669,21 @@ template<typename T> void relocate_to_initialized_indices_cb(void *src, void *ds
 
 template<typename T> void relocate_to_uninitialized_cb(void *src, void *dst)
 {
-  T *src_ = (T *)src;
-  T *dst_ = (T *)dst;
+  T *src_ = static_cast<T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   new (dst_) T(std::move(*src_));
   src_->~T();
 }
 template<typename T> void relocate_to_uninitialized_n_cb(void *src, void *dst, int64_t n)
 {
-  blender::uninitialized_relocate_n((T *)src, n, (T *)dst);
+  blender::uninitialized_relocate_n(static_cast<T *>(src), n, static_cast<T *>(dst));
 }
 template<typename T>
 void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask)
 {
-  T *src_ = (T *)src;
-  T *dst_ = (T *)dst;
+  T *src_ = static_cast<T *>(src);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) {
     new (dst_ + i) T(std::move(src_[i]));
@@ -693,8 +693,8 @@ void relocate_to_uninitialized_indices_cb(void *src, void *dst, IndexMask mask)
 
 template<typename T> void fill_initialized_cb(const void *value, void *dst, int64_t n)
 {
-  const T &value_ = *(const T *)value;
-  T *dst_ = (T *)dst;
+  const T &value_ = *static_cast<const T *>(value);
+  T *dst_ = static_cast<T *>(dst);
 
   for (int64_t i = 0; i < n; i++) {
     dst_[i] = value_;
@@ -702,16 +702,16 @@ template<typename T> void fill_initialized_cb(const void *value, void *dst, int6
 }
 template<typename T> void fill_initialized_indices_cb(const void *value, void *dst, IndexMask mask)
 {
-  const T &value_ = *(const T *)value;
-  T *dst_ = (T *)dst;
+  const T &value_ = *static_cast<const T *>(value);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) { dst_[i] = value_; });
 }
 
 template<typename T> void fill_uninitialized_cb(const void *value, void *dst, int64_t n)
 {
-  const T &value_ = *(const T *)value;
-  T *dst_ = (T *)dst;
+  const T &value_ = *static_cast<const T *>(value);
+  T *dst_ = static_cast<T *>(dst);
 
   for (int64_t i = 0; i < n; i++) {
     new (dst_ + i) T(value_);
@@ -720,28 +720,28 @@ template<typename T> void fill_uninitialized_cb(const void *value, void *dst, in
 template<typename T>
 void fill_uninitialized_indices_cb(const void *value, void *dst, IndexMask mask)
 {
-  const T &value_ = *(const T *)value;
-  T *dst_ = (T *)dst;
+  const T &value_ = *static_cast<const T *>(value);
+  T *dst_ = static_cast<T *>(dst);
 
   mask.foreach_index([&](int64_t i) { new (dst_ + i) T(value_); });
 }
 
 template<typename T> void debug_print_cb(const void *value, std::stringstream &ss)
 {
-  const T &value_ = *(const T *)value;
+  const T &value_ = *static_cast<const T *>(value);
   ss << value_;
 }
 
 template<typename T> bool is_equal_cb(const void *a, const void *b)
 {
-  const T &a_ = *(T *)a;
-  const T &b_ = *(T *)b;
+  const T &a_ = *static_cast<const T *>(a);
+  const T &b_ = *static_cast<const T *>(b);
   return a_ == b_;
 }
 
 template<typename T> uint64_t hash_cb(const void *value)
 {
-  const T &value_ = *(const T *)value;
+  const T &value_ = *static_cast<const T *>(value);
   return DefaultHash<T>{}(value_);
 }
 
@@ -780,7 +780,7 @@ inline std::unique_ptr<const CPPType> create_cpp_type(StringRef name, const T &d
                                     debug_print_cb<T>,
                                     is_equal_cb<T>,
                                     hash_cb<T>,
-                                    (const void *)&default_value);
+                                    static_cast<const void *>(&default_value));
   return std::unique_ptr<const CPPType>(type);
 }
 
diff --git a/source/blender/functions/FN_generic_vector_array.hh b/source/blender/functions/FN_generic_vector_array.hh
index 0a173d1fbc6..dc5ad3c36ab 100644
--- a/source/blender/functions/FN_generic_vector_array.hh
+++ b/source/blender/functions/FN_generic_vector_array.hh
@@ -186,7 +186,8 @@ template<typename T> class GVectorArrayRef {
   MutableSpan<T> operator[](int64_t index)
   {
     BLI_assert(index < vector_array_->starts_.size());
-    return MutableSpan<T>((T *)vector_array_->starts_[index], vector_array_->lengths_[index]);
+    return MutableSpan<T>(static_cast<T *>(vector_array_->starts_[index]),
+                          vector_array_->lengths_[index]);
   }
 
   int64_t size() const
diff --git a/source/blender/functions/FN_multi_function_builder.hh b/source/blender/functions/FN_multi_function_builder.hh
index dee0938eb3a..6d5ca7f64ad 100644
--- a/source/blender/functions/FN_multi_function_builder.hh
+++ b/source/blender/functions/FN_multi_function_builder.hh
@@ -58,7 +58,8 @@ template<typename In1, typename Out1> class CustomMF_SI_SO : public MultiFunctio
   template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
   {
     return [=](IndexMask mask, VSpan<In1> in1, MutableSpan<Out1> out1) {
-      mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i])); });
+      mask.foreach_index(
+          [&](int i) { new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i])); });
     };
   }
 
@@ -100,7 +101,8 @@ class CustomMF_SI_SI_SO : public MultiFunction {
   template<typename ElementFuncT> static FunctionT create_function(ElementFuncT element_fn)
   {
     return [=](IndexMask mask, VSpan<In1> in1, VSpan<In2> in2, MutableSpan<Out1> out1) {
-      mask.foreach_index([&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i])); });
+      mask.foreach_index(
+          [&](int i) { new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i], in2[i])); });
     };
   }
 
@@ -150,8 +152,9 @@ class CustomMF_SI_SI_SI_SO : public MultiFunction {
                VSpan<In2> in2,
                VSpan<In3> in3,
                MutableSpan<Out1> out1) {
-      mask.foreach_index(
-          [&](int i) { new ((void *)&out1[i]) Out1(element_fn(in1[i], in2[i], in3[i])); });
+      mask.foreach_index([&](int i) {
+        new (static_cast<void *>(&out1[i])) Out1(element_fn(in1[i], in2[i], in3[i]));
+      });
     };
   }
 
@@ -220,7 +223,7 @@ template<typename From, typename To> class CustomMF_Convert : public MultiFuncti
     MutableSpan<To> outputs = params.uninitialized_single_output<To>(1);
 
     for (int64_t i : mask) {
-      new ((void *)&outputs[i]) To(inputs[i]);
+      new (static_cast<void *>(&outputs[i])) To(inputs[i]);
     }
   }
 };
@@ -294,7 +297,7 @@ template<typename T> class CustomMF_Constant : public MultiFunction {
     if (other2 != nullptr) {
       const CPPType &type = CPPType::get<T>();
       if (type == other2->type_) {
-        return type.is_equal((const void *)&value_, other2->value_);
+        return type.is_equal(static_cast<const void *>(&value_), other2->value_);
       }
     }
     return false;
diff --git a/source/blender/functions/FN_multi_function_context.hh b/source/blender/functions/FN_multi_function_context.hh
index eec6b21ae7c..1d3ed726c4a 100644
--- a/source/blender/functions/FN_multi_function_context.hh
+++ b/source/blender/functions/FN_multi_function_context.hh
@@ -43,7 +43,7 @@ class MFContextBuilder {
  public:
   template<typename T> void add_global_context(std::string name, const T *context)
   {
-    global_contexts_.add_new(std::move(name), (const void *)context);
+    global_contexts_.add_new(std::move(name), static_cast<const void *>(context));
   }
 };
 
@@ -60,7 +60,7 @@ class MFContext {
   {
     const void *context = builder_.global_contexts_.lookup_default_as(name, nullptr);
     /* TODO: Implement type checking. */
-    return (const T *)context;
+    return static_cast<const T *>(context);
   }
 };
 
diff --git a/source/blender/functions/FN_multi_function_data_type.hh b/source/blender/functions/FN_multi_function_data_type.hh
index 34997703432..713f73c2b5a 100644
--- a/source/blender/functions/FN_multi_function_data_type.hh
+++ b/source/blender/functions/FN_multi_function_data_type.hh
@@ -110,7 +110,7 @@ class MFDataType {
 
   uint64_t hash() const
   {
-    return DefaultHash<CPPType>{}(*type_) + (uint64_t)category_;
+    return DefaultHash<CPPType>{}(*type_) + static_cast<uint64_t>(category_);
   }
 };
 
diff --git a/source/blender/functions/FN_multi_function_network.hh b/source/blender/functions/FN_multi_function_network.hh
index 7a9f5b4cfaf..b303589106a 100644
--- a/source/blender/functions/FN_multi_function_network.hh
+++ b/source/blender/functions/FN_multi_function_network.hh
@@ -118,7 +118,7 @@ class MFFunctionNode : public MFNode {
 };
 
 class MFDummyNode : public MFNode {
- private:
+ protected:
   StringRefNull name_;
   MutableSpan<StringRefNull> input_names_;
   MutableSpan<StringRefNull> output_names_;
@@ -279,25 +279,25 @@ inline bool MFNode::is_function() const
 inline MFDummyNode &MFNode::as_dummy()
 {
   BLI_assert(is_dummy_);
-  return *(MFDummyNode *)this;
+  return static_cast<MFDummyNode &>(*this);
 }
 
 inline const MFDummyNode &MFNode::as_dummy() const
 {
   BLI_assert(is_dummy_);
-  return *(const MFDummyNode *)this;
+  return static_cast<const MFDummyNode &>(*this);
 }
 
 inline MFFunctionNode &MFNode::as_function()
 {
   BLI_assert(!is_dummy_);
-  return *(MFFunctionNode *)this;
+  return static_cast<MFFunctionNode &>(*this);
 }
 
 inline const MFFunctionNode &MFNode::as_function() const
 {
   BLI_assert(!is_dummy_);
-  return *(const MFFunctionNode *)this;
+  return static_cast<const MFFunctionNode &>(*this);
 }
 
 inline MFInputSocket &MFNode::input(int index)
@@ -440,25 +440,25 @@ inline bool MFSocket::is_output() const
 inline MFInputSocket &MFSocket::as_input()
 {
   BLI_assert(this->is_input());
-  return *(MFInputSocket *)this;
+  return static_cast<MFInputSocket &>(*this);
 }
 
 inline const MFInputSocket &MFSocket::as_input() const
 {
   BLI_assert(this->is_input());
-  return *(const MFInputSocket *)this;
+  return static_cast<const MFInputSocket &>(*this);
 }
 
 inline MFOutputSocket &MFSocket::as_output()
 {
   BLI_assert(this->is_output());
-  return *(MFOutputSocket *)this;
+  return static_cast<MFOutputSocket &>(*this);
 }
 
 inline const MFOutputSocket &MFSocket::as_output() const
 {
   BLI_assert(this->is_output());
-  return *(const MFOutputSocket *)this;
+  return static_cast<const MFOutputSocket &>(*this);
 }
 
 /* --------------------------------------------------------------------
diff --git a/source/blender/functions/FN_spans.hh b/source/blender/functions/FN_spans.hh
index 76380f46e91..2c1257f9ad2 100644
--- a/source/blender/functions/FN_spans.hh
+++ b/source/blender/functions/FN_spans.hh
@@ -67,7 +67,8 @@ class GSpan {
   }
 
   template<typename T>
-  GSpan(Span<T> array) : GSpan(CPPType::get<T>(), (const void *)array.data(), array.size())
+  GSpan(Span<T> array)
+      : GSpan(CPPType::get<T>(), static_cast<const void *>(array.data()), array.size())
   {
   }
 
@@ -100,7 +101,7 @@ class GSpan {
   template<typename T> Span<T> typed() const
   {
     BLI_assert(type_->is<T>());
-    return Span<T>((const T *)data_, size_);
+    return Span<T>(static_cast<const T *>(data_), size_);
   }
 };
 
@@ -129,7 +130,7 @@ class GMutableSpan {
 
   template<typename T>
   GMutableSpan(MutableSpan<T> array)
-      : GMutableSpan(CPPType::get<T>(), (void *)array.begin(), array.size())
+      : GMutableSpan(CPPType::get<T>(), static_cast<void *>(array.begin()), array.size())
   {
   }
 
@@ -167,7 +168,7 @@ class GMutableSpan {
   template<typename T> MutableSpan<T> typed()
   {
     BLI_assert(type_->is<T>());
-    return MutableSpan<T>((T *)data_, size_);
+    return MutableSpan<T>(static_cast<T *>(data_), size_);
   }
 };
 
diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc
index cd3c38dd09f..77c8ba6373f 100644
--- a/source/blender/functions/intern/multi_function_network.cc
+++ b/source/blender/functions/intern/multi_function_network.cc
@@ -285,8 +285,8 @@ std::string MFNetwork::to_dot(Span<const MFNode *> marked_nodes) const
   Map<const MFNode *, dot::NodeWithSocketsRef> dot_nodes;
 
   Vector<const MFNode *> all_nodes;
-  all_nodes.extend(function_nodes_.as_span());
-  all_nodes.extend(dummy_nodes_.as_span());
+  all_nodes.extend(function_nodes_.as_span().cast<const MFNode *>());
+  all_nodes.extend(dummy_nodes_.as_span().cast<const MFNode *>());
 
   for (const MFNode *node : all_nodes) {
     dot::Node &dot_node = digraph.new_node("");
diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc
index 480a048b510..c543d86ad34 100644
--- a/source/blender/functions/intern/multi_function_network_evaluation.cc
+++ b/source/blender/functions/intern/multi_function_network_evaluation.cc
@@ -520,7 +520,7 @@ MFNetworkEvaluationStorage::~MFNetworkEvaluationStorage()
       continue;
     }
     if (any_value->type == ValueType::OwnSingle) {
-      OwnSingleValue *value = (OwnSingleValue *)any_value;
+      OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
       GMutableSpan span = value->span;
       const CPPType &type = span.type();
       if (value->is_single_allocated) {
@@ -532,7 +532,7 @@ MFNetworkEvaluationStorage::~MFNetworkEvaluationStorage()
       }
     }
     else if (any_value->type == ValueType::OwnVector) {
-      OwnVectorValue *value = (OwnVectorValue *)any_value;
+      OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
       delete value->vector_array;
     }
   }
@@ -550,7 +550,7 @@ bool MFNetworkEvaluationStorage::socket_is_computed(const MFOutputSocket &socket
     return false;
   }
   if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) {
-    return ((OutputValue *)any_value)->is_computed;
+    return static_cast<OutputValue *>(any_value)->is_computed;
   }
   return true;
 }
@@ -560,17 +560,17 @@ bool MFNetworkEvaluationStorage::is_same_value_for_every_index(const MFOutputSoc
   Value *any_value = value_per_output_id_[socket.id()];
   switch (any_value->type) {
     case ValueType::OwnSingle:
-      return ((OwnSingleValue *)any_value)->span.size() == 1;
+      return static_cast<OwnSingleValue *>(any_value)->span.size() == 1;
     case ValueType::OwnVector:
-      return ((OwnVectorValue *)any_value)->vector_array->size() == 1;
+      return static_cast<OwnVectorValue *>(any_value)->vector_array->size() == 1;
     case ValueType::InputSingle:
-      return ((InputSingleValue *)any_value)->virtual_span.is_single_element();
+      return static_cast<InputSingleValue *>(any_value)->virtual_span.is_single_element();
     case ValueType::InputVector:
-      return ((InputVectorValue *)any_value)->virtual_array_span.is_single_array();
+      return static_cast<InputVectorValue *>(any_value)->virtual_array_span.is_single_array();
     case ValueType::OutputSingle:
-      return ((OutputSingleValue *)any_value)->span.size() == 1;
+      return static_cast<OutputSingleValue *>(any_value)->span.size() == 1;
     case ValueType::OutputVector:
-      return ((OutputVectorValue *)any_value)->vector_array->size() == 1;
+      return static_cast<OutputVectorValue *>(any_value)->vector_array->size() == 1;
   }
   BLI_assert(false);
   return false;
@@ -605,7 +605,7 @@ void MFNetworkEvaluationStorage::finish_output_socket(const MFOutputSocket &sock
   }
 
   if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) {
-    ((OutputValue *)any_value)->is_computed = true;
+    static_cast<OutputValue *>(any_value)->is_computed = true;
   }
 }
 
@@ -627,7 +627,7 @@ void MFNetworkEvaluationStorage::finish_input_socket(const MFInputSocket &socket
       break;
     }
     case ValueType::OwnSingle: {
-      OwnSingleValue *value = (OwnSingleValue *)any_value;
+      OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
       BLI_assert(value->max_remaining_users >= 1);
       value->max_remaining_users--;
       if (value->max_remaining_users == 0) {
@@ -645,7 +645,7 @@ void MFNetworkEvaluationStorage::finish_input_socket(const MFInputSocket &socket
       break;
     }
     case ValueType::OwnVector: {
-      OwnVectorValue *value = (OwnVectorValue *)any_value;
+      OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
       BLI_assert(value->max_remaining_users >= 1);
       value->max_remaining_users--;
       if (value->max_remaining_users == 0) {
@@ -712,7 +712,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_single_output__full(const MFOutputS
   }
 
   BLI_assert(any_value->type == ValueType::OutputSingle);
-  return ((OutputSingleValue *)any_value)->span;
+  return static_cast<OutputSingleValue *>(any_value)->span;
 }
 
 GMutableSpan MFNetworkEvaluationStorage::get_single_output__single(const MFOutputSocket &socket)
@@ -730,7 +730,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_single_output__single(const MFOutpu
   }
 
   BLI_assert(any_value->type == ValueType::OutputSingle);
-  GMutableSpan span = ((OutputSingleValue *)any_value)->span;
+  GMutableSpan span = static_cast<OutputSingleValue *>(any_value)->span;
   BLI_assert(span.size() == 1);
   return span;
 }
@@ -749,7 +749,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__full(const MFOutput
   }
 
   BLI_assert(any_value->type == ValueType::OutputVector);
-  return *((OutputVectorValue *)any_value)->vector_array;
+  return *static_cast<OutputVectorValue *>(any_value)->vector_array;
 }
 
 GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutputSocket &socket)
@@ -766,7 +766,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp
   }
 
   BLI_assert(any_value->type == ValueType::OutputVector);
-  GVectorArray &vector_array = *((OutputVectorValue *)any_value)->vector_array;
+  GVectorArray &vector_array = *static_cast<OutputVectorValue *>(any_value)->vector_array;
   BLI_assert(vector_array.size() == 1);
   return vector_array;
 }
@@ -785,14 +785,14 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
 
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
-    GMutableSpan span = ((OutputSingleValue *)to_any_value)->span;
+    GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
     GVSpan virtual_span = this->get_single_input__full(input);
     virtual_span.materialize_to_uninitialized(mask_, span.data());
     return span;
   }
 
   if (from_any_value->type == ValueType::OwnSingle) {
-    OwnSingleValue *value = (OwnSingleValue *)from_any_value;
+    OwnSingleValue *value = static_cast<OwnSingleValue *>(from_any_value);
     if (value->max_remaining_users == 1 && !value->is_single_allocated) {
       value_per_output_id_[to.id()] = value;
       value_per_output_id_[from.id()] = nullptr;
@@ -826,7 +826,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
 
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
-    GMutableSpan span = ((OutputSingleValue *)to_any_value)->span;
+    GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
     BLI_assert(span.size() == 1);
     GVSpan virtual_span = this->get_single_input__single(input);
     type.copy_to_uninitialized(virtual_span.as_single_element(), span[0]);
@@ -834,7 +834,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
   }
 
   if (from_any_value->type == ValueType::OwnSingle) {
-    OwnSingleValue *value = (OwnSingleValue *)from_any_value;
+    OwnSingleValue *value = static_cast<OwnSingleValue *>(from_any_value);
     if (value->max_remaining_users == 1) {
       value_per_output_id_[to.id()] = value;
       value_per_output_id_[from.id()] = nullptr;
@@ -870,14 +870,14 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
 
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputVector);
-    GVectorArray &vector_array = *((OutputVectorValue *)to_any_value)->vector_array;
+    GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
     GVArraySpan virtual_array_span = this->get_vector_input__full(input);
     vector_array.extend(mask_, virtual_array_span);
     return vector_array;
   }
 
   if (from_any_value->type == ValueType::OwnVector) {
-    OwnVectorValue *value = (OwnVectorValue *)from_any_value;
+    OwnVectorValue *value = static_cast<OwnVectorValue *>(from_any_value);
     if (value->max_remaining_users == 1) {
       value_per_output_id_[to.id()] = value;
       value_per_output_id_[from.id()] = nullptr;
@@ -912,7 +912,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
 
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputVector);
-    GVectorArray &vector_array = *((OutputVectorValue *)to_any_value)->vector_array;
+    GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
     BLI_assert(vector_array.size() == 1);
     GVArraySpan virtual_array_span = this->get_vector_input__single(input);
     vector_array.extend(0, virtual_array_span[0]);
@@ -920,7 +920,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
   }
 
   if (from_any_value->type == ValueType::OwnVector) {
-    OwnVectorValue *value = (OwnVectorValue *)from_any_value;
+    OwnVectorValue *value = static_cast<OwnVectorValue *>(from_any_value);
     if (value->max_remaining_users == 1) {
       value_per_output_id_[to.id()] = value;
       value_per_output_id_[from.id()] = nullptr;
@@ -947,7 +947,7 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &s
   BLI_assert(any_value != nullptr);
 
   if (any_value->type == ValueType::OwnSingle) {
-    OwnSingleValue *value = (OwnSingleValue *)any_value;
+    OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     if (value->is_single_allocated) {
       return GVSpan::FromSingle(value->span.type(), value->span.data(), min_array_size_);
     }
@@ -955,11 +955,11 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &s
     return value->span;
   }
   if (any_value->type == ValueType::InputSingle) {
-    InputSingleValue *value = (InputSingleValue *)any_value;
+    InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
     return value->virtual_span;
   }
   if (any_value->type == ValueType::OutputSingle) {
-    OutputSingleValue *value = (OutputSingleValue *)any_value;
+    OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
     return value->span;
   }
@@ -975,17 +975,17 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket
   BLI_assert(any_value != nullptr);
 
   if (any_value->type == ValueType::OwnSingle) {
-    OwnSingleValue *value = (OwnSingleValue *)any_value;
+    OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     BLI_assert(value->span.size() == 1);
     return value->span;
   }
   if (any_value->type == ValueType::InputSingle) {
-    InputSingleValue *value = (InputSingleValue *)any_value;
+    InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
     BLI_assert(value->virtual_span.is_single_element());
     return value->virtual_span;
   }
   if (any_value->type == ValueType::OutputSingle) {
-    OutputSingleValue *value = (OutputSingleValue *)any_value;
+    OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
     BLI_assert(value->span.size() == 1);
     return value->span;
@@ -1002,7 +1002,7 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSock
   BLI_assert(any_value != nullptr);
 
   if (any_value->type == ValueType::OwnVector) {
-    OwnVectorValue *value = (OwnVectorValue *)any_value;
+    OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     if (value->vector_array->size() == 1) {
       GSpan span = (*value->vector_array)[0];
       return GVArraySpan(span, min_array_size_);
@@ -1011,11 +1011,11 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSock
     return *value->vector_array;
   }
   if (any_value->type == ValueType::InputVector) {
-    InputVectorValue *value = (InputVectorValue *)any_value;
+    InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
     return value->virtual_array_span;
   }
   if (any_value->type == ValueType::OutputVector) {
-    OutputVectorValue *value = (OutputVectorValue *)any_value;
+    OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
     return *value->vector_array;
   }
 
@@ -1030,17 +1030,17 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__single(const MFInputSo
   BLI_assert(any_value != nullptr);
 
   if (any_value->type == ValueType::OwnVector) {
-    OwnVectorValue *value = (OwnVectorValue *)any_value;
+    OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
     return *value->vector_array;
   }
   if (any_value->type == ValueType::InputVector) {
-    InputVectorValue *value = (InputVectorValue *)any_value;
+    InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
     BLI_assert(value->virtual_array_span.is_single_array());
     return value->virtual_array_span;
   }
   if (any_value->type == ValueType::OutputVector) {
-    OutputVectorValue *value = (OutputVectorValue *)any_value;
+    OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
     return *value->vector_array;
   }
diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc
index e53b9a2c648..e24f157d4f9 100644
--- a/source/blender/functions/intern/multi_function_network_optimization.cc
+++ b/source/blender/functions/intern/multi_function_network_optimization.cc
@@ -130,7 +130,8 @@ static Vector<MFNode *> find_nodes_based_on_mask(MFNetwork &network,
  */
 void dead_node_removal(MFNetwork &network)
 {
-  Array<bool> node_is_used_mask = mask_nodes_to_the_left(network, network.dummy_nodes());
+  Array<bool> node_is_used_mask = mask_nodes_to_the_left(network,
+                                                         network.dummy_nodes().cast<MFNode *>());
   Vector<MFNode *> nodes_to_remove = find_nodes_based_on_mask(network, node_is_used_mask, false);
   network.remove(nodes_to_remove);
 }
@@ -156,7 +157,7 @@ static bool function_node_can_be_constant(MFFunctionNode *node)
 static Vector<MFNode *> find_non_constant_nodes(MFNetwork &network)
 {
   Vector<MFNode *> non_constant_nodes;
-  non_constant_nodes.extend(network.dummy_nodes());
+  non_constant_nodes.extend(network.dummy_nodes().cast<MFNode *>());
 
   for (MFFunctionNode *node : network.function_nodes()) {
     if (!function_node_can_be_constant(node)) {
@@ -299,6 +300,10 @@ static Array<MFOutputSocket *> compute_constant_sockets_and_add_folded_nodes(
   return add_constant_folded_sockets(network_fn, params, resources, network);
 }
 
+class MyClass {
+  MFDummyNode node;
+};
+
 /**
  * Find function nodes that always output the same value and replace those with constant nodes.
  */
@@ -318,7 +323,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources)
     network.relink(original_socket, *folded_sockets[i]);
   }
 
-  network.remove(temporary_nodes);
+  network.remove(temporary_nodes.as_span().cast<MFNode *>());
 }
 
 /** \} */