rice 4.0.4 → 4.2.0

data/rice/detail/NativeAttribute.ipp

@@ -1,83 +1,112 @@
 #include <array>
 #include <algorithm>
 
-#include "rice_traits.hpp"
-#include "method_data.hpp"
+#include "../traits/rice_traits.hpp"
+#include "NativeRegistry.hpp"
 #include "to_ruby_defn.hpp"
-#include "../ruby_try_catch.hpp"
+#include "cpp_protect.hpp"
 
 namespace Rice::detail
 {
-  template<typename Return_T, typename Attr_T, typename Self_T>
-  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::get(VALUE self)
+  template<typename Attribute_T>
+  void NativeAttribute<Attribute_T>::define(VALUE klass, std::string name, Attribute_T attribute, AttrAccess access)
   {
-    RUBY_TRY
+    // Create a NativeAttribute that Ruby will call to read/write C++ variables
+    NativeAttribute_T* native = new NativeAttribute_T(klass, name, std::forward<Attribute_T>(attribute), access);
+
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
     {
-      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
-      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
-      return attr->read(self);
+      // Tell Ruby to invoke the static method read to get the attribute value
+      detail::protect(rb_define_method, klass, name.c_str(), (RUBY_METHOD_FUNC)&NativeAttribute_T::get, 0);
+
+      // Add to native registry
+      detail::Registries::instance.natives.add(klass, Identifier(name).id(), native);
     }
-    RUBY_CATCH
+
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+    {
+      if (std::is_const_v<std::remove_pointer_t<T>>)
+      {
+        throw std::runtime_error(name + " is readonly");
+      }
+
+      // Define the write method name
+      std::string setter = name + "=";
+
+      // Tell Ruby to invoke the static method write to get the attribute value
+      detail::protect(rb_define_method, klass, setter.c_str(), (RUBY_METHOD_FUNC)&NativeAttribute_T::set, 1);
+
+      // Add to native registry
+      detail::Registries::instance.natives.add(klass, Identifier(setter).id(), native);
+    }
+  }
+
+  template<typename Attribute_T>
+  inline VALUE NativeAttribute<Attribute_T>::get(VALUE self)
+  {
+    return cpp_protect([&]
+    {
+      using Native_Attr_T = NativeAttribute<Attribute_T>;
+      Native_Attr_T* attr = detail::Registries::instance.natives.lookup<Native_Attr_T*>();
+      return attr->read(self);
+    });
   }
 
-  template<typename Return_T, typename Attr_T, typename Self_T>
-  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::set(VALUE self, VALUE value)
+  template<typename Attribute_T>
+  inline VALUE NativeAttribute<Attribute_T>::set(VALUE self, VALUE value)
   {
-    RUBY_TRY
+    return cpp_protect([&]
     {
-      using Native_Attr_T = NativeAttribute<Return_T, Attr_T, Self_T>;
-      Native_Attr_T* attr = detail::MethodData::data<Native_Attr_T*>();
+      using Native_Attr_T = NativeAttribute<Attribute_T>;
+      Native_Attr_T* attr = detail::Registries::instance.natives.lookup<Native_Attr_T*>();
       return attr->write(self, value);
-    }
-    RUBY_CATCH
+    });
   }
 
-  template<typename Return_T, typename Attr_T, typename Self_T>
-  NativeAttribute<Return_T, Attr_T, Self_T>::NativeAttribute(Attr_T attr, AttrAccess access)
-    : attr_(attr), access_(access)
+  template<typename Attribute_T>
+  NativeAttribute<Attribute_T>::NativeAttribute(VALUE klass, std::string name,
+                                                             Attribute_T attribute, AttrAccess access)
+    : klass_(klass), name_(name), attribute_(attribute), access_(access)
   {
   }
 
-  template<typename Return_T, typename Attr_T, typename Self_T>
-  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::read(VALUE self)
+  template<typename Attribute_T>
+  inline VALUE NativeAttribute<Attribute_T>::read(VALUE self)
   {
-    using Unqualified_T = remove_cv_recursive_t<Return_T>;
-    if constexpr (std::is_member_object_pointer_v<Attr_T>)
+    using T_Unqualified = remove_cv_recursive_t<T>;
+    if constexpr (std::is_member_object_pointer_v<Attribute_T>)
     {
-      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
-      return To_Ruby<Unqualified_T>().convert(nativeSelf->*attr_);
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      return To_Ruby<T_Unqualified>().convert(nativeSelf->*attribute_);
     }
     else
     {
-      return To_Ruby<Unqualified_T>().convert(*attr_);
+      return To_Ruby<T_Unqualified>().convert(*attribute_);
     }
   }
 
