rice 4.9.0 → 4.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ee7533ef1a2e8fae4a992ef2d1dc2f3dd1cd4ab260217058e9de77ead8f80b
-  data.tar.gz: 83393a7a4238d817da51eccc5392d318bb2dab00e57d9ce688867a748a50f7a5
+  metadata.gz: 6482695048d122782acef1d7ee310c47c85cff57eb39c8740db46013a4af0e87
+  data.tar.gz: a4b3c772ac9d5baff75ad80dbc404dde8a3fc67c821836203dfdcef948877091
 SHA512:
-  metadata.gz: 26c796a5fcac6d816f9cddda0944be07a16cc93a0264221a351f4612061ed3b0e61dd4ab99eae0470ebc62e483f762820116024f6814f9f0023adccc466d66cf
-  data.tar.gz: aacb86cb9d086100650839ac2cf2cf49d60dcf4604f3539be24e0922c3f3ca3a8f06dfb0511e1e1b3281e9f475cf621218ac165b4c155e5d6e4e2083b3444823
+  metadata.gz: 553618d580f7734d23a0c0278636fe725f48cacd68572fa9d6cee828fed68b2af84cda1fecdad4bb65633ada077bf4b34a703e2bd25173bd4f3ae0de91c54c26
+  data.tar.gz: '0368ac5a1d1d957ab8a94dcec8a25c6e5cc539930848db9f78077c6006b86a6d81299af839ab1daed52fab9ce743496cebcff6e3698483961c0fc6cc2bef82b4'

data/CHANGELOG.md

@@ -1,4 +1,20 @@
-# Changelog 
+# Changelog
+
+## 4.9.1 (2026-01-04)
+This release focuses on improving memory management for STL containers and attribute setters.
+
+Enhancements:
+* Support `takeOwnership` and `keepAlive` when setting attributes via `Arg("value").takeOwnership()` and `Arg("value").keepAlive()`
+* Add `Arg` parameter names to all STL container methods for keyword argument support
+* Add `keepAlive` support for STL container operations (vector push/insert, set insert, map/multimap store)
+* Add `keepAlive` for map/unordered_map/multimap keys to prevent GC of pointer-type keys
+
+Bug Fixes:
+* Fix error when multiple overloaded methods take different types of vectors
+* Fix type unknown errors when using `std::shared_ptr` with g++
+* Fix CMake `_Ruby_DLEXT` variable type (string, not path)
+* Fix crash caused by static variable in keepAlive implementation
+* Fix incorrect attribute overloading behavior
 
 ## 4.9.0 (2026-01-01)
 This release revamps smart pointer support for `std::shared_ptr` and `std::unique_ptr`.

data/CMakePresets.json

@@ -6,7 +6,11 @@
       "hidden": true,
       "generator": "Ninja",
       "binaryDir": "${sourceDir}/build/${presetName}",
