rice 4.7.1 → 4.9.0

data/rice/cpp_api/Class.ipp

@@ -13,8 +13,8 @@ namespace Rice
     return *this;
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Class::create(Arg_Ts ...args)
+  template<typename ...Parameter_Ts>
+  inline Object Class::create(Parameter_Ts ...args)
   {
     return this->call("new", args...);
   }
@@ -33,6 +33,11 @@ namespace Rice
     return result;
   }
 
+  inline Class Class::superclass() const
+  {
+    return detail::protect(rb_class_superclass, this->value());
+  }
+
   inline Class define_class_under(Object parent, Identifier id, const Class& superclass)
   {
     VALUE klass = detail::protect(rb_define_class_id_under, parent.value(), id, superclass.value());
@@ -91,7 +96,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -101,7 +106,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Hash.ipp

@@ -234,7 +234,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -244,7 +244,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -253,11 +253,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -273,5 +273,8 @@ namespace Rice::detail
     {
       return Hash(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Module.hpp

@@ -49,11 +49,11 @@ namespace Rice
 
     #include "shared_methods.hpp"
   protected:
-    template<typename Function_T>
-    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo);
+    template<typename Function_T, typename ...Arg_Ts>
+    void wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args);
 
-    template<typename Class_T = VALUE, typename Method_T>
-    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo);
+    template<typename Class_T = VALUE, typename Method_T, typename ...Arg_Ts>
+    void wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args);
   };
 
   //! Define a new module in the namespace given by module.

data/rice/cpp_api/Module.ipp

@@ -32,16 +32,18 @@ namespace Rice
     this->set_value(result);
   }
 
-  template<typename Function_T>
-  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, MethodInfo* methodInfo)
+  template<typename Function_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_function(VALUE klass, std::string name, Function_T&& function, const Arg_Ts&...args)
   {
-    detail::NativeFunction<Function_T>::define(klass, name, std::forward<Function_T>(function), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeFunction<Function_T, isNoGVL>::define(klass, name, std::forward<Function_T>(function), args...);
   }
 
-  template<typename Class_T, typename Method_T>
-  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, MethodInfo* methodInfo)
+  template<typename Class_T, typename Method_T, typename ...Arg_Ts>
+  inline void Module::wrap_native_method(VALUE klass, std::string name, Method_T&& method, const Arg_Ts&...args)
   {
-    detail::NativeMethod<Class_T, Method_T>::define(klass, name, std::forward<Method_T>(method), methodInfo);
+    constexpr bool isNoGVL = detail::tuple_element_index_v<std::tuple<Arg_Ts...>, NoGVL> < (sizeof...(Arg_Ts));
+    detail::NativeMethod<Class_T, Method_T, isNoGVL>::define(klass, name, std::forward<Method_T>(method), args...);
   }
 
   inline Module define_module_under(Object parent, char const* name)
@@ -94,7 +96,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -104,7 +106,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -114,7 +116,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -124,7 +126,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>

data/rice/cpp_api/Object.hpp