-  template<typename Return_T, typename Attr_T, typename Self_T>
-  inline VALUE NativeAttribute<Return_T, Attr_T, Self_T>::write(VALUE self, VALUE value)
+  template<typename Attribute_T>
+  inline VALUE NativeAttribute<Attribute_T>::write(VALUE self, VALUE value)
   {
-    if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>> && std::is_member_object_pointer_v<Attr_T>)
+    if constexpr (std::is_fundamental_v<intrinsic_type<T>> && std::is_pointer_v<T>)
     {
-      Self_T* nativeSelf = From_Ruby<Self_T*>().convert(self);
-      nativeSelf->*attr_ = From_Ruby<Return_T>().convert(value);
+      static_assert(true, "An fundamental value, such as an integer, cannot be assigned to an attribute that is a pointer");
     }
-    else if constexpr (!std::is_const_v<std::remove_pointer_t<Attr_T>>)
+    else if constexpr (std::is_same_v<intrinsic_type<T>, std::string> && std::is_pointer_v<T>)
     {
-      *attr_ = From_Ruby<Return_T>().convert(value);
+      static_assert(true, "An string cannot be assigned to an attribute that is a pointer");
+    }
+    
+    if constexpr (!std::is_null_pointer_v<Receiver_T>)
+    {
+      Receiver_T* nativeSelf = From_Ruby<Receiver_T*>().convert(self);
+      nativeSelf->*attribute_ = From_Ruby<T_Unqualified>().convert(value);
+    }
+    else if constexpr (!std::is_const_v<std::remove_pointer_t<T>>)
+    {
+      *attribute_ = From_Ruby<T_Unqualified>().convert(value);
     }
-    return value;
-  }
-
-  template<typename T>
-  auto* Make_Native_Attribute(T* attr, AttrAccess access)
-  {
-    return new NativeAttribute<T, T*>(attr, access);
-  }
 
-  template<typename Class_T, typename T>
-  auto* Make_Native_Attribute(T Class_T::* attr, AttrAccess access)
-  {
-    using Attr_T = T Class_T::*;
-    return new NativeAttribute<T, Attr_T, Class_T>(attr, access);
+    return value;
   }
 } // Rice

data/rice/detail/NativeFunction.hpp

@@ -2,40 +2,86 @@
 #define Rice__detail__Native_Function__hpp_
 
 #include "ruby.hpp"
-#include "Exception_Handler_defn.hpp"
+#include "ExceptionHandler_defn.hpp"
 #include "MethodInfo.hpp"
