Fix slicing from "Array" to "ModelNode"

Author: Waguramu

include/simfil/model/nodes.h

@@ -110,16 +110,16 @@ struct model_ptr
     model_ptr& operator=(model_ptr&&) = default;
 
     template<typename OtherT>
-    model_ptr(model_ptr<OtherT> const& other) : data_(other.data_) {}  // NOLINT
+    model_ptr(model_ptr<OtherT> const& other) : data_(makeCompatibleCopy(other)) {}  // NOLINT
 
     template<typename OtherT>
-    model_ptr(model_ptr<OtherT>&& other) : data_(std::move(other.data_)) {}  // NOLINT
+    model_ptr(model_ptr<OtherT>&& other) : data_(makeCompatibleMove(std::move(other))) {}  // NOLINT
 
     template<typename OtherT>
-    model_ptr& operator= (model_ptr<OtherT> const& other) {data_ = other.data_; return *this;}
+    model_ptr& operator= (model_ptr<OtherT> const& other) {data_ = makeCompatibleCopy(other); return *this;}
 
     template<typename OtherT>
-    model_ptr& operator= (model_ptr<OtherT>&& other) {data_ = std::move(other.data_); return *this;}
+    model_ptr& operator= (model_ptr<OtherT>&& other) {data_ = makeCompatibleMove(std::move(other)); return *this;}
 
     template<typename... Args>
     explicit model_ptr(std::in_place_t, Args&&... args)
@@ -156,6 +156,44 @@ struct model_ptr
     inline operator bool () const {return data_.addr_;}  // NOLINT (allow implicit bool cast)
 
 private:
+    template<typename>
+    static constexpr bool AlwaysFalse = false;
+
+    template<typename OtherT>
+    [[nodiscard]] static T makeCompatibleCopy(model_ptr<OtherT> const& other)
+    {
+        if constexpr (std::is_base_of_v<T, OtherT> && !std::is_same_v<T, OtherT>) {
+            // Avoid slicing on derived->base conversions by rebuilding from node identity.
+            if constexpr (requires { T(other.data_.model_, other.data_.addr_, other.data_.data_, detail::mp_key{0}); }) {
+                return T(other.data_.model_, other.data_.addr_, other.data_.data_, detail::mp_key{0});
+            } else if constexpr (requires { T(other.data_.model_, other.data_.addr_, detail::mp_key{0}); }) {
+                return T(other.data_.model_, other.data_.addr_, detail::mp_key{0});
+            } else {
+                static_assert(
+                    AlwaysFalse<OtherT>,
+                    "Derived-to-base model_ptr conversion requires a constructor from model/address.");
+            }
+        }
+        return T(other.data_);
+    }
+
+    template<typename OtherT>
+    [[nodiscard]] static T makeCompatibleMove(model_ptr<OtherT>&& other)
+    {
+        if constexpr (std::is_base_of_v<T, OtherT> && !std::is_same_v<T, OtherT>) {
+            if constexpr (requires { T(std::move(other.data_.model_), other.data_.addr_, std::move(other.data_.data_), detail::mp_key{0}); }) {
+                return T(std::move(other.data_.model_), other.data_.addr_, std::move(other.data_.data_), detail::mp_key{0});
+            } else if constexpr (requires { T(std::move(other.data_.model_), other.data_.addr_, detail::mp_key{0}); }) {
+                return T(std::move(other.data_.model_), other.data_.addr_, detail::mp_key{0});
+            } else {
+                static_assert(
+                    AlwaysFalse<OtherT>,
+                    "Derived-to-base model_ptr conversion requires a constructor from model/address.");
+            }
+        }
+        return T(std::move(other.data_));
+    }
+
     T data_;
 };