-      "installDir": "${sourceDir}/install/${presetName}"
+      "installDir": "${sourceDir}/install/${presetName}",
+      "cacheVariables": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -fvisibility=hidden -fvisibility-inlines-hidden"
+      }
     },
     {
       "name": "linux-debug",
@@ -14,7 +18,7 @@
       "displayName": "Linux Debug",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -Og"
+        "CMAKE_CXX_FLAGS_DEBUG": "-ggdb3 -O0 -fno-omit-frame-pointer -fno-inline -fno-optimize-sibling-calls"
       },
       "condition": {
         "type": "equals",
@@ -28,7 +32,9 @@
       "displayName": "Linux Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -O3 -DNDEBUG"
+        "CMAKE_CXX_FLAGS_RELEASE": "-O3 -DNDEBUG",
+        "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON",
+        "CMAKE_SHARED_LINKER_FLAGS_RELEASE": "-Wl,--exclude-libs,ALL -Wl,--strip-all"
       },
       "condition": {
         "type": "equals",
@@ -42,7 +48,8 @@
       "displayName": "macOS Debug",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_FLAGS": "-Wall -Wno-unused-private-field -ftemplate-backtrace-limit=0 -Og"
+        "CMAKE_CXX_FLAGS": "-Wall -Wno-unused-private-field -ftemplate-backtrace-limit=0 -fvisibility=hidden -fvisibility-inlines-hidden",
+        "CMAKE_CXX_FLAGS_DEBUG": "-g3 -Og -fno-omit-frame-pointer -fno-inline -gsplit-dwarf"
       },
       "condition": {
         "type": "equals",
@@ -56,7 +63,10 @@
       "displayName": "macOS Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_FLAGS": "-Wall -Wno-unused-private-field -ftemplate-backtrace-limit=0 -O3 -DNDEBUG"
+        "CMAKE_CXX_FLAGS": "-Wall -Wno-unused-private-field -ftemplate-backtrace-limit=0 -fvisibility=hidden -fvisibility-inlines-hidden",
+        "CMAKE_CXX_FLAGS_RELEASE": "-O3 -DNDEBUG",
+        "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON",
+        "CMAKE_SHARED_LINKER_FLAGS_RELEASE": "-Wl,-dead_strip -Wl,-x"
       },
       "condition": {
         "type": "equals",
@@ -65,99 +75,116 @@
       }
     },
     {
-      "name": "windows",
-      "hidden": true,
+      "name": "mingw-debug",
+      "inherits": "base",
+      "displayName": "Mingw x64 Debug",
+      "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_DEBUG": "-g3 -Og -fno-omit-frame-pointer -fno-inline -gsplit-dwarf"
+      },
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Windows"
+      }
+    },
+    {
+      "name": "mingw-release",
       "inherits": "base",
+      "displayName": "Mingw x64 Release",
+      "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_RELEASE": "-O3 -DNDEBUG",
+        "CMAKE_SHARED_LINKER_FLAGS_RELEASE": "-Wl,--exclude-all-symbols"
+      },
       "condition": {
         "type": "equals",
         "lhs": "${hostSystemName}",
         "rhs": "Windows"
+      }
+    },
+    {
+      "name": "windows-base",
+      "hidden": true,
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/${presetName}",
+      "installDir": "${sourceDir}/install/${presetName}",
+      "toolchainFile": "$env{VCPKG_ROOT}\\scripts\\buildsystems\\vcpkg.cmake",
+      "cacheVariables": {
+        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE"
       },
-      "toolchainFile": "$env{VCPKG_ROOT}\\scripts\\buildsystems\\vcpkg.cmake"
+      "condition": {
+        "type": "equals",
+        "lhs": "${hostSystemName}",
+        "rhs": "Windows"
+      }
     },
     {
       "name": "msvc-debug",
-      "inherits": "windows",
+      "inherits": "windows-base",
       "displayName": "MSVC x64 Debug",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE",
-        "CMAKE_MSVC_DEBUG_INFORMATION_FORMAT": "EditAndContinue"
+        "CMAKE_CXX_FLAGS_DEBUG": "/Od",
+        "CMAKE_MSVC_DEBUG_INFORMATION_FORMAT": "ProgramDatabase"
       }
     },
     {
       "name": "msvc-release",
-      "inherits": "windows",
+      "inherits": "windows-base",
       "displayName": "MSVC x64 Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
         "CMAKE_CXX_COMPILER": "cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /O2 /DNDEBUG /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE",
+        "CMAKE_CXX_FLAGS_RELEASE": "/O2 /DNDEBUG",
+        "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON",
         "CMAKE_MSVC_DEBUG_INFORMATION_FORMAT": "ProgramDatabase"
       }
     },
