[GR-17457] Remove the behavior that rb_funcall() passes the rb_iterate() block

PullRequest: truffleruby/2707

Author: eregon

CHANGELOG.md

@@ -51,6 +51,7 @@ Performance:
 
 Changes:
 
+* `rb_iterate()` (deprecated since 1.9) no longer magically passes the block to `rb_funcall()`, use `rb_block_call()` instead.
 
 Security:
 

lib/truffle/truffle/cext.rb

@@ -878,14 +878,7 @@ def rb_funcallv(recv, meth, argv)
   end
 
   def rb_funcall(recv, meth, n, *args)
-    # see #call_with_thread_locally_stored_block
-    thread_local_block = Thread.current[:__C_BLOCK__]
-    Thread.current[:__C_BLOCK__] = nil
-    begin
-      Primitive.send_without_cext_lock(recv, meth, args, thread_local_block)
-    ensure
-      Thread.current[:__C_BLOCK__] = thread_local_block
-    end
+    Primitive.send_without_cext_lock(recv, meth, args, nil)
   end
 
   def rb_apply(recv, meth, args)
@@ -1656,21 +1649,17 @@ def rb_thread_call_without_gvl(function, data1, unblock, data2)
 
   def rb_iterate(iteration, iterated_object, callback, callback_arg)
     block = rb_block_proc
-    if block
-      call_with_thread_locally_stored_block iteration, iterated_object do |block_arg|
-        rb_iterate_call_block(callback, block_arg, callback_arg, &block)
-      end
-    else
-      call_with_thread_locally_stored_block iteration, iterated_object do |block_arg|
-        Primitive.cext_unwrap(Primitive.call_with_c_mutex(callback, [
-            Primitive.cext_wrap(block_arg),
-            Primitive.cext_wrap(callback_arg),
-            0, # argc
-            nil, # argv
-            nil, # blockarg
-        ]))
-      end
-    end
+    wrapped_callback = proc do |block_arg|
+      Primitive.cext_unwrap(Primitive.call_with_c_mutex_and_frame(callback, [
+        Primitive.cext_wrap(block_arg),
+        Primitive.cext_wrap(callback_arg),
+        0, # argc
+        nil, # argv
+        nil, # blockarg
+      ], block))
+    end
+    Primitive.cext_unwrap(
+      Primitive.call_with_c_mutex_and_frame(iteration, [Primitive.cext_wrap(iterated_object)], wrapped_callback))
   end
 
   def rb_thread_wait_fd(fd)

lib/truffle/truffle/cext_ruby.rb

@@ -50,31 +50,4 @@ def rb_define_method(mod, name, function, argc)
     method_body_with_arity = Primitive.proc_specify_arity(method_body, arity)
     mod.define_method(name, method_body_with_arity)
   end
-
-  private
-
-  def rb_iterate_call_block(callback, block_arg, callback_arg, &block)
-    Primitive.cext_unwrap(Primitive.call_with_c_mutex_and_frame(callback, [
-        Primitive.cext_wrap(block_arg),
-        Primitive.cext_wrap(callback_arg),
-        0, # argc
-        nil, # argv
-        nil, # blockarg
-    ], block))
-  end
-
-  def call_with_thread_locally_stored_block(function, *args, &block)
-    # MRI puts the block to a thread local th->passed_block and later rb_funcall reads it,
-    # we have to do the same
-    # TODO (pitr-ch 14-Dec-2017): This is fixed just for rb_iterate with a rb_funcall in it combination
-
-    previous_block = Thread.current[:__C_BLOCK__]
-    begin
-      Thread.current[:__C_BLOCK__] = block
-      Primitive.cext_unwrap(Primitive.call_with_c_mutex_and_frame(function, args.map! { |arg| Primitive.cext_wrap(arg) }, block))
-    ensure
-      Thread.current[:__C_BLOCK__] = previous_block
-    end
-  end
-
 end

spec/ruby/optional/capi/proc_spec.rb

@@ -104,8 +104,9 @@
 
   # Ruby -> C -> Ruby -> Proc.new
   it "raises an ArgumentError when the C function calls a Ruby method that calls Proc.new" do
-    def @p.Proc_new() Proc.new end
-    -> { @p.rb_Proc_new(2) { :called } }.should raise_error(ArgumentError)
+    -> {
+      @p.rb_Proc_new(2) { :called }
+    }.should raise_error(ArgumentError)
   end
 
   # Ruby -> C -> Ruby -> C -> rb_funcall(Proc.new)

spec/tags/optional/capi/array_tags.txt

@@ -0,0 +1 @@
+fails(deprecated):C-API Array function rb_iterate calls a function with the other function available as a block