rice 4.11.4 → 4.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '07196451c8152b8110d5a2aa17d9d1073c846139a8e08d3fe71217095c3386d6'
-  data.tar.gz: d0a84860a008461a29396679953abe8377f24b92ee9085ed84820dd946065390
+  metadata.gz: ee35bcabc987b70a0614689a9fe28f60ceeb0d63ad492ebc1d1914acebfb63d8
+  data.tar.gz: 40451a4f9531b935f70aefb2fc2e7ecb5bd75a546035fb7c3eed3af8f47f2911
 SHA512:
-  metadata.gz: 1d560e79db1a4645bd6d1084e0df00a44d79795b14d963292e731912c1bcabf29578846ff18a2bf8f8cdb171419c1b13be66b358582328ff5e4d18c61aee8731
-  data.tar.gz: bfa6478914622bf559db804f3ccb10fd51c39973ff7032a07d2ced37c7d5fbbacd3b9417ed4399499f97f209ec115daecabd7e9ab75a145dfaba9c6c2d94478e
+  metadata.gz: 8cc76f3c9395f94bf5830cc60ad5c327ab9941b0f532ac095553f774481d04cf72ddc2abf7db167438063c7e3e91455a2cc660fbd37d2e917276b30bef6a3203
+  data.tar.gz: 4ffb5214a1bf6dfeda4222a6c6c7006313820eac1cf17fdf36994a70099506ec591be20cd77db52f8034ed47cb65297d0b80c9dd3ff08aed70ade273f1cc492e

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 4.12.0 (2026-04-09)
+
+### Bug Fixes
+
+* Fix undefined behavior when deleting polymorphic classes with non-virtual destructors
+* Fix overload resolution to prefer `T&` or `const T&` over `T&&` after perfect forwarding changes
+* Fix `Reference<T>` constructor overload resolution so forwarded arguments bind to the typed overload instead of falling through to `Reference(VALUE)`
+* Reject incomplete `std::unique_ptr` bindings at compile time
+
+### Enhancements
+
+* Forward `Object::call` arguments without copying
+* Forward Rice constructor rvalue arguments
+* Forward `std::function` callback arguments
+* Add support for `To_Ruby<T&>` for types missing it
+* Allow raw Ruby procs and lambdas to convert directly to `std::function` parameters while keeping the callable alive with `Pin`
+* Only define equality-based STL container methods when the contained type supports C++ equality comparison
+
+## 4.11.5 (2026-03-24)
+
+### Bug Fixes
+
+* Fix Valgrind invalid reads caused by stale GC root addresses (#399)
+* Fix `rb_gc_register_address()` triggering GC before Anchor stores heap object — use `RB_GC_GUARD` to keep VALUE alive
+* Fix gem packaging warning
+
 ## 4.11.4 (2026-03-13)
 
 ### Bug Fixes

data/CMakePresets.json

@@ -9,7 +9,7 @@
       "installDir": "${sourceDir}/install/${presetName}",
       "cacheVariables": {
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -fvisibility=hidden -fvisibility-inlines-hidden"
+        "CMAKE_CXX_FLAGS": "-Wall -Wno-array-bounds -ftemplate-backtrace-limit=0 -fvisibility=hidden -fvisibility-inlines-hidden"
       }
     },
     {
@@ -81,7 +81,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "g++.exe",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -fvisibility=hidden -fvisibility-inlines-hidden",
+        "CMAKE_CXX_FLAGS": "-Wall -Wno-array-bounds -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -fvisibility=hidden -fvisibility-inlines-hidden",
         "CMAKE_CXX_FLAGS_DEBUG": "-g3 -Og -fno-omit-frame-pointer -fno-inline -gsplit-dwarf"
       },
       "condition": {
@@ -97,7 +97,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
         "CMAKE_CXX_COMPILER": "g++.exe",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -fvisibility=hidden -fvisibility-inlines-hidden",
+        "CMAKE_CXX_FLAGS": "-Wall -Wno-array-bounds -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -fvisibility=hidden -fvisibility-inlines-hidden",
         "CMAKE_CXX_FLAGS_RELEASE": "-O3 -DNDEBUG",
         "CMAKE_SHARED_LINKER_FLAGS_RELEASE": "-Wl,--exclude-all-symbols"
       },

data/bin/rice-doc.rb

@@ -1,3 +1,5 @@
+#! /usr/bin/env ruby
+
 require 'libxml-ruby'
 
 # Require rice

data/include/rice/rice.hpp

@@ -189,6 +189,9 @@ namespace Rice
     constexpr bool is_ostreamable_v = is_ostreamable<T>::value;
 
     // Is the type comparable?
+    // Libraries with unconstrained operator== declarations may specialize this
+    // trait to false when equality is not actually usable by Rice's STL
+    // wrappers.
     template<typename T, typename SFINAE = void>
     struct is_comparable : std::false_type {};
 
