rice 4.7.1 → 4.8.0

data/rice/Buffer.ipp

@@ -102,11 +102,11 @@ namespace Rice
       }
       default:
       {
-        if (RubyType_T::Exact.find(valueType) != RubyType_T::Exact.end() ||
-          RubyType_T::Castable.find(valueType) != RubyType_T::Castable.end() ||
-          RubyType_T::Narrowable.find(valueType) != RubyType_T::Narrowable.end())
+        if (detail::From_Ruby<detail::remove_cv_recursive_t<T>>().is_convertible(value))
         {
-          T data = detail::protect(RubyType_T::fromRuby, value);
+          // The Ruby method may return a different type - for example Ruby floats
+          // are converted to double and not float - so we need a typecast.
+          T data = (T)detail::protect(RubyType_T::fromRuby, value);
           this->m_size = 1;
           this->m_buffer = new T[this->m_size]();
           memcpy((void*)this->m_buffer, &data, sizeof(T));
@@ -115,9 +115,9 @@ namespace Rice
         }
         else
         {
-          detail::TypeMapper<T> typeMapper;
-          std::string typeName = typeMapper.name();
-          throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+          detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+          std::string typeName = typeIndexParser.name();
+          throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
             detail::protect(rb_obj_classname, value), typeName.c_str());
         }
       }
@@ -137,8 +137,8 @@ namespace Rice
         this->m_size = array.size();
 
         // Use operator new[] to allocate memory but not call constructors.
-        size_t size = sizeof(T) * this->m_size;
-        this->m_buffer = static_cast<T*>(operator new[](size));
+        size_t memsize = sizeof(T) * this->m_size;
+        this->m_buffer = static_cast<T*>(operator new[](memsize));
 
         detail::From_Ruby<Intrinsic_T> fromRuby;
 
@@ -147,7 +147,7 @@ namespace Rice
           // Construct objects in allocated memory using move or copy construction
           if constexpr (std::is_move_constructible_v<T>)
           {
-            new (&this->m_buffer[i]) T(std::move(fromRuby.convert(array[i].value())));
+            new (&this->m_buffer[i]) T(std::move(fromRuby.convert(array[(long)i].value())));
           }
           else if constexpr (std::is_copy_constructible_v<T>)
           {
@@ -155,8 +155,9 @@ namespace Rice
           }
           else
           {
+            detail::TypeIndexParser typeIndexParser(typeid(Intrinsic_T), std::is_fundamental_v<Intrinsic_T>);
             throw Exception(rb_eTypeError, "Cannot construct object of type %s - type is not move or copy constructible",
-              detail::TypeMapper<Intrinsic_T>().name().c_str());
+              typeIndexParser.name().c_str());
           }
         }
         break;
@@ -196,9 +197,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -267,8 +268,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T, std::enable_if_t<!std::is_pointer_v<T> && !std::is_void_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -345,7 +346,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
+  inline Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_size(size), m_buffer(pointer)
   {
   }
 
@@ -373,7 +374,7 @@ namespace Rice
         for (size_t i = 0; i < this->m_size; i++)
         {
           // Check the inner value is also an array
-          Array inner(outer[i].value());
+          Array inner(outer[(long)i].value());
 
           // Allocate inner buffer
           this->m_buffer[i] = new T[inner.size()]();
@@ -383,13 +384,16 @@ namespace Rice
             String packed = inner.pack<Intrinsic_T>();
             memcpy((void*)this->m_buffer[i], RSTRING_PTR(packed.value()), RSTRING_LEN(packed.value()));
           }
+          // This is for std::string, should be a 1 length array
           else
           {
             detail::From_Ruby<Intrinsic_T*> fromRuby;
-            for (int i = 0; i < inner.size(); i++)
+            if (inner.size() != 1)
             {
-              this->m_buffer[0] = fromRuby.convert(inner[i].value());
+              throw Exception(rb_eTypeError, "Expected inner array size 1 for type %s* but got %ld",
+                detail::TypeIndexParser(typeid(T)).name().c_str(), inner.size());
             }
+            this->m_buffer[i] = fromRuby.convert(inner[0].value());
           }
         }
 
@@ -409,9 +413,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -495,8 +499,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T*, std::enable_if_t<!detail::is_wrapped_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -559,7 +563,7 @@ namespace Rice
   }
 
   template<typename T>
-  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_buffer(pointer), m_size(size)
+  inline Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::Buffer(T** pointer, size_t size) : m_size(size), m_buffer(pointer)
   {
   }
 
@@ -584,7 +588,7 @@ namespace Rice
 
         for (size_t i = 0; i < this->m_size; i++)
         {
-          this->m_buffer[i] = fromRuby.convert(array[i].value());
+          this->m_buffer[i] = fromRuby.convert(array[(long)i].value());
         }
 
         this->m_owner = true;
