Add C API function rb_funcall_with_block_kw

Author: andrykonchin

lib/truffle/truffle/cext.rb

@@ -903,6 +903,10 @@ def rb_funcall_with_block(recv, meth, argv, block)
     Primitive.public_send_argv_without_cext_lock(recv, meth, argv, block)
   end
 
+  def rb_funcall_with_block_keywords(recv, meth, argv, block)
+    Primitive.public_send_argv_keywords_without_cext_lock(recv, meth, argv, block)
+  end
+
   def rb_funcallv_public(recv, meth, argv)
     Primitive.public_send_argv_without_cext_lock(recv, meth, argv, nil)
   end

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

@@ -340,8 +340,12 @@ static VALUE kernel_spec_rb_funcallv_public(VALUE self, VALUE obj, VALUE method)
   return rb_funcallv_public(obj, SYM2ID(method), 0, NULL);
 }
 
-static VALUE kernel_spec_rb_funcall_with_block(VALUE self, VALUE obj, VALUE method, VALUE block) {
-  return rb_funcall_with_block(obj, SYM2ID(method), 0, NULL, block);
+static VALUE kernel_spec_rb_funcall_with_block(VALUE self, VALUE obj, VALUE method, VALUE args, VALUE block) {
+  return rb_funcall_with_block(obj, SYM2ID(method), RARRAY_LENINT(args), RARRAY_PTR(args), block);
+}
+
+static VALUE kernel_spec_rb_funcall_with_block_kw(VALUE self, VALUE obj, VALUE method, VALUE args, VALUE block) {
+  return rb_funcall_with_block_kw(obj, SYM2ID(method), RARRAY_LENINT(args), RARRAY_PTR(args), block, RB_PASS_KEYWORDS);
 }
 
 static VALUE kernel_spec_rb_funcall_many_args(VALUE self, VALUE obj, VALUE method) {
@@ -397,7 +401,8 @@ void Init_kernel_spec(void) {
 #endif
   rb_define_method(cls, "rb_funcallv_public", kernel_spec_rb_funcallv_public, 2);
   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, 3);
+  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);
 }
 
 #ifdef __cplusplus

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

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

spec/ruby/optional/capi/kernel_spec.rb

@@ -1,4 +1,5 @@
 require_relative 'spec_helper'
+require_relative 'fixtures/kernel'
 
 kernel_path = load_extension("kernel")
 
@@ -597,6 +598,16 @@ def sum(a, b)
       @s.rb_funcallv(self, :empty, []).should == 42
       @s.rb_funcallv(self, :sum, [1, 2]).should == 3
     end
+
+    it "calls a private method" do
+      object = CApiKernelSpecs::ClassWithPrivateMethod.new
+      @s.rb_funcallv(object, :private_method, []).should == 0
+    end
+
+    it "calls a protected method" do
+      object = CApiKernelSpecs::ClassWithProtectedMethod.new
+      @s.rb_funcallv(object, :protected_method, []).should == 0
+    end
   end
 
   ruby_version_is "3.0" do
@@ -621,6 +632,16 @@ def m(*args, **kwargs)
           @s.rb_funcallv_kw(self, :m, [42])
         }.should raise_error(TypeError, 'no implicit conversion of Integer into Hash')
       end
+
+      it "calls a private method" do
+        object = CApiKernelSpecs::ClassWithPrivateMethod.new
+        @s.rb_funcallv_kw(object, :private_method, [{}]).should == 0
+      end
+
+      it "calls a protected method" do
+        object = CApiKernelSpecs::ClassWithProtectedMethod.new
+        @s.rb_funcallv_kw(object, :protected_method, [{}]).should == 0
+      end
     end
 
     describe "rb_keyword_given_p" do
@@ -676,21 +697,56 @@ def many_args(*args)
   end
 
   describe 'rb_funcall_with_block' do
-    before :each do
+    it "calls a method with block" do
       @obj = Object.new
       class << @obj
-        def method_public; yield end
-        def method_private; yield end
-        private :method_private
+        def method_public(*args); [args, yield] end
       end
+
+      @s.rb_funcall_with_block(@obj, :method_public, [1, 2], proc { :result }).should == [[1, 2], :result]
     end
 