-#include "function_traits.hpp"
+#include "../traits/function_traits.hpp"
+#include "../traits/method_traits.hpp"
 #include "from_ruby.hpp"
 
 namespace Rice::detail
 {
-  template<typename Function_T, bool IsMethod>
+  //! The NativeFunction class calls C++ functions/methods/lambdas on behalf of Ruby
+  /*! The NativeFunction class is an intermediate between Ruby and C++. Every method
+   *  defined in Rice is associated with a NativeFuntion instance that is stored in
+   *  a unordered_map maintained by the MethodData class. The key is the Ruby class
+   *  and method.
+   * 
+   *  When Ruby calls into C++ it invokes the static NativeFunction.call method. This
+   *  method then looks up the NativeFunction instance and calls its ->() operator.
+   *
+   *  The instance then converts each of the arguments passed from Ruby into their
+   *  C++ equivalents. It then retrieves the C++ object (if there is one, Ruby could
+   *  be calling a free standing method or lambda). Then it calls the C++ method
+   *  and gets back the result. If there is a result (so not void), it is converted
+   *  from a C++ object to a Ruby object and returned back to Ruby.
+   * 
+   *  This class make heavy use of C++ Template metaprogramming to determine
+   *  the types and parameters a method takes. It then uses that information
+   *  to perform type conversion Ruby to C++.
+   *   
+   *  @tparam From_Ruby_T - The type of C++ class wrapped by Ruby. Note
+   *    this may be different than the Class of Function_T. For example, 
+   *    std::map has a size() method but that is actually implemented on 
+   *    an ancestor class _Tree. Thus From_Ruby_T is std::map but 
+   *    Function_T::Class_T is _Tree. This typename must be specified
+   *    by the calling code.
+   *  @tparam Function_T - A template that represents the C++ function
+   *    to call. This typename is automatically deduced by the compiler.
+   *  @tparam IsMethod - A boolean specifying whether the function has
+   *    a self parameter or not. Rice differentiates these two cases by
+   *    calling them methods (self) or functions (no self).
+   */
+
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
   class NativeFunction
   {
   public:
+    using NativeFunction_T = NativeFunction<From_Ruby_T, Function_T, IsMethod>;
+
     // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
     // have the concept of constants anyways
     using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
-    using Self_T = typename method_traits<Function_T, IsMethod>::Self_T;
+    using Class_T = typename method_traits<Function_T, IsMethod>::Class_T;
     using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
-    using From_Ruby_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+    using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+
+    // Register function with Ruby
+    static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
     // Static member function that Ruby calls
     static VALUE call(int argc, VALUE* argv, VALUE self);
 
   public:
-    NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo);
+    // 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;
 
     // Invokes the wrapped function
     VALUE operator()(int argc, VALUE* argv, VALUE self);
 
+  protected:
+    NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
+
   private:
     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_Ts createFromRuby(std::index_sequence<I...>& indices);
+    From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
 
     To_Ruby<Return_T> createToRuby();
       
@@ -47,23 +93,27 @@ namespace Rice::detail
     Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
 
     // Figure out what self is
-    Self_T getSelf(VALUE self);
+    Class_T getReceiver(VALUE self);
+
+    // Throw an exception when wrapper cannot be extracted
+    [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
 
     // Do we need to keep alive any arguments?
     void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
 
     // Call the underlying C++ function
-    VALUE invokeNativeFunction(Arg_Ts& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs);
+    VALUE invokeNativeFunction(const Arg_Ts& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs);
 
   private:
-    Function_T func_;
-    From_Ruby_Ts fromRubys_;
+    VALUE klass_;
+    std::string method_name_;
+    Function_T function_;
+    From_Ruby_Args_Ts fromRubys_;
     To_Ruby<Return_T> toRuby_;
-    std::shared_ptr<Exception_Handler> handler_;
     std::unique_ptr<MethodInfo> methodInfo_;
   };
 }
 #include "NativeFunction.ipp"
 
-#endif // Rice__detail__Native_Function__hpp_
+#endif // Rice__detail__Native_Function__hpp_

data/rice/detail/NativeFunction.ipp

@@ -1,24 +1,43 @@
 #include <array>
 #include <algorithm>
 #include <stdexcept>
+#include <sstream>
 
-#include "method_data.hpp"
+#include "cpp_protect.hpp"
 #include "to_ruby_defn.hpp"
-#include "../ruby_try_catch.hpp"
+#include "NativeRegistry.hpp"
 
 namespace Rice::detail
 {
-  template<typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Function_T, IsMethod>::call(int argc, VALUE* argv, VALUE self)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  void NativeFunction<From_Ruby_T, Function_T, IsMethod>::define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo)
   {
-    using Wrapper_T = NativeFunction<Function_T, IsMethod>;
-    Wrapper_T* wrapper = detail::MethodData::data<Wrapper_T*>();
-    return wrapper->operator()(argc, argv, self);
+    // Tell Ruby to invoke the static method call on this class
+    detail::protect(rb_define_method, klass, method_name.c_str(), (RUBY_METHOD_FUNC)&NativeFunction_T::call, -1);
+
+    // Now create a NativeFunction instance and save it to the natives registry keyed on
+    // Ruby klass and method id. There may be multiple NativeFunction instances
+    // because the same C++ method could be mapped to multiple Ruby methods.
+    NativeFunction_T* native = new NativeFunction_T(klass, method_name, std::forward<Function_T>(function), methodInfo);
+    detail::Registries::instance.natives.add(klass, Identifier(method_name).id(), native);
+  }
+
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  VALUE NativeFunction<From_Ruby_T, Function_T, IsMethod>::call(int argc, VALUE* argv, VALUE self)
+  {
+    // Look up the native function based on the Ruby klass and method id
+    NativeFunction_T* nativeFunction = detail::Registries::instance.natives.lookup<NativeFunction_T*>();
+
+    // Execute the function but make sure to catch any C++ exceptions!
+    return cpp_protect([&]
+    {
+      return nativeFunction->operator()(argc, argv, self);
+    });
   }
 