@@ -602,9 +606,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<T> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -687,8 +691,8 @@ namespace Rice
   template<typename T>
   inline VALUE Buffer<T*, std::enable_if_t<detail::is_wrapped_v<T>>>::toString() const
   {
-    detail::TypeMapper<T*> typeMapper;
-    std::string description = "Buffer<type: " + typeMapper.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
+    detail::TypeIndexParser typeIndexParser(typeid(T*), std::is_fundamental_v<detail::intrinsic_type<T>>);
+    std::string description = "Buffer<type: " + typeIndexParser.simplifiedName() + ", size: " + std::to_string(this->m_size) + ">";
 
     // We can't use To_Ruby because To_Ruby depends on Buffer - ie a circular reference
     return detail::protect(rb_utf8_str_new_cstr, description.c_str());
@@ -750,7 +754,7 @@ namespace Rice
   }
   
   template<typename T>
-  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value, size_t size)
+  inline Buffer<T, std::enable_if_t<std::is_void_v<T>>>::Buffer(VALUE value, size_t)
   {
     ruby_value_type valueType = rb_type(value);
 
@@ -767,9 +771,9 @@ namespace Rice
       }
       default:
       {
-        detail::TypeMapper<void> typeMapper;
-        std::string typeName = typeMapper.name();
-        throw Exception(rb_eTypeError, "wrong argument type %s (expected % s*)",
+        detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+        std::string typeName = typeIndexParser.name();
+        throw Exception(rb_eTypeError, "wrong argument type %s (expected %s*)",
           detail::protect(rb_obj_classname, value), typeName.c_str());
       }
     }
@@ -863,8 +867,8 @@ namespace Rice
         define_method("size", &Buffer_T::size).
         template define_method<VALUE(Buffer_T::*)(size_t) const>("bytes", &Buffer_T::bytes, Return().setValue()).
         template define_method<VALUE(Buffer_T::*)() const>("bytes", &Buffer_T::bytes, Return().setValue()).
-        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
-        define_method("release", &Buffer_T::release, Return().setBuffer());
+        define_method("data", &Buffer_T::ptr, ReturnBuffer()).
+        define_method("release", &Buffer_T::release, ReturnBuffer());
     }
     else
     {
@@ -878,8 +882,8 @@ namespace Rice
         template define_method<Array(Buffer_T::*)(size_t) const>("to_ary", &Buffer_T::toArray, Return().setValue()).
         template define_method<Array(Buffer_T::*)() const>("to_ary", &Buffer_T::toArray, Return().setValue()).
         define_method("[]", &Buffer_T::operator[], Arg("index")).
-        define_method("data", &Buffer_T::ptr, Return().setBuffer()).
-        define_method("release", &Buffer_T::release, Return().setBuffer());
+        define_method("data", &Buffer_T::ptr, ReturnBuffer()).
+        define_method("release", &Buffer_T::release, ReturnBuffer());
 
       if constexpr (!std::is_pointer_v<T> && !std::is_void_v<T> && !std::is_const_v<T> && std::is_copy_assignable_v<T>)
       {

data/rice/Callback.hpp

@@ -16,6 +16,6 @@ namespace Rice
    *  \return nothing
    */
   template<typename Callback_T, typename...Arg_Ts>
-  void define_callback(const Arg_Ts&...args);
+  void define_callback(Arg_Ts&&...args);
 }
 #endif // Rice__Callback__hpp_

data/rice/Callback.ipp

@@ -1,13 +1,8 @@
 namespace Rice
 {
   template<typename Callback_T, typename...Arg_Ts>
-  void define_callback(const Arg_Ts&...args)
+  inline void define_callback(Arg_Ts&&...args)
   {
-    MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Callback_T>::arity, args...);
-  #ifdef HAVE_LIBFFI
-    detail::NativeCallbackFFI<Callback_T>::setMethodInfo(methodInfo);
-  #else
-    detail::NativeCallbackSimple<Callback_T>::setMethodInfo(methodInfo);
-  #endif
+    detail::NativeCallback<Callback_T>::define(std::forward<Arg_Ts>(args)...);
   }
 }

data/rice/Constructor.hpp

@@ -16,7 +16,7 @@ namespace Rice
   *
   *  For more information, see Rice::Data_Type::define_constructor.
   */
-  template<typename T, typename...Arg_Ts>
+  template<typename T, typename...Parameter_Ts>
   class Constructor;
 }
 #endif // Rice__Constructor__hpp_

data/rice/Constructor.ipp