-    it "calls a method with block" do
-      @s.rb_funcall_with_block(@obj, :method_public, proc { :result }).should == :result
+    it "does not call a private method" do
+      object = CApiKernelSpecs::ClassWithPrivateMethod.new
+
+      -> {
+        @s.rb_funcall_with_block(object, :private_method, [], proc { })
+      }.should raise_error(NoMethodError, /private/)
+    end
+
+    it "does not call a protected method" do
+      object = CApiKernelSpecs::ClassWithProtectedMethod.new
+
+      -> {
+        @s.rb_funcall_with_block(object, :protected_method, [], proc { })
+      }.should raise_error(NoMethodError, /protected/)
+    end
+  end
+
+  describe 'rb_funcall_with_block_kw' do
+    it "calls a method with keyword arguments and a block" do
+      @obj = Object.new
+      class << @obj
+        def method_public(*args, **kw, &block); [args, kw, block.call] end
+      end
+
+      @s.rb_funcall_with_block_kw(@obj, :method_public, [1, 2, {a: 2}], proc { :result }).should == [[1, 2], {a: 2}, :result]
     end
 
     it "does not call a private method" do
-      -> { @s.rb_funcall_with_block(@obj, :method_private, proc { :result }) }.should raise_error(NoMethodError, /private/)
+      object = CApiKernelSpecs::ClassWithPrivateMethod.new
+
+      -> {
+        @s.rb_funcall_with_block_kw(object, :private_method, [{}], proc { })
+      }.should raise_error(NoMethodError, /private/)
+    end
+
+    it "does not call a protected method" do
+      object = CApiKernelSpecs::ClassWithProtectedMethod.new
+
+      -> {
+        @s.rb_funcall_with_block_kw(object, :protected_method, [{}], proc { })
+      }.should raise_error(NoMethodError, /protected/)
     end
   end
 end

src/main/c/cext/call.c

@@ -106,6 +106,18 @@ VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VAL
     rb_tr_unwrap(pass_procval)));
 }
 
+VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval, int kw_splat) {
+  if (kw_splat && argc > 0) {
+    return rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_funcall_with_block_keywords",
+      rb_tr_unwrap(recv),
+      rb_tr_unwrap(ID2SYM(mid)),
+      polyglot_from_VALUE_array(argv, argc),
+      rb_tr_unwrap(procval)));
+  } else {
+    return rb_funcall_with_block(recv, mid, argc, argv, procval);
+  }
+}
+
 VALUE rb_yield_splat(VALUE values) {
   if (rb_block_given_p()) {
     return RUBY_CEXT_INVOKE("rb_yield_splat", values);

src/main/java/org/truffleruby/cext/CExtNodes.java

@@ -411,6 +411,32 @@ protected Object publicSendWithoutLock(
         }
     }
 
+    @Primitive(name = "public_send_argv_keywords_without_cext_lock")
+    public abstract static class PublicSendARGVKeywordsWithoutCExtLockNode extends SendWithoutCExtLockBaseNode {
+        @Specialization
+        protected Object sendWithoutCExtLock(
+                VirtualFrame frame, Object receiver, RubySymbol method, Object argv, Object block,
+                @Cached UnwrapCArrayNode unwrapCArrayNode,
+                @Cached HashCastNode hashCastNode,
+                @Cached InlinedConditionProfile emptyProfile,
+                @Cached(parameters = "PUBLIC") DispatchNode dispatchNode,
+                @Cached InlinedConditionProfile ownedProfile) {
+            Object[] args = unwrapCArrayNode.execute(argv);
+
+            // Remove empty kwargs in the caller, so the callee does not need to care about this special case
+            final RubyHash keywords = hashCastNode.execute(ArrayUtils.getLast(args));
+            if (emptyProfile.profile(this, keywords.empty())) {
+                args = LiteralCallNode.removeEmptyKeywordArguments(args);
+                return sendWithoutCExtLock(frame, receiver, method, block, EmptyArgumentsDescriptor.INSTANCE, args,
+                        dispatchNode, ownedProfile);
+            } else {
+                return sendWithoutCExtLock(frame, receiver, method, block,
+                        KeywordArgumentsDescriptorManager.EMPTY, args,
+                        dispatchNode, ownedProfile);
+            }
+        }
+    }
+
     @Primitive(name = "cext_mark_object_on_call_exit")
     public abstract static class MarkObjectOnCallExit extends PrimitiveArrayArgumentsNode {