rice 4.6.1 → 4.7.0

data/rice/detail/NativeFunction.hpp

@@ -35,77 +35,40 @@ namespace Rice::detail
    *    calling them methods (self) or functions (no self).
    */
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<typename Function_T>
   class NativeFunction: Native
   {
   public:
-    using NativeFunction_T = NativeFunction<Class_T, Function_T, IsMethod>;
+    using NativeFunction_T = NativeFunction<Function_T>;
 
     // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
     // have the concept of constants anyways
     using Return_T = typename function_traits<Function_T>::return_type;
-    using Receiver_T = typename method_traits<Function_T, IsMethod>::Class_T;
-    using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
-    static constexpr std::size_t arity = method_traits<Function_T, IsMethod>::arity;
-    using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+    using Class_T = typename function_traits<Function_T>::class_type;
+    using Arg_Ts = typename function_traits<Function_T>::arg_types;
     using To_Ruby_T = remove_cv_recursive_t<Return_T>;
 
     // Register function with Ruby
     static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
-    // Proc entry
-    static VALUE procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
-    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
   public:
-    // Disallow creating/copying/moving
-    NativeFunction() = delete;
-    NativeFunction(const NativeFunction_T&) = delete;
-    NativeFunction(NativeFunction_T&&) = delete;
-    void operator=(const NativeFunction_T&) = delete;
-    void operator=(NativeFunction_T&&) = delete;
+    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
-    Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
     VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
     std::string toString() override;
 
-    NativeFunction(Function_T function);
-    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
-
-  protected:
+    std::string name() override;
+    NativeKind kind() override;
+    VALUE returnKlass() override;
 
   private:
-    template<int I>
-    Convertible matchParameter(std::vector<std::optional<VALUE>>& value);
-
-    template<std::size_t...I>
-    Convertible matchParameters(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
-
     template<std::size_t...I>
     std::vector<std::string> argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices);
 
-    template<typename T, std::size_t I>
-    From_Ruby<T> createFromRuby();
-      
-    // Create NativeArgs which are used to convert values from Ruby to C++
-    template<std::size_t...I>
-    From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
-
-    // Convert C++ value to Ruby
-    To_Ruby<To_Ruby_T> createToRuby();
-      
-    // Convert Ruby argv pointer to Ruby values
-    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
-
-    template<typename Arg_T, int I>
-    Arg_T getNativeValue(std::vector<std::optional<VALUE>>& values);
-
     // Convert Ruby values to C++ values
     template<typename std::size_t...I>
     Arg_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
 
-    // Figure out what self is
-    Receiver_T getReceiver(VALUE self);
-
     // Throw an exception when wrapper cannot be extracted
     [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
 
@@ -113,16 +76,15 @@ namespace Rice::detail
     void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
 
     // Call the underlying C++ function
-    VALUE invokeNativeFunction(Arg_Ts&& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs);
+    VALUE invoke(Arg_Ts&& nativeArgs);
+    VALUE invokeNoGVL(Arg_Ts&& nativeArgs);
 
   private:
     VALUE klass_;
     std::string method_name_;
     Function_T function_;
-    From_Ruby_Args_Ts fromRubys_;
-    To_Ruby<To_Ruby_T> toRuby_;
     std::unique_ptr<MethodInfo> methodInfo_;
+    To_Ruby<To_Ruby_T> toRuby_;
   };
 }
 

data/rice/detail/NativeFunction.ipp

@@ -6,9 +6,14 @@
 
 namespace Rice::detail
 {
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  void NativeFunction<Class_T, Function_T, IsMethod>::define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
+  template<typename Function_T>
+  void NativeFunction<Function_T>::define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
   {
+    // Verify return and argument types
+    Native::verify_type<Return_T>(methodInfo->returnInfo()->isBuffer());
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
+    Native::verify_args<Arg_Ts>(methodInfo, indices);
+
     // Have we defined this method yet in Ruby?
     Identifier identifier(method_name);
     const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, identifier.id());
@@ -25,68 +30,33 @@ namespace Rice::detail
     detail::Registries::instance.natives.add(klass, identifier.id(), native);
   }
 