@@ -1,16 +1,16 @@
 namespace Rice
 {
-  template<typename T, typename...Arg_Ts>
+  template<typename T, typename...Parameter_Ts>
   class Constructor
   {
   public:
-    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+    static constexpr std::size_t arity = sizeof...(Parameter_Ts);
 
     static constexpr bool isCopyConstructor()
     {
       if constexpr (arity == 1)
       {
-        using Arg_Types = std::tuple<Arg_Ts...>;
+        using Arg_Types = std::tuple<Parameter_Ts...>;
         using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
         return (arity == 1 &&
                 std::is_lvalue_reference_v<First_Arg_T> &&
@@ -26,7 +26,7 @@ namespace Rice
     {
       if constexpr (arity == 1)
       {
-        using Arg_Types = std::tuple<Arg_Ts...>;
+        using Arg_Types = std::tuple<Parameter_Ts...>;
         using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
         return (arity == 1 &&
           std::is_rvalue_reference_v<First_Arg_T> &&
@@ -38,25 +38,25 @@ namespace Rice
       }
     }
 
-    static void initialize(VALUE self, Arg_Ts...args)
+    static void initialize(VALUE self, Parameter_Ts...args)
     {
       // Call C++ constructor
       T* data = new T(args...);
-      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
     static void initialize_copy(VALUE self, const T& other)
     {
       // Call C++ copy constructor
       T* data = new T(other);
-      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+      detail::wrapConstructed<T>(self, Data_Type<T>::ruby_data_type(), data);
     }
 
   };
 
   //! Special-case Constructor used when defining Directors.
-  template<typename T, typename...Arg_Ts>
-  class Constructor<T, Object, Arg_Ts...>
+  template<typename T, typename...Parameter_Ts>
+  class Constructor<T, Object, Parameter_Ts...>
   {
     public:
       static constexpr bool isCopyConstructor()
@@ -69,11 +69,11 @@ namespace Rice
         return false;
       }
 
-      static void initialize(Object self, Arg_Ts...args)
+      static void initialize(Object self, Parameter_Ts...args)
       {
         // Call C++ constructor
         T* data = new T(self, args...);
-        detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
+        detail::wrapConstructed<T>(self.value(), Data_Type<T>::ruby_data_type(), data);
       }
   };
 }

data/rice/Data_Object.ipp

@@ -14,9 +14,9 @@ namespace Rice
     }
     else
     {
-      detail::TypeMapper<T> typeMapper;
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
       return Exception(rb_eTypeError, "Wrong argument type. Expected %s. Received %s.",
-        typeMapper.simplifiedName().c_str(),
+        typeIndexParser.simplifiedName().c_str(),
         detail::protect(rb_obj_classname, value));
     }
   }
@@ -228,7 +228,7 @@ namespace Rice::detail
     VALUE convert(U* data)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ReturnBuffer*>(this->arg_) ? true : false;
 
       if (data == nullptr)
       {
@@ -273,7 +273,7 @@ namespace Rice::detail
     VALUE convert(U* data)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ReturnBuffer*>(this->arg_) ? true : false;
  
       if (data == nullptr)
       {
@@ -361,7 +361,7 @@ namespace Rice::detail
     {
     }
     
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -412,7 +412,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -455,7 +455,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -501,9 +501,9 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      bool isBuffer = this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
@@ -528,7 +528,7 @@ namespace Rice::detail
     T* convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
@@ -584,7 +584,7 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -633,9 +633,9 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
@@ -656,7 +656,7 @@ namespace Rice::detail
     T** convert(VALUE value)
     {
       bool isOwner = this->arg_ && this->arg_->isOwner();
-      bool isBuffer = this->arg_ && this->arg_->isBuffer();
+      bool isBuffer = dynamic_cast<ArgBuffer*>(this->arg_) ? true : false;
 
       switch (rb_type(value))
       {
@@ -707,7 +707,7 @@ namespace Rice::detail
                   "Please include rice/stl.hpp header for STL support");
 
   public:
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {

data/rice/Data_Type.hpp

@@ -90,8 +90,7 @@ namespace Rice
      *  library to die at run time when it tries to convert the base
      *  type into the Director proxy type.
      *
-     *  This method takes no methodInfo, just needs the type of the
-     *  Director proxy class.
+     *  This method needs the type of the Director proxy class.
      *
      *  For example:
      *  \code
@@ -134,11 +133,11 @@ namespace Rice
     template<typename Iterator_Func_T>
     Data_Type<T>& define_iterator(Iterator_Func_T begin, Iterator_Func_T end, std::string name = "each");
 
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, const Arg_Ts&...args);
   
-    template <typename Attribute_T>
-    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, Return returnInfo = Return());
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access = AttrAccess::ReadWrite, const Arg_Ts&...args);
 
     #include "cpp_api/shared_methods.hpp"
   protected:
@@ -161,11 +160,11 @@ namespace Rice
     template<typename T_, typename Base_T>
     friend Rice::Data_Type<T_> define_class(char const * name);
 
-    template<typename Method_T>
-    void wrap_native_method(VALUE klass, std::string name, Method_T&& function, MethodInfo* methodInfo);
+    template<typename Method_T, typename...Arg_Ts>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& function, const Arg_Ts&...args);
 
-    template <typename Attribute_T>
-    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo);
+    template <typename Attribute_T, typename...Arg_Ts>
+    Data_Type<T>& define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args);
 
   private:
     template<typename T_>