@@ -9,6 +9,7 @@
 namespace Rice
 {
   class Class;
+  class Module;
   class String;
   class Array;
 
@@ -116,6 +117,11 @@ namespace Rice
      */
     bool is_a(Object klass) const;
 
+    //! Extend the object with a module.
+    /*! \param mod the module to extend with.
+     */
+    void extend(Module const& mod);
+
     //! Determine if the objects responds to a method.
     /*! \param id the name of the method
      *  \return true if the objects responds to the method, false
@@ -181,8 +187,8 @@ namespace Rice
     *    float ret = x.call<float>("foo", z, 42);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    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
@@ -204,8 +210,8 @@ namespace Rice
     *    float ret = x.call_kw<float>("foo", kw);
     *  \endcode
     */
-    template<typename ...Arg_Ts>
-    Object call_kw(Identifier id, Arg_Ts... args) const;
+    template<typename ...Parameter_Ts>
+    Object call_kw(Identifier id, Parameter_Ts... args) const;
 
     //! Vectorized call.
     /*! Calls the method identified by id with the list of arguments

data/rice/cpp_api/Object.ipp

@@ -27,8 +27,8 @@ namespace Rice
     return *this;
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  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
@@ -37,15 +37,15 @@ namespace Rice
        to the destination method resulting in a segmentation fault. This is
        easy to duplicate by setting GC.stress to true and calling a constructor
        that takes multiple values like a std::pair wrapper. */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(std::forward<Arg_Ts>(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, value(), id.id(), (int)values.size(), (const VALUE*)values.data());
   }
 
-  template<typename ...Arg_Ts>
-  inline Object Object::call_kw(Identifier id, Arg_Ts... args) const
+  template<typename ...Parameter_Ts>
+  inline Object Object::call_kw(Identifier id, Parameter_Ts... args) const
   {
     /* IMPORTANT - See call() above */
-    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>().convert(args)... };
+    std::array<VALUE, sizeof...(Parameter_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Parameter_Ts>>().convert(args)... };
     return detail::protect(rb_funcallv_kw, value(), id.id(), (int)values.size(), (const VALUE*)values.data(), RB_PASS_KEYWORDS);
   }
 
@@ -99,6 +99,11 @@ namespace Rice
     return RB_TEST(result);
   }
 