-  template<typename Function_T, bool IsMethod>
-  NativeFunction<Function_T, IsMethod>::NativeFunction(Function_T func, std::shared_ptr<Exception_Handler> handler, MethodInfo* methodInfo)
-    : func_(func), handler_(handler), methodInfo_(methodInfo)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  NativeFunction<From_Ruby_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 
@@ -30,9 +49,9 @@ namespace Rice::detail
     this->toRuby_ = this->createToRuby();
   }
 
-  template<typename Function_T, bool IsMethod>
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
   template<typename T, std::size_t I>
-  From_Ruby<T> NativeFunction<Function_T, IsMethod>::createFromRuby()
+  From_Ruby<T> NativeFunction<From_Ruby_T, Function_T, IsMethod>::createFromRuby()
   {
     // Does the From_Ruby instantiation work with Arg?
     if constexpr (std::is_constructible_v<From_Ruby<T>, Arg*>)
@@ -45,8 +64,8 @@ namespace Rice::detail
     }
   }
 
-  template<typename Function_T, bool IsMethod>
-  To_Ruby<typename NativeFunction<Function_T, IsMethod>::Return_T> NativeFunction<Function_T, IsMethod>::createToRuby()
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  To_Ruby<typename NativeFunction<From_Ruby_T, Function_T, IsMethod>::Return_T> NativeFunction<From_Ruby_T, Function_T, IsMethod>::createToRuby()
   {
     // Does the From_Ruby instantiation work with ReturnInfo?
     if constexpr (std::is_constructible_v<To_Ruby<Return_T>, Return*>)
@@ -59,41 +78,41 @@ namespace Rice::detail
     }
   }
 
-  template<typename Function_T, bool IsMethod>
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
   template<std::size_t... I>