@@ -859,6 +862,7 @@ namespace Rice::detail
 // =========   Anchor.hpp   =========
 
 #include <ruby.h>
+#include <ruby/vm.h>
 
 namespace Rice
 {
@@ -893,7 +897,6 @@ namespace Rice
       VALUE get() const;
 
     private:
-      static void disable(VALUE);
       static void registerExitHandler();
 
       inline static bool enabled_ = true;
@@ -1094,6 +1097,7 @@ namespace Rice
         break;
       case RUBY_TAG_THROW:
         this->message_ = "Unexpected throw";
+        break;
       case RUBY_TAG_RAISE:
         this->message_ = "Ruby exception was thrown";
         break;
@@ -1590,6 +1594,7 @@ namespace Rice::detail
     static constexpr double SignedToUnsigned = 0.5;// Penalty for signed to unsigned (can't represent negatives)
     static constexpr double FloatToInt = 0.5;      // Domain change penalty when converting float to int (lossy)
     static constexpr double ConstMismatch = 0.99;  // Penalty for const mismatch
+    static constexpr double RValueMismatch = 0.98; // Prefer borrowing wrapped objects over moving from them
   };
 }
 
@@ -1667,23 +1672,28 @@ namespace Rice
 {
   namespace detail
   {
-    inline Anchor::Anchor(VALUE value) : value_(value)
+    inline Anchor::Anchor(VALUE value)
     {
+      // rb_gc_register_address() can trigger GC, so we must register the
+      // empty this->value_ slot before storing a heap VALUE in it.
+      // RB_GC_GUARD(value) keeps the ctor argument alive through the end of
+      // this method until the registered slot has been updated.
       if (!RB_SPECIAL_CONST_P(value))
       {
         Anchor::registerExitHandler();
         detail::protect(rb_gc_register_address, &this->value_);
         this->registered_ = true;
       }
+      this->value_ = value;
+      RB_GC_GUARD(value);
     }
 
     inline Anchor::~Anchor()
     {
       if (Anchor::enabled_ && this->registered_)
       {
-        detail::protect(rb_gc_unregister_address, &this->value_);
+        rb_gc_unregister_address(&this->value_);
       }
-      // Ruby auto detects VALUEs in the stack, so make sure up in case this object is on the stack
       this->registered_ = false;
       this->value_ = Qnil;
     }
@@ -1693,17 +1703,18 @@ namespace Rice
       return this->value_;
     }
 
-    // This will be called by ruby at exit - we want to disable further unregistering
-    inline void Anchor::disable(VALUE)
-    {
-      Anchor::enabled_ = false;
-    }
-
     inline void Anchor::registerExitHandler()
     {
       if (!Anchor::exitHandlerRegistered_)
       {
-        detail::protect(rb_set_end_proc, &Anchor::disable, Qnil);
+        // Use ruby_vm_at_exit which fires AFTER the VM is destroyed,
+        // not rb_set_end_proc which fires BEFORE. rb_set_end_proc
+        // runs as an end_proc in LIFO order alongside at_exit blocks,
+        // so its timing depends on require order — if the extension
+        // loads after minitest/autorun, the disable callback runs
+        // before tests execute, causing Anchor destructors to skip
+        // rb_gc_unregister_address and leave dangling root pointers.
+        ruby_vm_at_exit([](ruby_vm_t*) { Anchor::enabled_ = false; });
         Anchor::exitHandlerRegistered_ = true;
       }
     }
@@ -2026,7 +2037,7 @@ namespace Rice
     *  \endcode
     */
     template<typename ...Parameter_Ts>
-    Object call(Identifier id, Parameter_Ts... args) const;
+    Object call(Identifier id, Parameter_Ts&&... args) const;
 
     //! Call the Ruby method specified by 'id' on object 'obj'.
     /*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
@@ -2049,7 +2060,7 @@ namespace Rice
     *  \endcode
     */
     template<typename ...Parameter_Ts>
-    Object call_kw(Identifier id, Parameter_Ts... args) const;
+    Object call_kw(Identifier id, Parameter_Ts&&... args) const;
 
     //! Vectorized call.
     /*! Calls the method identified by id with the list of arguments
@@ -4272,7 +4283,7 @@ namespace Rice
 
   public:
     Reference();
-    Reference(T& data);
+    Reference(const T& data);
     Reference(VALUE value);
     T& get();
 
@@ -4281,7 +4292,7 @@ namespace Rice
   };
 
   // Specialization needed when VALUE type matches T, causing constructor ambiguity
-  // between Reference(T&) and Reference(VALUE). VALUE is unsigned long when
+  // between Reference(const T&) and Reference(VALUE). VALUE is unsigned long when
   // SIZEOF_LONG == SIZEOF_VOIDP (Linux/macOS) and unsigned long long when
   // SIZEOF_LONG_LONG == SIZEOF_VOIDP (Windows x64).
 #if SIZEOF_LONG == SIZEOF_VOIDP
@@ -4453,6 +4464,12 @@ namespace Rice::detail
         {
           result = Convertible::None;
         }
+        // Existing wrapped Ruby objects should prefer borrowing overloads to
+        // rvalue-reference overloads so they are not silently moved-from.
+        else if constexpr (std::is_rvalue_reference_v<T>)
+        {
+          result = Convertible::RValueMismatch;
+        }
         // It is ok to send a non-const value to a const parameter but
         // prefer non-const to non-const by slightly decreasing the score
         else if (!isConst && is_const_any_v<T>)
@@ -4489,6 +4506,11 @@ namespace Rice::detail
     {
       return this->fromRuby_.convert(valueOpt.value());
     }
+    else if constexpr (std::is_rvalue_reference_v<T>)
+    {
+      // Rvalue-reference parameters cannot safely use stored default values.
+      // Materializing them from std::any would require moving from shared state.
+    }
     // Remember std::is_copy_constructible_v<std::vector<std::unique_ptr<T>>>> returns true. Sigh.
     // So special case vector handling
     else if constexpr (detail::is_std_vector_v<detail::intrinsic_type<T>>)
@@ -6453,6 +6475,25 @@ namespace Rice
       Arg* arg_ = nullptr;
     };
 
+    template<>
+    class To_Ruby<char*&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char* data)
+      {
+        return To_Ruby<char*>(arg_).convert(data);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     template<int N>
     class To_Ruby<char[N]>
     {
@@ -6485,6 +6526,25 @@ namespace Rice
       Arg* arg_ = nullptr;
     };
 
+    template<int N>
+    class To_Ruby<char(&)[N]>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(const char (&buffer)[N])
+      {
+        return To_Ruby<char[N]>(arg_).convert(buffer);
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  unsigned char  ============
     template<>
     class To_Ruby<unsigned char>
@@ -7206,6 +7266,25 @@ namespace Rice
       Arg* arg_ = nullptr;
     };
 
+    template<>
+    class To_Ruby<std::nullptr_t&>
+    {
+    public:
+      To_Ruby() = default;
+
+      explicit To_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
+      VALUE convert(std::nullptr_t const)
+      {
+        return Qnil;
+      }
+
+    private:
+      Arg* arg_ = nullptr;
+    };
+
     // ===========  void  ============
     template<>
     class To_Ruby<void>
@@ -7264,6 +7343,7 @@ namespace Rice
     };
  }
 }
+
 // =========   from_ruby.ipp   =========
 #include <limits>
 #include <optional>
@@ -9044,7 +9124,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Reference<T>::Reference(T& data) : data_(data)
+  inline Reference<T>::Reference(const T& data) : data_(data)
   {
   }
 
@@ -10282,10 +10362,10 @@ namespace Rice::detail
 
     if constexpr (is_complete_v<T>)
     {
-      // is_abstract_v requires a complete type, so nest inside is_complete_v.
-      // Deleting an abstract class through a non-virtual destructor is UB,
+      // is_polymorphic_v requires a complete type, so nest inside is_complete_v.
+      // Deleting a polymorphic class through a non-virtual destructor is UB,
       // but it is safe if the destructor is virtual.
-      if constexpr (std::is_destructible_v<T> && (!std::is_abstract_v<T> || std::has_virtual_destructor_v<T>))
+      if constexpr (std::is_destructible_v<T> && (!std::is_polymorphic_v<T> || std::has_virtual_destructor_v<T>))
       {
         if (this->isOwner_)
         {
@@ -12657,6 +12737,25 @@ namespace Rice::detail
     }
   };
 
+  // Wraps a C++ function as a Ruby proc
+  template<typename Return_T, typename ...Parameter_Ts>
+  class To_Ruby<Return_T(*&)(Parameter_Ts...)>
+  {
+  public:
+    using Proc_T = Return_T(*&)(Parameter_Ts...);
+
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg*)
+    {}
+
+    VALUE convert(Proc_T proc)
+    {
+      // Wrap the C+++ function pointer as a Ruby Proc
+      return NativeProc<Proc_T>::createRubyProc(std::forward<Proc_T>(proc));
+    }
+  };
+
   // Makes a Ruby proc callable as C callback
   template<typename Return_T, typename ...Parameter_Ts>
   class From_Ruby<Return_T(*)(Parameter_Ts...)>
@@ -12709,53 +12808,6 @@ namespace Rice
   }
 }
 
-/*namespace Rice::detail
-{
-  template<>
-  struct Type<Encoding>
-  {
-    static bool verify()
-    {
-      return true;
-    }
-  };
-  
-  template<>
-  class To_Ruby<Encoding>
-  {
-  public:
-    VALUE convert(const Encoding& encoding)
-    {
-    //  return x.value();
-    }
-  };
-
-  template<>
-  class From_Ruby<Encoding>
-  {
-  public:
-    Convertible is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_SYMBOL:
-          return Convertible::Exact;
-          break;
-      case RUBY_T_STRING:
-          return Convertible::Cast;
-          break;
-        default:
-          return Convertible::None;
-        }
-    }
-
-    Encoding convert(VALUE value)
-    {
-     // return Symbol(value);
-    }
-  };
-}
-*/
 // =========   Object.ipp   =========
 namespace Rice
 {
@@ -12801,7 +12853,7 @@ namespace Rice
   }
 
   template<typename ...Parameter_Ts>
-  inline Object Object::call(Identifier id, Parameter_Ts... args) const
+  inline Object Object::call(Identifier id, Parameter_Ts&&... args) const
   {
     /* IMPORTANT - We store VALUEs in an array that is a local variable.
        That allows the Ruby garbage collector to find them when scanning
@@ -12815,10 +12867,10 @@ namespace Rice
   }
 
   template<typename ...Parameter_Ts>
-  inline Object Object::call_kw(Identifier id, Parameter_Ts... args) const
+  inline Object Object::call_kw(Identifier id, Parameter_Ts&&... args) const
   {
     /* IMPORTANT - See call() above */
-    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(args)... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(std::forward<Parameter_Ts>(args))... };
     return detail::protect(rb_funcallv_kw, this->validated_value(), id.id(), (int)values.size(), (const VALUE*)values.data(), RB_PASS_KEYWORDS);
   }
 
