Remove __C_BLOCK__ handling and use call_with_c_mutex_and_frame

Author: eregon

lib/truffle/truffle/cext.rb

@@ -878,14 +878,7 @@ def rb_funcallv(recv, meth, args)
   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, rb_block_proc)
   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/tags/optional/capi/proc_tags.txt

@@ -2,3 +2,4 @@ fails:C-API when calling Proc.new from a C function returns the Proc passed by t
 fails:C-API when calling Proc.new from a C function returns the Proc passed to the Ruby method when the C function calls other Ruby methods before calling Proc.new
 fails:C-API when calling Proc.new from a C function returns the most recent Proc passed when the Ruby method called the C function
 fails:C-API when calling Proc.new from a C function returns the Proc passed from the original Ruby call to the C function
+fails:C-API when calling Proc.new from a C function raises an ArgumentError when the C function calls a Ruby method that calls Proc.new