+  inline void Object::extend(Module const& mod)
+  {
+    detail::protect(rb_extend_object, this->value(), mod.value());
+  }
+
   inline bool Object::respond_to(Identifier id) const
   {
     return bool(rb_respond_to(this->value(), id.id()));
@@ -202,7 +207,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -212,7 +217,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -221,7 +226,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -231,7 +236,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -240,11 +245,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -260,5 +265,8 @@ namespace Rice::detail
     {
       return Object(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/String.hpp

@@ -38,8 +38,8 @@ namespace Rice
     String(std::string_view const& s);
 
     //! Format a string using printf-style formatting.
-    template <typename... Arg_Ts>
-    static inline String format(char const* fmt, Arg_Ts&&...args);
+    template <typename... Parameter_Ts>
+    static inline String format(char const* fmt, Parameter_Ts&&...args);
 
     //! Get the length of the String.
     /*! \return the length of the string.

data/rice/cpp_api/String.ipp

@@ -28,16 +28,16 @@ namespace Rice
   {
   }
 
-  template <typename... Arg_Ts>
-  inline String String::format(char const* fmt, Arg_Ts&&...args)
+  template <typename... Parameter_Ts>
+  inline String String::format(char const* fmt, Parameter_Ts&&...args)
   {
-    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
+    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Parameter_Ts>(args)...);
     std::string temp(size, '\0');
 
     // size+1 avoids truncating the string. Otherwise snprintf writes n - 1 characters
     // to allow space for null character but we don't need that since std::string
     // will add a null character internally at n + 1
-    std::snprintf(&temp[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+    std::snprintf(&temp[0], size + 1, fmt, std::forward<Parameter_Ts>(args)...);
 
     String s = String(temp.c_str());
     return s;
@@ -97,7 +97,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -107,7 +107,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -116,11 +116,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -136,5 +136,8 @@ namespace Rice::detail
     {
       return String(value);
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 }

data/rice/cpp_api/Symbol.ipp

@@ -67,7 +67,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -77,7 +77,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
 
@@ -87,7 +87,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -97,7 +97,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -110,15 +110,15 @@ namespace Rice::detail
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
         case RUBY_T_SYMBOL:
           return Convertible::Exact;
           break;
-      case RUBY_T_STRING:
-          return Convertible::Cast;
+        case RUBY_T_STRING:
+          return Convertible::Exact;
           break;
         default:
           return Convertible::None;

data/rice/cpp_api/shared_methods.hpp

@@ -33,8 +33,7 @@ inline auto& include_module(Module const& inc)
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(this->value(), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -52,8 +51,7 @@ inline auto& define_method(std::string name, Method_T&& method, const Arg_Ts&...
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(this->value(), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -75,8 +73,7 @@ inline auto& define_function(std::string name, Function_T&& func, const Arg_Ts&.
 template<typename Method_T, typename...Arg_Ts>
 inline auto& define_singleton_method(std::string name, Method_T&& method, const Arg_Ts&...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::method_traits<Method_T>::arity, args...);
-  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), methodInfo);
+  this->wrap_native_method(rb_singleton_class(*this), name, std::forward<Method_T>(method), args...);
   return *this;
 }
 
@@ -94,8 +91,7 @@ inline auto& define_singleton_method(std::string name, Method_T&& method, const
 template<typename Function_T, typename...Arg_Ts>
 inline auto& define_singleton_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
 {
-  MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Function_T>::arity, args...);
-  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), methodInfo);
+  this->wrap_native_function(rb_singleton_class(*this), name, std::forward<Function_T>(func), args...);
   return *this;
 }
 
@@ -112,7 +108,7 @@ inline auto& define_singleton_function(std::string name, Function_T&& func, cons
  *  \return *this
  */
 template<typename Function_T, typename...Arg_Ts>
-inline auto& define_module_function(std::string name, Function_T&& func, const Arg_Ts& ...args)
+inline auto& define_module_function(std::string name, Function_T&& func, Arg_Ts&& ...args)
 {
   if (this->rb_type() != T_MODULE)
   {

data/rice/detail/Forwards.hpp

@@ -0,0 +1,18 @@
+#ifndef Rice__detail__Forwards__hpp_
+#define Rice__detail__Forwards__hpp_
+
+namespace Rice::detail
+{
+  // Setup method forwarding from a wrapper class to its wrapped type using Ruby's Forwardable.
+  // This allows calling methods on the wrapper that get delegated to the wrapped object via
+  // a "get" method that returns the wrapped object.
+  //
+  // Parameters:
+  //   wrapper_klass - The Ruby class to add forwarding to (e.g., SharedPtr_MyClass)
+  //   wrapped_klass - The Ruby class whose methods should be forwarded (e.g., MyClass)
+  void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass);
+}
+
+#include "Forwards.ipp"
+
+#endif // Rice__detail__Forwards__hpp_

data/rice/detail/Forwards.ipp

@@ -0,0 +1,60 @@
+namespace Rice::detail
+{
+  inline void define_forwarding(VALUE wrapper_klass, VALUE wrapped_klass)
+  {
+    protect(rb_require, "forwardable");
+    Object forwardable = Object(rb_cObject).const_get("Forwardable");
+    Object(wrapper_klass).extend(forwardable.value());
+
+    // Get wrapper class's method names to avoid conflicts
+    std::set<std::string> wrapperMethodSet;
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::Method))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeReader))
+    {
+      wrapperMethodSet.insert(native->name());
+    }
+    for (Native* native : Registries::instance.natives.lookup(wrapper_klass, NativeKind::AttributeWriter))
+    {
+      wrapperMethodSet.insert(native->name() + "=");
+    }
+
+    // Get wrapped class's method names from the registry, including ancestor classes
+    std::set<std::string> wrappedMethodSet;
+    Class klass(wrapped_klass);
+    while (klass.value() != rb_cObject && klass.value() != Qnil)
+    {
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::Method))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeReader))
+      {
+        wrappedMethodSet.insert(native->name());
+      }
+      for (Native* native : Registries::instance.natives.lookup(klass.value(), NativeKind::AttributeWriter))
+      {
+        wrappedMethodSet.insert(native->name() + "=");
+      }
+
+      klass = klass.superclass();
+    }
+
+    // Build the arguments array for def_delegators: [:get, :method1, :method2, ...]
+    // Skip methods that are already defined on the wrapper class
+    Array args;
+    args.push(Symbol("get"));
+    for (const std::string& method : wrappedMethodSet)
+    {
+      if (wrapperMethodSet.find(method) == wrapperMethodSet.end())
+      {
+        args.push(Symbol(method));
+      }
+    }
+
+    // Call def_delegators(*args)
+    Object(wrapper_klass).vcall("def_delegators", args);
+  }
+}