@@ -13166,6 +13218,25 @@ namespace Rice::detail
       return x.value();
     }
 
+    private:
+    Arg* arg_ = nullptr;
+  };
+
+  template<>
+  class To_Ruby<String&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    VALUE convert(String const& x)
+    {
+      return x.value();
+    }
+
   private:
     Arg* arg_ = nullptr;
   };
@@ -13899,6 +13970,25 @@ namespace Rice::detail
     Arg* arg_ = nullptr;
   };
 
+  template<>
+  class To_Ruby<Hash&>
+  {
+  public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    VALUE convert(Hash const& x)
+    {
+      return x.value();
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+
   template<>
   class From_Ruby<Hash>
   {
@@ -15113,7 +15203,7 @@ namespace Rice
     static void initialize(VALUE self, Parameter_Ts...args)
     {
       // Call C++ constructor
-      T* data = new T(args...);
+      T* data = new T(std::forward<Parameter_Ts>(args)...);
       detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
@@ -15147,11 +15237,12 @@ namespace Rice
       static void initialize(Object self, Parameter_Ts...args)
       {
         // Call C++ constructor
-        T* data = new T(self, args...);
+        T* data = new T(self, std::forward<Parameter_Ts>(args)...);
         detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data);
       }
   };
 }
+
 // =========   Callback.hpp   =========
 
 namespace Rice
@@ -15514,16 +15605,6 @@ namespace Rice::detail
     Arg* arg_ = nullptr;
   };
 