+
     {
       "name": "clang-windows-debug",
-      "inherits": "windows",
+      "inherits": "windows-base",
       "displayName": "Clang Windows Debug",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field"
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS_DEBUG": "/Od /Zi"
       }
     },
     {
       "name": "clang-windows-release",
-      "inherits": "windows",
+      "inherits": "windows-base",
       "displayName": "Clang Windows Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
         "CMAKE_CXX_COMPILER": "clang-cl.exe",
-        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /O2 /DNDEBUG /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field"
-      }
-    },
-    {
-      "name": "mingw-debug",
-      "inherits": "base",
-      "displayName": "Mingw x64 Debug",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_COMPILER": "g++.exe",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -Og"
-      },
-      "condition": {
-        "type": "equals",
-        "lhs": "${hostSystemName}",
-        "rhs": "Windows"
-      }
-    },
-    {
-      "name": "mingw-release",
-      "inherits": "base",
-      "displayName": "Mingw x64 Release",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_COMPILER": "g++.exe",
-        "CMAKE_CXX_FLAGS": "-Wall -ftemplate-backtrace-limit=0 -Wa,-mbig-obj -O3 -DNDEBUG"
-      },
-      "condition": {
-        "type": "equals",
-        "lhs": "${hostSystemName}",
-        "rhs": "Windows"
+        "CMAKE_CXX_FLAGS": "/EHs /W4 /bigobj /utf-8 /D_CRT_SECURE_NO_DEPRECATE /D_CRT_NONSTDC_NO_DEPRECATE /clang:-Wno-unused-private-field",
+        "CMAKE_CXX_FLAGS_RELEASE": "/O2 /DNDEBUG",
+        "CMAKE_INTERPROCEDURAL_OPTIMIZATION": "ON"
       }
     }
   ],
+
   "buildPresets": [
     {
       "name": "linux-debug",
       "displayName": "Build Linux Debug",
-      "configurePreset": "linux-debug"
+      "configurePreset": "linux-debug",
+      "jobs": 6
     },
     {
       "name": "linux-release",
       "displayName": "Build Linux Release",
-      "configurePreset": "linux-release"
+      "configurePreset": "linux-release",
+      "jobs": 6
     },
     {
       "name": "macos-debug",
@@ -200,4 +227,4 @@
       "configurePreset": "mingw-release"
     }
   ]
-}
+}

data/FindRuby.cmake

@@ -428,7 +428,7 @@ if (Ruby_EXECUTABLE AND NOT Ruby_EXECUTABLE STREQUAL "${_Ruby_EXECUTABLE_LAST_QU
   set(_Ruby_POSSIBLE_LIB_DIR ${_Ruby_POSSIBLE_LIB_DIR} CACHE INTERNAL "The Ruby lib dir" FORCE)
   set(Ruby_RUBY_LIB_DIR ${Ruby_RUBY_LIB_DIR} CACHE INTERNAL "The Ruby ruby-lib dir" FORCE)
   set(_Ruby_SO_NAME ${_Ruby_SO_NAME} CACHE PATH "The Ruby shared library name" FORCE)
-  set(_Ruby_DLEXT ${_Ruby_DLEXT} CACHE PATH "Ruby extensions extension" FORCE)
+  set(_Ruby_DLEXT ${_Ruby_DLEXT} CACHE STRING "Ruby extensions extension" FORCE)
   set(Ruby_SITEARCH_DIR ${Ruby_SITEARCH_DIR} CACHE INTERNAL "The Ruby site arch dir" FORCE)
   set(Ruby_SITELIB_DIR ${Ruby_SITELIB_DIR} CACHE INTERNAL "The Ruby site lib dir" FORCE)
   set(Ruby_HAS_VENDOR_RUBY ${Ruby_HAS_VENDOR_RUBY} CACHE BOOL "Vendor Ruby is available" FORCE)

data/include/rice/rice.hpp

@@ -599,6 +599,10 @@ namespace Rice::detail
 {
   class WrapperBase
   {
+  public:
+    static void addKeepAlive(VALUE object, VALUE keepAlive);
+    static bool isConst(VALUE object);
+
   public:
     WrapperBase(rb_data_type_t* rb_data_type);
     virtual ~WrapperBase() = default;
@@ -672,7 +676,7 @@ namespace Rice::detail
 
   // ---- Helper Functions ---------
   template <typename T>
-  void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data);
+  Wrapper<T*>* wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data);
 
   template <typename T>
   VALUE wrap(VALUE klass, rb_data_type_t* rb_data_type, T& data, bool isOwner);
@@ -3020,8 +3024,9 @@ namespace Rice
       using Receiver_T = typename attribute_traits<Attribute_T>::class_type;
 
     public:
-      // Register attribute getter/setter with Ruby
-      static void define(VALUE klass, std::string name, Attribute_T attribute);
+      // Register attribute setter with Ruby
+      template<typename...Arg_Ts>
+      static void define(VALUE klass, std::string name, Attribute_T attribute, Arg_Ts&...args);
 
     public:
       // Disallow creating/copying/moving
@@ -3039,11 +3044,12 @@ namespace Rice
       VALUE returnKlass() override;
 
     protected:
-      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr);
+      NativeAttributeSet(VALUE klass, std::string name, Attribute_T attr, std::unique_ptr<Parameter<T_Unqualified>> parameter);
 
     private:
       VALUE klass_;
       Attribute_T attribute_;
