[GR-51310] Implement rb_check_funcall()

PullRequest: truffleruby/4122

Author: eregon

CHANGELOG.md

@@ -30,6 +30,7 @@ Compatibility:
 * Support `Socket.sockaddr_in(port, Socket::INADDR_ANY)` (#3361, @mtortonesi).
 * Implement the `Data` class from Ruby 3.2 (#3039, @moste00, @eregon).
 * Make `Coverage.start` and `Coverage.result` accept parameters (#3149, @mtortonesi, @andrykonchin).
+* Implement `rb_check_funcall()` (@eregon).
 
 Performance:
 

lib/cext/include/truffleruby/truffleruby-abi-version.h

@@ -10,6 +10,6 @@
 // $RUBY_VERSION must be the same as TruffleRuby.LANGUAGE_VERSION.
 // $ABI_NUMBER starts at 1 and is incremented for every ABI-incompatible change.
 
-#define TRUFFLERUBY_ABI_VERSION "3.2.2.9"
+#define TRUFFLERUBY_ABI_VERSION "3.2.2.10"
 
 #endif

lib/truffle/truffle/cext.rb

@@ -1060,6 +1060,10 @@ def rb_funcallv(recv, meth, argv)
     Primitive.send_argv_without_cext_lock(recv, meth, argv, nil)
   end
 
+  def rb_check_funcall(recv, meth, args)
+    Primitive.send_without_cext_lock(Truffle::Type, :check_funcall, [recv, meth, args], nil)
+  end
+
   def rb_funcallv_keywords(recv, meth, argv)
     Primitive.send_argv_keywords_without_cext_lock(recv, meth, argv, nil)
   end

spec/ruby/optional/capi/ext/kernel_spec.c

@@ -355,6 +355,15 @@ static VALUE kernel_spec_rb_funcall_many_args(VALUE self, VALUE obj, VALUE metho
                     INT2FIX(5), INT2FIX(4), INT2FIX(3), INT2FIX(2), INT2FIX(1));
 }
 
+static VALUE kernel_spec_rb_check_funcall(VALUE self, VALUE receiver, VALUE method, VALUE args) {
+  VALUE ret = rb_check_funcall(receiver, SYM2ID(method), RARRAY_LENINT(args), RARRAY_PTR(args));
+  if (ret == Qundef) {
+    return ID2SYM(rb_intern("Qundef"));
+  } else {
+    return ret;
+  }
+}
+
 void Init_kernel_spec(void) {
   VALUE cls = rb_define_class("CApiKernelSpecs", rb_cObject);
   rb_define_method(cls, "rb_block_given_p", kernel_spec_rb_block_given_p, 0);
@@ -403,6 +412,7 @@ void Init_kernel_spec(void) {
   rb_define_method(cls, "rb_funcall_many_args", kernel_spec_rb_funcall_many_args, 2);
   rb_define_method(cls, "rb_funcall_with_block", kernel_spec_rb_funcall_with_block, 4);
   rb_define_method(cls, "rb_funcall_with_block_kw", kernel_spec_rb_funcall_with_block_kw, 4);
+  rb_define_method(cls, "rb_check_funcall", kernel_spec_rb_check_funcall, 3);
 }
 
 #ifdef __cplusplus

spec/ruby/optional/capi/fixtures/kernel.rb

@@ -1,19 +1,19 @@
 class CApiKernelSpecs
   class ClassWithPublicMethod
     def public_method(*, **)
-      0
+      :public
     end
   end
 
   class ClassWithPrivateMethod
     private def private_method(*, **)
-      0
+      :private
     end
   end
 
   class ClassWithProtectedMethod
     protected def protected_method(*, **)
-      0
+      :protected
     end
   end
 end

spec/ruby/optional/capi/kernel_spec.rb

@@ -606,12 +606,12 @@ def sum(a, b)
 
     it "calls a private method" do
       object = CApiKernelSpecs::ClassWithPrivateMethod.new
-      @s.rb_funcallv(object, :private_method, []).should == 0
+      @s.rb_funcallv(object, :private_method, []).should == :private
     end
 
     it "calls a protected method" do
       object = CApiKernelSpecs::ClassWithProtectedMethod.new
-      @s.rb_funcallv(object, :protected_method, []).should == 0
+      @s.rb_funcallv(object, :protected_method, []).should == :protected
     end
   end
 
@@ -629,12 +629,12 @@ def m(*args, **kwargs)
 
     it "calls a private method" do
       object = CApiKernelSpecs::ClassWithPrivateMethod.new
-      @s.rb_funcallv_kw(object, :private_method, [{}]).should == 0
+      @s.rb_funcallv_kw(object, :private_method, [{}]).should == :private
     end
 
     it "calls a protected method" do
       object = CApiKernelSpecs::ClassWithProtectedMethod.new
-      @s.rb_funcallv_kw(object, :protected_method, [{}]).should == 0
+      @s.rb_funcallv_kw(object, :protected_method, [{}]).should == :protected
     end
 
     it "raises TypeError if the last argument is not a Hash" do
@@ -752,4 +752,39 @@ def method_public(*args, **kw, &block); [args, kw, block.call] end
       }.should raise_error(NoMethodError, /protected/)
     end
   end
+
+  describe "rb_check_funcall" do
+    it "calls a method" do
+      @s.rb_check_funcall(1, :+, [2]).should == 3
+    end
+
+    it "returns Qundef if the method is not defined" do
+      obj = Object.new
+      @s.rb_check_funcall(obj, :foo, []).should == :Qundef
+    end
+
+    it "uses #respond_to? to check if the method is defined" do
+      ScratchPad.record []
+      obj = Object.new
+      def obj.respond_to?(name, priv)
+        ScratchPad << name
+        name == :foo || super
+      end
+      def obj.method_missing(name, *args)
+        name == :foo ? [name, 42] : super
+      end
+      @s.rb_check_funcall(obj, :foo, []).should == [:foo, 42]
+      ScratchPad.recorded.should == [:foo]
+    end
+
+    it "calls a private method" do
+      object = CApiKernelSpecs::ClassWithPrivateMethod.new
+      @s.rb_check_funcall(object, :private_method, []).should == :private
+    end
+
+    it "calls a protected method" do
+      object = CApiKernelSpecs::ClassWithProtectedMethod.new
+      @s.rb_check_funcall(object, :protected_method, []).should == :protected
+    end
+  end
 end

src/main/c/cext/call.c

@@ -49,6 +49,13 @@ VALUE rb_funcallv_public(VALUE object, ID name, int args_count, const VALUE *arg
     polyglot_from_VALUE_array(args, args_count)));
 }
 
+VALUE rb_check_funcall(VALUE object, ID name, int args_count, const VALUE *args) {
+  return rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_check_funcall",
+    rb_tr_unwrap(object),
+    rb_tr_unwrap(ID2SYM(name)),
+    rb_tr_unwrap(rb_ary_new_from_values(args_count, args))));
+}
+
 VALUE rb_apply(VALUE object, ID name, VALUE args) {
   return RUBY_CEXT_INVOKE("rb_apply", object, ID2SYM(name), args);
 }