-  template<typename T>
-  class To_Ruby<Data_Object<T>>
-  {
-  public:
-    VALUE convert(const Object& x)
-    {
-      return x.value();
-    }
-  };
-
   template <typename T>
   class From_Ruby
   {
@@ -15869,38 +15950,6 @@ namespace Rice::detail
     Arg* arg_ = nullptr;
     std::vector<Intrinsic_T*> vector_;
   };
-
-  template<typename T>
-  class From_Ruby<Data_Object<T>>
-  {
-    static_assert(!std::is_fundamental_v<intrinsic_type<T>>,
-                  "Data_Object cannot be used with fundamental types");
-
-    static_assert(!std::is_same_v<T, std::map<T, T>> && !std::is_same_v<T, std::unordered_map<T, T>> &&
-                  !std::is_same_v<T, std::monostate> && !std::is_same_v<T, std::multimap<T, T>> &&
-                  !std::is_same_v<T, std::optional<T>> && !std::is_same_v<T, std::pair<T, T>> &&
-                  !std::is_same_v<T, std::set<T>> && !std::is_same_v<T, std::string> &&
-                  !std::is_same_v<T, std::vector<T>>,
-                  "Please include rice/stl.hpp header for STL support");
-
-  public:
-    double is_convertible(VALUE value)
-    {
-      switch (rb_type(value))
-      {
-        case RUBY_T_DATA:
-          return Data_Type<T>::is_descendant(value) ? Convertible::Exact : Convertible::None;
-          break;
-        default:
-          return Convertible::None;
-        }
-    }
-
-    static Data_Object<T> convert(VALUE value)
-    {
-      return Data_Object<T>(value);
-    }
-  };
 }
 
 // =========   Enum.hpp   =========