+      std::unique_ptr<Parameter<T_Unqualified>> parameter_;
     };
   } // detail
 } // Rice
@@ -3804,10 +3810,11 @@ namespace Rice::detail
     NativeRegistry& operator=(const NativeRegistry& other) = delete;
 
     void add(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
+    void replace(VALUE klass, ID methodId, std::unique_ptr<Native>& native);
     void reset(VALUE klass);
 
-    const std::vector<Native*> lookup(VALUE klass);
-    const std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
+    std::vector<Native*> lookup(VALUE klass);
+    std::vector<std::unique_ptr<Native>>& lookup(VALUE klass, ID methodId);
     std::vector<Native*> lookup(VALUE klass, NativeKind kind);
 
   private:
@@ -3976,17 +3983,16 @@ namespace Rice::detail
     // One caveat - procs are also RUBY_T_DATA so don't check if this is a function type
     if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA && !std::is_function_v<std::remove_pointer_t<T>>)
     {
-      // Check the constness of the Ruby wrapped value and the parameter
-      WrapperBase* wrapper = getWrapper(value);
+      bool isConst = WrapperBase::isConst(value);
 
       // Do not send a const value to a non-const parameter
-      if (wrapper->isConst() && !is_const_any_v<T>)
+      if (isConst && !is_const_any_v<T>)
       {
         result = Convertible::None;
       }
       // 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 (!wrapper->isConst() && is_const_any_v<T>)
+      else if (!isConst && is_const_any_v<T>)
       {
         result = Convertible::ConstMismatch;
       }
@@ -8929,17 +8935,21 @@ namespace Rice::detail
 {
   inline void NativeRegistry::add(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
   {
-    if (rb_type(klass) == T_ICLASS)
-    {
-      klass = detail::protect(rb_class_of, klass);
-    }
+    // Lookup items for method
+    std::vector<std::unique_ptr<Native>>& natives = NativeRegistry::lookup(klass, methodId);
 
-    // Create the key
-    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
+    // Add new native
+    natives.push_back(std::move(native));
+  }
 
+  inline void NativeRegistry::replace(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
+  {
     // Lookup items for method
-    std::vector<std::unique_ptr<Native>>& natives = this->natives_[key];
+    std::vector<std::unique_ptr<Native>>& natives = NativeRegistry::lookup(klass, methodId);
 
+    // Clear existing natives
+    natives.clear();
+    // Add new native
     natives.push_back(std::move(native));
   }
 
@@ -8959,7 +8969,7 @@ namespace Rice::detail
     }
   }
   
-  inline const std::vector<Native*> NativeRegistry::lookup(VALUE klass)
+  inline std::vector<Native*> NativeRegistry::lookup(VALUE klass)
   {
     std::vector<Native*> result;
 
@@ -8985,7 +8995,7 @@ namespace Rice::detail
     return result;
   }
 
-  inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
+  inline std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)
     {
@@ -9577,6 +9587,18 @@ namespace Rice::detail
 
 namespace Rice::detail
 {
+  inline void WrapperBase::addKeepAlive(VALUE object, VALUE keepAlive)
+  {
+    WrapperBase* wrapper = getWrapper(object);
+    wrapper->addKeepAlive(keepAlive);
+  }
+
+  inline bool WrapperBase::isConst(VALUE object)
+  {
+    WrapperBase* wrapper = getWrapper(object);
+    return wrapper->isConst();
+  }
+
   inline WrapperBase::WrapperBase(rb_data_type_t* rb_data_type) : rb_data_type_(rb_data_type)
   {
   }
@@ -9874,7 +9896,7 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline void wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
+  inline Wrapper<T*>* wrapConstructed(VALUE value, rb_data_type_t* rb_data_type, T* data)
   {
     using Wrapper_T = Wrapper<T*>;
 
@@ -9890,6 +9912,8 @@ namespace Rice::detail
     RTYPEDDATA_DATA(value) = wrapper;
 
     Registries::instance.instances.add(data, value);
+
+    return wrapper;
   }
 }
 
@@ -10072,16 +10096,14 @@ namespace Rice::detail
       Arg* arg = parameters_[i]->arg();
       if (arg->isKeepAlive())
       {
-        static WrapperBase* selfWrapper = getWrapper(self);
-        selfWrapper->addKeepAlive(rubyValues[i].value());
+        WrapperBase::addKeepAlive(self, rubyValues[i].value());
       }
     }
 
     // Check return value
     if (this->returnInfo_->isKeepAlive())
     {
-      WrapperBase* returnWrapper = getWrapper(returnValue);
-      returnWrapper->addKeepAlive(self);
+      WrapperBase::addKeepAlive(returnValue, self);
     }
   }
 