data/rice/Data_Type.ipp

@@ -20,13 +20,13 @@ namespace Rice
   }
 
   template<typename T>
-  inline size_t ruby_size_internal(const T* data)
+  inline size_t ruby_size_internal(const T*)
   {
     return sizeof(T);
   }
 
   template<>
-  inline size_t ruby_size_internal(const void* data)
+  inline size_t ruby_size_internal(const void*)
   {
     return sizeof(void*);
   }
@@ -37,8 +37,8 @@ namespace Rice
   {
     if (is_bound())
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string message = "Type " + typeMapper.name() + " is already bound to a different type";
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string message = "Type " + typeIndexParser.name() + " is already bound to a different type";
       throw std::runtime_error(message.c_str());
     }
 
@@ -69,10 +69,10 @@ namespace Rice
 
     // Add a method to get the source C++ class name from Ruby
     Data_Type<T> dataType;
-    dataType.define_singleton_method("cpp_class", [](VALUE klass) -> VALUE
+    dataType.define_singleton_method("cpp_class", [](VALUE) -> VALUE
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string cppClassName = typeMapper.simplifiedName();
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string cppClassName = typeIndexParser.simplifiedName();
       Return returnInfo;
       returnInfo.takeOwnership();
       return detail::To_Ruby<char*>(&returnInfo).convert(cppClassName.c_str());
@@ -148,7 +148,7 @@ namespace Rice
 
   template<typename T>
   template<typename Constructor_T, typename...Rice_Arg_Ts>
-  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args)
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T, Rice_Arg_Ts const& ...args)
   {
     check_is_bound();
 
@@ -187,9 +187,6 @@ namespace Rice
   template<typename Function_T>
   inline Data_Type<T>& Data_Type<T>::define(Function_T func)
   {
-    // The passed in this pointer is an RValue, so we need to keep it alive by
-    // assigning it to a const lvalue
-    const auto& dummy = *this;
     func(*this);
     return *this;
   }
@@ -233,8 +230,8 @@ namespace Rice
   {
     if (!is_bound())
     {
-      detail::TypeMapper<T> typeMapper;
-      std::string message = "Type is not defined with Rice: " + typeMapper.name();
+      detail::TypeIndexParser typeIndexParser(typeid(T), std::is_fundamental_v<detail::intrinsic_type<T>>);
+      std::string message = "Type is not defined with Rice: " + typeIndexParser.name();
       throw std::invalid_argument(message.c_str());
     }
   }
@@ -330,30 +327,30 @@ namespace Rice
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_attr(std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
-    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access, returnInfo);
+    return this->define_attr_internal<Attribute_T>(this->klass_, name, std::forward<Attribute_T>(attribute), access, args...);
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_singleton_attr(std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
-    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access, returnInfo);
+    return this->define_attr_internal<Attribute_T>(singleton, name, std::forward<Attribute_T>(attribute), access, args...);
   }
 
   template <typename T>
-  template <typename Attribute_T>
-  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, Return returnInfo)
+  template <typename Attribute_T, typename...Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_attr_internal(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access, const Arg_Ts&...args)
   {
     using Attr_T = typename detail::attribute_traits<Attribute_T>::attr_type;
 
     // Define attribute getter
     if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
     {
-      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), returnInfo);
+      detail::NativeAttributeGet<Attribute_T>::define(klass, name, std::forward<Attribute_T>(attribute), args...);
     }
 
     // Define attribute setter
@@ -391,9 +388,9 @@ namespace Rice
   }
 
   template <typename T>
-  template<typename Method_T>
-  inline void Data_Type<T>::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  template<typename Method_T, typename ...Arg_Ts>
+  inline void Data_Type<T>::wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args)
   {
-    Module::wrap_native_method<T, Method_T>(klass, name, std::forward<Method_T>(method), methodInfo);
+    Module::wrap_native_method<T, Method_T>(klass, name, std::forward<Method_T>(method), args...);
   }
 }

data/rice/Director.hpp

@@ -23,6 +23,7 @@ namespace Rice
       /*! If a Ruby script calls 'super' on a method that's otherwise a pure virtual
        *  method, use this method to throw an exception in this case.
        */
+      [[noreturn]]
       void raisePureVirtual() const
       {
         rb_raise(rb_eNotImpError, "Cannot call super() into a pure-virtual C++ method");