-  // Ruby calls this method when invoking a proc that was defined as a C++ function
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
-  {
-    return cpp_protect([&]
-    {
-      NativeFunction_T * native = (NativeFunction_T*)callback_arg;
-      return (*native)(argc, argv, Qnil);
-    });
-  }
-
-  // Ruby calls this method if an instance f a NativeFunction is owned by a Ruby proc. That happens when C++
-  // returns a function back to Ruby
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  template<typename Function_T>
+  NativeFunction<Function_T>::NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
+    : Native(Native::create_parameters<Arg_Ts>(methodInfo)),
+      klass_(klass), method_name_(method_name), function_(function), methodInfo_(methodInfo),
+      toRuby_(methodInfo->returnInfo())
   {
-    NativeFunction_T* native = (NativeFunction_T*)callback_arg;
-    delete native;
-    return Qnil;
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  NativeFunction<Class_T, Function_T, IsMethod>::NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
-    : klass_(klass), method_name_(method_name), function_(function), methodInfo_(methodInfo)
-  {
-    // Create a tuple of NativeArgs that will convert the Ruby values to native values. For 
-    // builtin types NativeArgs will keep a copy of the native value so that it 
-    // can be passed by reference or pointer to the native function. For non-builtin types
-    // it will just pass the value through.
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    this->fromRubys_ = this->createFromRuby(indices);
-
-    this->toRuby_ = this->createToRuby();
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  NativeFunction<Class_T, Function_T, IsMethod>::NativeFunction(Function_T function)
-    : NativeFunction(Qnil, "", function, new MethodInfo(arity))
-  {
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<typename Function_T>
   template<std::size_t... I>
-  std::vector<std::string> NativeFunction<Class_T, Function_T, IsMethod>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
+  std::vector<std::string> NativeFunction<Function_T>::argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices)
   {
-    std::vector<std::string> typeNames;
-    (typeNames.push_back(cppClassName(typeName(typeid(typename std::tuple_element<I, Arg_Ts>::type)))), ...);
-    return typeNames;
+    std::vector<std::string> result;
+    for (std::unique_ptr<ParameterAbstract>& parameter : this->parameters_)
+    {
+      result.push_back(parameter->cppTypeName());
+    }
+    return result;
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  std::string NativeFunction<Class_T, Function_T, IsMethod>::toString()
+  template<typename Function_T>
+  std::string NativeFunction<Function_T>::toString()
   {
     std::ostringstream result;
 
-    result << cppClassName(typeName(typeid(Return_T))) << " ";
-    
-    if (!std::is_null_pointer_v<Receiver_T>)
-    {
-      result << cppClassName(typeName(typeid(Receiver_T))) << "::";
-    }
-    
+    detail::TypeMapper<Return_T> typeMapper;
+    result << typeMapper.simplifiedName() << " ";
     result << this->method_name_;
 
     result << "(";
@@ -103,294 +73,24 @@ namespace Rice::detail
     return result.str();
   }
     
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  To_Ruby<typename NativeFunction<Class_T, Function_T, IsMethod>::To_Ruby_T> NativeFunction<Class_T, Function_T, IsMethod>::createToRuby()
-  {
-    // Does the From_Ruby instantiation work with ReturnInfo?
-    if constexpr (std::is_constructible_v<To_Ruby<To_Ruby_T>, Return*>)
-    {
-      return To_Ruby<To_Ruby_T>(&this->methodInfo_->returnInfo);
-    }
-    else
-    {
-      return To_Ruby<To_Ruby_T>();
-    }
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  template<typename T, std::size_t I>
-  From_Ruby<T> NativeFunction<Class_T, Function_T, IsMethod>::createFromRuby()
-  {
-    // Does the From_Ruby instantiation work with Arg?
-    if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
-    {
-      return From_Ruby<T>(this->methodInfo_->arg(I));
-    }
-    else
-    {
-      return From_Ruby<T>();
-    }
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  template<std::size_t... I>
-  typename NativeFunction<Class_T, Function_T, IsMethod>::From_Ruby_Args_Ts NativeFunction<Class_T, Function_T, IsMethod>::createFromRuby(std::index_sequence<I...>& indices)
-  {
-    return std::make_tuple(createFromRuby<remove_cv_recursive_t<typename std::tuple_element<I, Arg_Ts>::type>, I>()...);
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  template<int I>
-  Convertible NativeFunction<Class_T, Function_T, IsMethod>::matchParameter(std::vector<std::optional<VALUE>>& values)
-  {
-    Convertible result = Convertible::None;
-    MethodInfo* methodInfo = this->methodInfo_.get();
-    const Arg* arg = methodInfo->arg(I);
-    std::optional<VALUE> value = values[I];
-
-    // Is a VALUE being passed directly to C++ ?
-    if (value.has_value())
-    {
-      if (arg->isValue())
-      {
-        result = Convertible::Exact;
-      }
-      // If index is less than argc then check with FromRuby if the VALUE is convertible
-      // to C++.
-      else
-      {
-        VALUE value = values[I].value();
-        auto fromRuby = std::get<I>(this->fromRubys_);
-        result = fromRuby.is_convertible(value);
-
-        // If this is an exact match check if the const-ness of the value and the parameter match
-        if (result == Convertible::Exact && rb_type(value) == RUBY_T_DATA)
-        {
-          // Check the constness of the Ruby wrapped value and the parameter
-          WrapperBase* wrapper = getWrapper(value);
-          using Parameter_T = std::tuple_element_t<I, Arg_Ts>;
-
-          // Do not send a const value to a non-const parameter
-          if (wrapper->isConst() && !is_const_any_v<Parameter_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 slighly decreasing the convertible value
-          else if (!wrapper->isConst() && is_const_any_v<Parameter_T>)
-          {
-            result = Convertible::Const;
-          }
-        }
-      }
-    }
-    // Last check if a default value has been set
-    else if (arg->hasDefaultValue())
-    {
-      result = Convertible::Exact;
-    }
-
-    return result;
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  template<std::size_t... I>
-  Convertible NativeFunction<Class_T, Function_T, IsMethod>::matchParameters(std::vector<std::optional<VALUE>>& values,
-    std::index_sequence<I...>& indices)
-  {
-    Convertible result = Convertible::Exact;
-    ((result = result & this->matchParameter<I>(values)), ...);
-    return result;
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  Resolved NativeFunction<Class_T, Function_T, IsMethod>::matches(size_t argc, const VALUE* argv, VALUE self)
-  {
-    // Return false if Ruby provided more arguments than the C++ method takes
-    if (argc > arity)
-      return Resolved{ Convertible::None, 0, this };
-
-    Resolved result { Convertible::Exact, 1, this };
-
-    std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, false);
-    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-    result.convertible = this->matchParameters(rubyValues, indices);
-
-    if constexpr (arity > 0)
-    {
-      int providedValues = std::count_if(rubyValues.begin(), rubyValues.end(), [](std::optional<VALUE>& value)
-        {
-          return value.has_value();
-        });
-
-      result.parameterMatch = providedValues / (double)arity;
-    }
-    return result;
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  std::vector<std::optional<VALUE>> NativeFunction<Class_T, Function_T, IsMethod>::getRubyValues(size_t argc, const VALUE* argv, bool validate)
-  {
-#undef max
-    int size = std::max((size_t)arity, (size_t)argc);
-    std::vector<std::optional<VALUE>> result(size);
-
-    // Keyword handling
-    if (rb_keyword_given_p())
-    {
-      // Keywords are stored in the last element in a hash
-      int actualArgc = argc - 1;
-
-      VALUE value = argv[actualArgc];
-      Hash keywords(value);
-
-      // Copy over leading non-keyword arguments
-      for (int i = 0; i < actualArgc; i++)
-      {
-        result[i] = argv[i];
-      }
-
-      // Copy over keyword arguments
-      for (auto pair : keywords)
-      {
-        Symbol key(pair.first);
-        const Arg* arg = this->methodInfo_->arg(key.str());
-        if (!arg)
-        {
-          throw std::invalid_argument("Unknown keyword: " + key.str());
-        }
-        result[arg->position] = pair.second.value();
-      }
-    }
-    else
-    {
-      std::copy(argv, argv + argc, result.begin());
-    }
-     
-    // Block handling. If we find a block and the last parameter is missing then
-    // set it to the block
-    if (rb_block_given_p() && result.size() > 0 && !result.back().has_value())
-    {
-      VALUE proc = rb_block_proc();
-      result.back() = proc;
-    }
-
-    if (validate)
-    {
-      // Protect against user sending too many arguments
-      if (argc > arity)
-      {
-        std::string message = "wrong number of arguments (given " +
-          std::to_string(argc) + ", expected " + std::to_string(arity) + ")";
-        throw std::invalid_argument(message);
-      }
-
-      for (size_t i=0; i<result.size(); i++)
-      {
-        std::optional<VALUE> value = result[i];
-        Arg* arg = this->methodInfo_->arg(i);
-
-        if (!arg->hasDefaultValue() && !value.has_value())
-        {
-          std::string message;
-          message = "Missing argument. Name: " + arg->name + ". Index: " + std::to_string(arg->position) + ".";
-          throw std::invalid_argument(message);
-        }
-      }
-    }
-    
-    return result;
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  template<typename Arg_T, int I>
-  Arg_T NativeFunction<Class_T, Function_T, IsMethod>::getNativeValue(std::vector<std::optional<VALUE>>& values)
-  {
-    /* In general the compiler will convert T to const T, but that does not work for converting
-       T** to const T** (see see https://isocpp.org/wiki/faq/const-correctness#constptrptr-conversion)
-       which comes up in the OpenCV bindings.
-     
-       An alternative solution is updating From_Ruby#convert to become a templated function that specifies
-       the return type. That works but requires a lot more code changes for this one case and is not 
-       backwards compatible. */
-
-    std::optional<VALUE> value = values[I];
-    Arg* arg = this->methodInfo_->arg(I);
-
-    if constexpr (is_pointer_pointer_v<Arg_T> && !std::is_convertible_v<remove_cv_recursive_t<Arg_T>, Arg_T>)
-    {
-      return (Arg_T)std::get<I>(this->fromRubys_).convert(value.value());
-    }
-    else if (value.has_value())
-    {
-      return std::get<I>(this->fromRubys_).convert(value.value());
-    }
-    else if constexpr (std::is_constructible_v<std::remove_cv_t<Arg_T>, std::remove_cv_t<std::remove_reference_t<Arg_T>>&>)
-    {
-      if (arg->hasDefaultValue())
-      {
-        return arg->defaultValue<Arg_T>();
-      }
-    }
-
-    throw std::invalid_argument("Could not convert Rubyy value");
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
+  template<typename Function_T>
   template<std::size_t... I>
-  typename NativeFunction<Class_T, Function_T, IsMethod>::Arg_Ts NativeFunction<Class_T, Function_T, IsMethod>::getNativeValues(std::vector<std::optional<VALUE>>& values,
+  typename NativeFunction<Function_T>::Arg_Ts NativeFunction<Function_T>::getNativeValues(std::vector<std::optional<VALUE>>& values,
      std::index_sequence<I...>& indices)
   {
     /* Loop over each value returned from Ruby and convert it to the appropriate C++ type based
        on the arguments (Arg_Ts) required by the C++ function. Arg_T may have const/volatile while
        the associated From_Ruby<T> template parameter will not. Thus From_Ruby produces non-const values 
        which we let the compiler convert to const values as needed. This works except for 
-       T** -> const T**, see comment in getNativeValue method. */
-    return std::forward_as_tuple(this->getNativeValue<std::tuple_element_t<I, Arg_Ts>, I>(values)...);
-  }
-
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  typename NativeFunction<Class_T, Function_T, IsMethod>::Receiver_T NativeFunction<Class_T, Function_T, IsMethod>::getReceiver(VALUE self)
-  {
-    // There is no self parameter
-    if constexpr (std::is_same_v<Receiver_T, std::nullptr_t>)
-    {
-      return nullptr;
-    }
-    // Self parameter is a Ruby VALUE so no conversion is needed
-    else if constexpr (std::is_same_v<Receiver_T, VALUE>)
-    {
-      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);
-    }
+       T** -> const T**, see comment in convertToNative method. */
+    //return std::forward_as_tuple(this->getNativeValue<std::tuple_element_t<I, Arg_Ts>, I>(values)...);
+    return std::forward_as_tuple(
+      (dynamic_cast<Parameter<std::tuple_element_t<I, Arg_Ts>>*>(this->parameters_[I].get()))->
+               convertToNative(values[I])...);
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeFunction(Arg_Ts&& nativeArgs)
+  template<typename Function_T>
+  VALUE NativeFunction<Function_T>::invoke(Arg_Ts&& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
@@ -403,57 +103,30 @@ namespace Rice::detail
       Return_T nativeResult = std::apply(this->function_, std::forward<Arg_Ts>(nativeArgs));
 
       // Return the result
-      return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
+      return this->toRuby_.convert(nativeResult);
     }
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs)
+  template<typename Function_T>
+  VALUE NativeFunction<Function_T>::invokeNoGVL(Arg_Ts&& nativeArgs)
   {
-    Receiver_T receiver = this->getReceiver(self);
-    auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), std::forward<Arg_Ts>(nativeArgs));
-
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->function_, std::forward<decltype(selfAndNativeArgs)>(selfAndNativeArgs));
+      no_gvl(this->function_, std::forward<Arg_Ts>(nativeArgs));
       return Qnil;
     }
     else
     {
-      Return_T nativeResult = std::apply(this->function_, std::forward<decltype(selfAndNativeArgs)>(selfAndNativeArgs));
-
-      // Special handling if the method returns self. If so we do not want
-      // to create a new Ruby wrapper object and instead return self.
-      if constexpr (std::is_same_v<intrinsic_type<Return_T>, intrinsic_type<Receiver_T>>)
-      {
-        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Receiver_T>)
-        {
-          if (nativeResult == receiver)
-            return self;
-        }
-        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Receiver_T>)
-        {
-          if (nativeResult == &receiver)
-            return self;
-        }
-        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Receiver_T>)
-        {
-          if (&nativeResult == receiver)
-            return self;
-        }
-        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Receiver_T>)
-        {
-          if (&nativeResult == &receiver)
-            return self;
-        }
-      }
+      // Call the native method and get the result
+      Return_T nativeResult = no_gvl(this->function_, std::forward<Arg_Ts>(nativeArgs));
 
-      return this->toRuby_.convert(std::forward<Return_T>(nativeResult));
+      // Return the result
+      return this->toRuby_.convert(nativeResult);
     }
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  void NativeFunction<Class_T, Function_T, IsMethod>::noWrapper(const VALUE klass, const std::string& wrapper)
+  template<typename Function_T>
+  void NativeFunction<Function_T>::noWrapper(const VALUE klass, const std::string& wrapper)
   {
     std::stringstream message;
 
@@ -468,8 +141,8 @@ namespace Rice::detail
     throw std::runtime_error(message.str());
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  void NativeFunction<Class_T, Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
+  template<typename Function_T>
+  void NativeFunction<Function_T>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues)
   {
     // Self will be Qnil for wrapped procs
     if (self == Qnil)
@@ -493,7 +166,7 @@ namespace Rice::detail
     }
 
     // Check return value
-    if (this->methodInfo_->returnInfo.isKeepAlive())
+    if (this->methodInfo_->returnInfo()->isKeepAlive())
     {
       if (selfWrapper == nullptr)
       {
@@ -510,8 +183,8 @@ namespace Rice::detail
     }
   }
 
-  template<typename Class_T, typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Class_T, Function_T, IsMethod>::operator()(size_t argc, const VALUE* argv, VALUE self)
+  template<typename Function_T>
+  VALUE NativeFunction<Function_T>::operator()(size_t argc, const VALUE* argv, VALUE self)
   {
     // Get the ruby values and make sure we have the correct number
     std::vector<std::optional<VALUE>> rubyValues = this->getRubyValues(argc, argv, true);
@@ -521,15 +194,17 @@ namespace Rice::detail
     // Convert the Ruby values to native values
     Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
-    // Now call the native method
+    bool noGvl = this->methodInfo_->function()->isNoGvl();
+
     VALUE result = Qnil;
-    if constexpr (std::is_same_v<Receiver_T, std::nullptr_t>)
+
+    if (noGvl)
     {
-      result = this->invokeNativeFunction(std::forward<Arg_Ts>(nativeValues));
+      result = this->invokeNoGVL(std::forward<Arg_Ts>(nativeValues));
     }
     else
     {
-      result = this->invokeNativeMethod(self, std::forward<Arg_Ts>(nativeValues));
+      result = this->invoke(std::forward<Arg_Ts>(nativeValues));
     }
 
     // Check if any function arguments or return values need to have their lifetimes tied to the receiver
@@ -537,4 +212,32 @@ namespace Rice::detail
 
     return result;
   }
+
+  template<typename Function_T>
+  inline std::string NativeFunction<Function_T>::name()
+  {
+    return this->method_name_;
+  }
+
+  template<typename Function_T>
+  inline NativeKind NativeFunction<Function_T>::kind()
+  {
+    return NativeKind::Function;
+  }
+
+  template<typename Function_T>
+  inline VALUE NativeFunction<Function_T>::returnKlass()
+  {
+    // Check if an array is being returned
+    if (this->methodInfo_->returnInfo()->isBuffer())
+    {
+      TypeMapper<Pointer<Return_T>> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+    else
+    {
+      TypeMapper<Return_T> typeMapper;
+      return typeMapper.rubyKlass();
+    }
+  }
 }