-  typename NativeFunction<Function_T, IsMethod>::From_Ruby_Ts NativeFunction<Function_T, IsMethod>::createFromRuby(std::index_sequence<I...>& indices)
+  typename NativeFunction<From_Ruby_T, Function_T, IsMethod>::From_Ruby_Args_Ts NativeFunction<From_Ruby_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 Function_T, bool IsMethod>
-  std::vector<VALUE> NativeFunction<Function_T, IsMethod>::getRubyValues(int argc, VALUE* argv)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  std::vector<VALUE> NativeFunction<From_Ruby_T, Function_T, IsMethod>::getRubyValues(int argc, VALUE* argv)
   {
-    // Setup a tuple to contain required methodInfo to rb_scan_args
+    // Setup a tuple for the leading rb_scan_args arguments
     std::string scanFormat = this->methodInfo_->formatString();
-    std::tuple<int, VALUE*, const char*> rbScanMandatory = std::forward_as_tuple(argc, argv, scanFormat.c_str());
+    std::tuple<int, VALUE*, const char*> rbScanArgs = std::forward_as_tuple(argc, argv, scanFormat.c_str());
 
-    // Create a vector to store the variable number of Ruby Values
-    std::vector<VALUE> rbScanArgsOptional(std::tuple_size_v<Arg_Ts>, Qnil);
+    // Create a vector to store the VALUEs that will be returned by rb_scan_args
+    std::vector<VALUE> rbScanValues(std::tuple_size_v<Arg_Ts>, Qnil);
 
-    // Convert the vector to an array so it can then be concatenated to a tuple
-    std::array<VALUE*, std::tuple_size_v<Arg_Ts>> rbScanArgsOptionalPointers;
-    std::transform(rbScanArgsOptional.begin(), rbScanArgsOptional.end(), rbScanArgsOptionalPointers.begin(),
+    // Convert the vector to an array so it can be concatenated to a tuple. As importantly
+    // fill it with pointers to rbScanValues
+    std::array<VALUE*, std::tuple_size_v<Arg_Ts>> rbScanValuePointers;
+    std::transform(rbScanValues.begin(), rbScanValues.end(), rbScanValuePointers.begin(),
       [](VALUE& value)
       {
         return &value;
       });
 
     // Combine the tuples and call rb_scan_args
-    auto rbScanArgs = std::tuple_cat(rbScanMandatory, rbScanArgsOptionalPointers);
-    std::apply(rb_scan_args, rbScanArgs);
+    std::apply(rb_scan_args, std::tuple_cat(rbScanArgs, rbScanValuePointers));
 
-    return rbScanArgsOptional;
+    return rbScanValues;
   }
 
-  template<typename Function_T, bool IsMethod>
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
   template<std::size_t... I>
-  typename NativeFunction<Function_T, IsMethod>::Arg_Ts NativeFunction<Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
+  typename NativeFunction<From_Ruby_T, Function_T, IsMethod>::Arg_Ts NativeFunction<From_Ruby_T, Function_T, IsMethod>::getNativeValues(std::vector<VALUE>& values,
      std::index_sequence<I...>& indices)
   {
     // Convert each Ruby value to its native value by calling the appropriate fromRuby instance.
@@ -102,80 +121,91 @@ namespace Rice::detail
     return std::forward_as_tuple(std::get<I>(this->fromRubys_).convert(values[I])...);
   }
 
-  template<typename Function_T, bool IsMethod>
-  typename NativeFunction<Function_T, IsMethod>::Self_T NativeFunction<Function_T, IsMethod>::getSelf(VALUE self)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  typename NativeFunction<From_Ruby_T, Function_T, IsMethod>::Class_T NativeFunction<From_Ruby_T, Function_T, IsMethod>::getReceiver(VALUE self)
   {
     // There is no self parameter
-    if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
+    if constexpr (std::is_same_v<Class_T, std::nullptr_t>)
     {
       return nullptr;
     }
     // Self parameter is a Ruby VALUE so no conversion is needed
-    else if constexpr (std::is_same_v<Self_T, VALUE>)
+    else if constexpr (std::is_same_v<Class_T, VALUE>)
     {
       return self;
     }
-    // Self parameter could be derived from Object or it is an C++ instdance and
+    /* 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<Class_T>, From_Ruby_T> && 
+                        std::is_base_of_v<intrinsic_type<Class_T>, From_Ruby_T>)
+    {
+      From_Ruby_T* instance = From_Ruby<From_Ruby_T*>().convert(self);
+      return dynamic_cast<Class_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<Self_T>().convert(self);
+      return From_Ruby<Class_T>().convert(self);
     }
   }
 
-  template<typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeFunction(Arg_Ts& nativeArgs)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  VALUE NativeFunction<From_Ruby_T, Function_T, IsMethod>::invokeNativeFunction(const Arg_Ts& nativeArgs)
   {
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->func_, nativeArgs);
+      std::apply(this->function_, nativeArgs);
       return Qnil;
     }
     else
     {
       // Call the native method and get the result
-      Return_T nativeResult = std::apply(this->func_, nativeArgs);
-      
+      Return_T nativeResult = std::apply(this->function_, nativeArgs);
+
       // Return the result
       return this->toRuby_.convert(nativeResult);
     }
   }
 
-  template<typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Function_T, IsMethod>::invokeNativeMethod(VALUE self, Arg_Ts& nativeArgs)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  VALUE NativeFunction<From_Ruby_T, Function_T, IsMethod>::invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs)
   {
-    Self_T receiver = this->getSelf(self);
+    Class_T receiver = this->getReceiver(self);
     auto selfAndNativeArgs = std::tuple_cat(std::forward_as_tuple(receiver), nativeArgs);
 
     if constexpr (std::is_void_v<Return_T>)
     {
-      std::apply(this->func_, selfAndNativeArgs);
+      std::apply(this->function_, selfAndNativeArgs);
       return Qnil;
     }
     else
     {
-      Return_T nativeResult = (Return_T)std::apply(this->func_, selfAndNativeArgs);
+      Return_T nativeResult = (Return_T)std::apply(this->function_, 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<Self_T>>)
+      if constexpr (std::is_same_v<intrinsic_type<Return_T>, intrinsic_type<Class_T>>)
       {
-        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Self_T>)
+        if constexpr (std::is_pointer_v<Return_T> && std::is_pointer_v<Class_T>)
         {
           if (nativeResult == receiver)
             return self;
         }
-        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Self_T>)
+        else if constexpr (std::is_pointer_v<Return_T> && std::is_reference_v<Class_T>)
         {
           if (nativeResult == &receiver)
             return self;
         }
-        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Self_T>)
+        else if constexpr (std::is_reference_v<Return_T> && std::is_pointer_v<Class_T>)
         {
           if (&nativeResult == receiver)
             return self;
         }
-        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Self_T>)
+        else if constexpr (std::is_reference_v<Return_T> && std::is_reference_v<Class_T>)
         {
           if (&nativeResult == &receiver)
             return self;
@@ -186,63 +216,85 @@ namespace Rice::detail
     }
   }
 
-  template<typename Function_T, bool IsMethod>
-  void NativeFunction<Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  void NativeFunction<From_Ruby_T, Function_T, IsMethod>::noWrapper(const VALUE klass, const std::string& wrapper)
   {
-    // Check function arguments
+    std::stringstream message;
+
+    message << "When calling the method `";
+    message << this->method_name_;
+    message << "' we could not find the wrapper for the '";
+    message << rb_obj_classname(klass);
+    message << "' ";
+    message << wrapper;
+    message << " type. You should not use keepAlive() on a Return or Arg that is a builtin Rice type.";
+
+    throw std::runtime_error(message.str());
+  }
+
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  void NativeFunction<From_Ruby_T, Function_T, IsMethod>::checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues)
+  {
+    // selfWrapper will be nullptr if this(self) is a builtin type and not an external(wrapped) type
+    // it is highly unlikely that keepAlive is used in this case but we check anyway
     Wrapper* selfWrapper = getWrapper(self);
+
+    // Check function arguments
     for (const Arg& arg : (*this->methodInfo_))
     {
-      if (arg.isKeepAlive)
+      if (arg.isKeepAlive())
       {
+        if (selfWrapper == nullptr)
+        {
+          noWrapper(self, "self");
+        }
         selfWrapper->addKeepAlive(rubyValues[arg.position]);
       }
     }
 
     // Check return value
-    if (this->methodInfo_->returnInfo.isKeepAlive)
+    if (this->methodInfo_->returnInfo.isKeepAlive())
     {
+      if (selfWrapper == nullptr)
+      {
+        noWrapper(self, "self");
+      }
+
+      // returnWrapper will be nullptr if returnValue is a built-in type and not an external(wrapped) type
       Wrapper* returnWrapper = getWrapper(returnValue);
+      if (returnWrapper == nullptr)
+      {
+        noWrapper(returnValue, "return");
+      }
       returnWrapper->addKeepAlive(self);
     }
   }
 
-  template<typename Function_T, bool IsMethod>
-  VALUE NativeFunction<Function_T, IsMethod>::operator()(int argc, VALUE* argv, VALUE self)
+  template<typename From_Ruby_T, typename Function_T, bool IsMethod>
+  VALUE NativeFunction<From_Ruby_T, Function_T, IsMethod>::operator()(int argc, VALUE* argv, VALUE self)
   {
-    try
-    {
-      // Get the ruby values
-      std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv);
-
-      auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
-
-      // Convert the Ruby values to native values
-      Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
+    // Get the ruby values
+    std::vector<VALUE> rubyValues = this->getRubyValues(argc, argv);
 
-      // Now call the native method
-      VALUE result = Qnil;
-      if constexpr (std::is_same_v<Self_T, std::nullptr_t>)
-      {
-        result = this->invokeNativeFunction(nativeValues);
-      }
-      else
-      {
-        result = this->invokeNativeMethod(self, nativeValues);
-      }
+    auto indices = std::make_index_sequence<std::tuple_size_v<Arg_Ts>>{};
 
-      // Check if any function arguments or return values need to have their lifetimes tied to the receiver
-      this->checkKeepAlive(self, result, rubyValues);
+    // Convert the Ruby values to native values
+    Arg_Ts nativeValues = this->getNativeValues(rubyValues, indices);
 
-      return result;
+    // Now call the native method
+    VALUE result = Qnil;
+    if constexpr (std::is_same_v<Class_T, std::nullptr_t>)
+    {
+      result = this->invokeNativeFunction(nativeValues);
     }
-    catch (...)
+    else
     {
-      RUBY_TRY
-      {
-        return this->handler_->handle_exception();
-      }
-      RUBY_CATCH
+      result = this->invokeNativeMethod(self, nativeValues);
     }
+
+    // Check if any function arguments or return values need to have their lifetimes tied to the receiver
+    this->checkKeepAlive(self, result, rubyValues);
+
+    return result;
   }
 }