data/rice/detail/InstanceRegistry.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__InstanceRegistry__hpp_
 #define Rice__detail__InstanceRegistry__hpp_
 
-#include <map>
-
 namespace Rice::detail
 {
   class InstanceRegistry

data/rice/detail/Native.hpp

@@ -11,8 +11,7 @@ namespace Rice::detail
     inline bool operator<(Resolved other);
     inline bool operator>(Resolved other);
 
-    Convertible convertible;
-    double parameterMatch;
+    double score;  // Combined score: minParameterScore * parameterMatch
     Native* native;
   };
 
@@ -23,7 +22,8 @@ namespace Rice::detail
     Iterator,
     AttributeReader,
     AttributeWriter,
-    Proc
+    Proc,
+    Callback
   };
 
   class Native
@@ -31,8 +31,9 @@ namespace Rice::detail
   public:
     static VALUE resolve(int argc, VALUE* argv, VALUE self);
   public:
-    Native() = default;
-    Native(std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
+    Native(std::string name);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo);
+    Native(std::string name, std::unique_ptr<Return>&& returnInfo, std::vector<std::unique_ptr<ParameterAbstract>>&& parameters);
     virtual ~Native() = default;
 
     Native(const Native&) = delete;
@@ -40,36 +41,45 @@ namespace Rice::detail
     void operator=(const Native&) = delete;
     void operator=(Native&&) = delete;
 
-    virtual Resolved matches(size_t argc, const VALUE* argv, VALUE self);
-    virtual VALUE operator()(size_t argc, const VALUE* argv, VALUE self) = 0;
+    virtual Resolved matches(std::map<std::string, VALUE>& values);
+    virtual VALUE operator()(std::map<std::string, VALUE>& values, VALUE self) = 0;
     virtual std::string toString() = 0;
 
     // Ruby API access
-    virtual std::string name() = 0;
+    std::string name();
+    std::vector<const ParameterAbstract*> parameters();
     virtual NativeKind kind() = 0;
     virtual VALUE returnKlass() = 0;
-    std::vector<const ParameterAbstract*> parameters();
 
   protected:
-    template<typename T>
-    static void verify_type(bool isBuffer);
+    template<typename T, bool isBuffer>
+    static void verify_type();
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static void verify_args(MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
-
-    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
+    static std::map<std::string, VALUE> readRubyArgs(size_t argc, const VALUE* argv);
+    std::vector<std::optional<VALUE>> getRubyValues(std::map<std::string, VALUE> values, bool validate);
     ParameterAbstract* getParameterByName(std::string name);
-    Convertible matchParameters(std::vector<std::optional<VALUE>>& values);
+    double matchParameters(std::vector<std::optional<VALUE>>& values, size_t argc);
+
+    template<typename Parameter_Tuple, typename... Arg_Ts>
+    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(Arg_Ts&& ...args);
 
-    template<typename Tuple_T>
-    static std::vector<std::unique_ptr<ParameterAbstract>> create_parameters(MethodInfo* methodInfo);
+    template<typename... Arg_Ts>
+    static std::unique_ptr<Return> create_return(Arg_Ts& ...args);
 
-    template<typename Tuple_T, std::size_t ...Indices>
-    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, MethodInfo* methodInfo, std::index_sequence<Indices...> indices);
+    // Do we need to keep alive any arguments?
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
+
+  private:
+    template<typename Parameter_Tuple, typename Arg_Tuple, std::size_t ...Indices>
+    static inline void create_parameters_impl(std::vector<std::unique_ptr<ParameterAbstract>>& parameters, std::index_sequence<Indices...> indices, std::vector<std::unique_ptr<Arg>>&& args);
+
+    template<typename Parameter_Tuple, typename Arg_Tuple, size_t I>
+    static void verify_parameter();
 
   protected:
+    std::string name_;
+    std::unique_ptr<Return> returnInfo_;
     std::vector<std::unique_ptr<ParameterAbstract>> parameters_;
-
   };
 }