@@ -10420,7 +10442,7 @@ namespace Rice::detail
     // matches or calls function pointer. Instead Ruby can call the static call method defined on
     // this class (&NativeAttribute_T::get).
     Identifier identifier(name);
-    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+    detail::Registries::instance.natives.replace(klass, identifier.id(), native);
   }
 
   template<typename Attribute_T>
@@ -10525,28 +10547,46 @@ namespace Rice::detail
 namespace Rice::detail
 {
   template<typename Attribute_T>
-  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute)
+  template<typename...Arg_Ts>
+  void NativeAttributeSet<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, Arg_Ts&...args)
   {
-    // Create a NativeAttributeSet that Ruby will call to read/write C++ variables
-    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute));
+    // Extract Arg from Arg_Ts if present, otherwise create default
+    using Arg_Tuple = std::tuple<Arg_Ts...>;
+    constexpr std::size_t index = tuple_element_index_v<Arg_Tuple, Arg, ArgBuffer>;
+
+    std::unique_ptr<Arg> arg;
+    if constexpr (index < std::tuple_size_v<Arg_Tuple>)
+    {
+      using Arg_T_Local = std::decay_t<std::tuple_element_t<index, Arg_Tuple>>;
+      const Arg_T_Local& argInfo = std::get<index>(std::forward_as_tuple(std::forward<Arg_Ts>(args)...));
+      arg = std::make_unique<Arg_T_Local>(argInfo);
+    }
+    else
+    {
+      arg = std::make_unique<Arg>("value");
+    }
+
+    // Create the parameter
+    auto parameter = std::make_unique<Parameter<T_Unqualified>>(std::move(arg));
+
+    // Create a NativeAttributeSet that Ruby will call to write C++ variables
+    NativeAttribute_T* nativeAttribute = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), std::move(parameter));
     std::unique_ptr<Native> native(nativeAttribute);
 
     // Define the write method name
     std::string setter = name + "=";
 
-    // Tell Ruby to invoke the static method write to get the attribute value
+    // Tell Ruby to invoke the static method resolve to set the attribute value
     detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&Native::resolve, -1);
 
-    // Add to native registry. Since attributes cannot be overridden, there is no need to set the
-    // matches or calls function pointer. Instead Ruby can call the static call method defined on
-    // this class (&NativeAttribute_T::set).
+    // Add to native registry
     Identifier identifier(setter);
-    detail::Registries::instance.natives.add(klass, identifier.id(), native);
+    detail::Registries::instance.natives.replace(klass, identifier.id(), native);
   }
 
   template<typename Attribute_T>
-  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute)
-    : Native(name), klass_(klass), attribute_(attribute)
+  NativeAttributeSet<Attribute_T>::NativeAttributeSet(VALUE klass, std::string name, Attribute_T attribute, std::unique_ptr<Parameter<T_Unqualified>> parameter)
+    : Native(name), klass_(klass), attribute_(attribute), parameter_(std::move(parameter))
   {
   }
 
@@ -10567,25 +10607,25 @@ namespace Rice::detail
       throw std::runtime_error("Incorrect number of parameters for setting attribute. Attribute: " + this->name_);
     }
 
+    // Get the Ruby value and convert to native
     VALUE value = values.begin()->second;
+    std::optional<VALUE> valueOpt(value);
+    T_Unqualified nativeValue = this->parameter_->convertToNative(valueOpt);
 
     if constexpr (!std::is_null_pointer_v<Receiver_T>)
     {
       Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
-
-      // Deal with pointers to pointes, see Parameter::convertToNative commment
-      if constexpr (is_pointer_pointer_v<Attr_T> && !std::is_convertible_v<remove_cv_recursive_t<Attr_T>, Attr_T>)
-      {
-        nativeSelf->*attribute_ = (Attr_T)From_Ruby<T_Unqualified>().convert(value);
-      }
-      else
-      {
-        nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
-      }
+      nativeSelf->*attribute_ = (Attr_T)nativeValue;
     }
     else
     {
-      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
+      *attribute_ = nativeValue;
+    }
+
+    // Check if we need to prevent the value from being garbage collected
+    if (this->parameter_->arg()->isKeepAlive())
+    {
+      WrapperBase::addKeepAlive(self, value);
     }
 
     return value;
@@ -10606,18 +10646,8 @@ namespace Rice::detail
   template<typename Attribute_T>
   inline VALUE NativeAttributeSet<Attribute_T>::returnKlass()
   {
-    // Check if an array is being returned
-    bool isBuffer = dynamic_cast<ReturnBuffer*>(this->returnInfo_.get()) ? true : false;
-    if (isBuffer)
-    {
-      TypeMapper<Pointer<detail::remove_cv_recursive_t<std::remove_pointer_t<Attr_T>>>> typeMapper;
-      return typeMapper.rubyKlass();
-    }
-    else
-    {
-      TypeMapper<Attr_T> typeMapper;
-      return typeMapper.rubyKlass();
-    }
+    TypeMapper<Attr_T> typeMapper;
+    return typeMapper.rubyKlass();
   }
 }
 
@@ -11257,30 +11287,33 @@ namespace Rice::detail
     {
       return self;
     }
-    /* This case happens when a class wrapped by Rice is calling a method
-       defined on an ancestor class. For example, the std::map size method
-       is defined on _Tree not map. Rice needs to know the actual type
-       that was wrapped so it can correctly extract the C++ object from 
-       the Ruby object. */
-    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> && 
-                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_pointer_v<Receiver_T>)
-    {
-      Class_T* instance = From_Ruby<Class_T*>().convert(self);
-      return dynamic_cast<Receiver_T>(instance);
-    }
-    else if constexpr (!std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T> &&
-                        std::is_reference_v<Receiver_T>)
-    {
-      Class_T& instance = From_Ruby<Class_T&>().convert(self);
-      return dynamic_cast<Receiver_T>(instance);
-    }
-    // Self parameter could be derived from Object or it is an C++ instance and
-    // needs to be unwrapped from Ruby
     else
     {
-      return From_Ruby<Receiver_T>().convert(self);
+      /* When a class wrapped by Rice calls a method defined on an ancestor class
+         (e.g., std::map calling a method from _Tree), we need to unwrap as Class_T
+         and dynamic_cast to the base class. Otherwise unwrap directly as Receiver_T. */
+      constexpr bool isDerived = !std::is_same_v<intrinsic_type<Receiver_T>, Class_T> &&
+                                  std::is_base_of_v<intrinsic_type<Receiver_T>, Class_T>;
+
+      if constexpr (isDerived)
+      {
+        if constexpr (std::is_pointer_v<Receiver_T>)
+        {
+          Class_T* instance = From_Ruby<Class_T*>().convert(self);
+          return dynamic_cast<Receiver_T>(instance);
+        }
+        else if constexpr (std::is_reference_v<Receiver_T>)
+        {
+          Class_T& instance = From_Ruby<Class_T&>().convert(self);
+          return dynamic_cast<Receiver_T>(instance);
+        }
+      }
+      else
+      {
+        // Note GCC has a false warning: function may return address of local variable [-Wreturn-local-addr].
+        // From_Ruby returns a reference to data in the Ruby object, not the temporary.
+        return From_Ruby<Receiver_T>().convert(self);
+      }
     }
   }
 
@@ -14548,7 +14581,7 @@ namespace Rice
       }
       else
       {
-        detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute));
+        detail::NativeAttributeSet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), args...);
       }
     }