Expand to shareable_proc and shareable_lambda

Author: andrewn617

error.c

@@ -228,8 +228,8 @@ rb_warning_category_enabled_p(rb_warning_category_t category)
  * +:ractor_isolation+ ::
  *   Ractor isolation violations reported by Ractor.check_isolation
  *   (downgraded from Ractor::IsolationError exceptions to warnings), and
- *   FrozenError warnings reported for objects passed to Ractor.make_shareable
- *   while Ractor.warn_frozen_error is enabled.
+ *   FrozenError warnings reported for objects that would be frozen for Ractor
+ *   shareability while Ractor.warn_frozen_error is enabled.
  */
 
 static VALUE

include/ruby/internal/intern/error.h

@@ -202,16 +202,16 @@ RBIMPL_ATTR_NORETURN()
 void rb_error_frozen_object(VALUE what);
 
 /**
- * True once Ractor.warn_frozen_error has marked any objects whose would-be
+ * True once Ractor.warn_frozen_error has recorded any objects whose would-be
  * FrozenError should be reported as a warning instead.
  *
  * @internal
  */
 RUBY_EXTERN bool ruby_ractor_warn_frozen_error_objects_enabled;
 
 /**
- * Emits a warning and returns true if +obj+ was recorded by Ractor.make_shareable
- * while Ractor.warn_frozen_error was enabled.
+ * Emits a warning and returns true if +obj+ was recorded for Ractor
+ * shareability while Ractor.warn_frozen_error was enabled.
  *
  * @internal
  */

ractor.c

@@ -1270,13 +1270,13 @@ rb_ractor_warn_frozen_error_warn(VALUE obj)
     }
 
     rb_category_warn(RB_WARN_CATEGORY_RACTOR_ISOLATION,
-                     "would raise FrozenError: can't modify object passed to Ractor.make_shareable with Ractor.warn_frozen_error=true: %"PRIsVALUE,
+                     "would raise FrozenError: can't modify object that would be frozen for Ractor shareability with Ractor.warn_frozen_error=true: %"PRIsVALUE,
                      rb_obj_class(obj));
     return true;
 }
 
-static void
-ractor_warn_frozen_error_mark(VALUE obj)
+void
+rb_ractor_warn_frozen_error_mark(VALUE obj)
 {
     if (RB_SPECIAL_CONST_P(obj)) {
         return;
@@ -1708,19 +1708,22 @@ make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
     if (rb_ractor_shareable_p(obj)) {
         return traverse_skip;
     }
-    else if (!allow_frozen_shareable_p(obj)) {
+    else if (rb_ractor_warn_frozen_error_marked_p(obj)) {
+        return traverse_skip;
+    }
+
+    /* Mark on entry, not as a finalizer, so recursive warning-mode
+     * make_shareable calls that come from Proc self / outer-variable checks
+     * can detect cycles and stop instead of re-walking the same object graph
+     * until SystemStackError. */
+    rb_ractor_warn_frozen_error_mark(obj);
+
+    if (!allow_frozen_shareable_p(obj)) {
         VM_ASSERT(RB_TYPE_P(obj, T_DATA));
         const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);
 
         if (type->flags & RUBY_TYPED_FROZEN_SHAREABLE_NO_REC) {
-            if (obj_refer_only_shareables_p(obj)) {
-                ractor_warn_frozen_error_mark(obj);
-                return traverse_skip;
-            }
-            else {
-                rb_raise(rb_eRactorError,
-                         "can not make shareable object for %+"PRIsVALUE" because it refers unshareable objects", obj);
-            }
+            return obj_refer_only_shareables_p(obj) ? traverse_skip : traverse_cont;
         }
         else if (rb_obj_is_proc(obj)) {
             if (!rb_proc_ractor_make_shareable_continue(obj, Qundef, data->chain)) {
@@ -1735,7 +1738,7 @@ make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
             return traverse_cont;
         }
         else {
-            return traverse_stop;
+            return traverse_cont;
         }
     }
 
@@ -1754,7 +1757,7 @@ make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
 static enum obj_traverse_iterator_result
 mark_warn_shareable(VALUE obj)
 {
-    ractor_warn_frozen_error_mark(obj);
+    rb_ractor_warn_frozen_error_mark(obj);
     return traverse_cont;
 }
 
@@ -1781,13 +1784,20 @@ rb_ractor_make_shareable(VALUE obj)
 
     if (rb_obj_traverse(obj, enter_func, null_leave, final_func, &chain, &exception)) {
         if (!exception) {
-            exception = rb_exc_new3(rb_eRactorError, rb_sprintf("can not make shareable object for %+"PRIsVALUE, obj));
+            if (ruby_ractor_warn_frozen_error) {
+                exception = rb_exc_new3(rb_eRactorError,
+                                        rb_sprintf("can not make shareable object for an instance of %"PRIsVALUE,
+                                                   rb_class_real(CLASS_OF(obj))));
+            }
+            else {
+                exception = rb_exc_new3(rb_eRactorError, rb_sprintf("can not make shareable object for %+"PRIsVALUE, obj));
+            }
         }
         // In Ractor.check_isolation mode downgrade to a :ractor_isolation
         // warning (with the chain inlined) so the sweep can keep going.
         // Outside that mode, attach the chain to @reference_chain and raise
         // exactly as before.
-        if (rb_thread_ractor_isolation_check_p()) {
+        if (rb_thread_ractor_isolation_check_p() || ruby_ractor_warn_frozen_error) {
             VALUE message = rb_obj_as_string(rb_funcall(exception, rb_intern("message"), 0));
             if (!NIL_P(chain)) {
                 rb_str_append(message, chain);
@@ -2699,9 +2709,14 @@ static VALUE
 ractor_shareable_proc(rb_execution_context_t *ec, VALUE replace_self, bool is_lambda)
 {
     if (!rb_ractor_shareable_p(replace_self)) {
-        // In check_isolation mode this only warns; fall through and try to
-        // make the proc shareable anyway so the sweep can keep going.
-        rb_ractor_isolation_violation("self should be shareable: %" PRIsVALUE, replace_self);
+        if (ruby_ractor_warn_frozen_error) {
+            rb_ractor_make_shareable(replace_self);
+        }
+        else {
+            // In check_isolation mode this only warns; fall through and try to
+            // make the proc shareable anyway so the sweep can keep going.
+            rb_ractor_isolation_violation("self should be shareable: %" PRIsVALUE, replace_self);
+        }
     }
     VALUE proc = is_lambda ? rb_block_lambda() : rb_block_proc();
     return rb_proc_ractor_make_shareable(rb_proc_dup(proc), replace_self);

ractor.rb

@@ -735,6 +735,11 @@ def unmonitor port
   #     Ractor.shareable_proc(self: self){}
   #     #=> self should be shareable: main (Ractor::IsolationError)
   #
+  # If +Ractor.warn_frozen_error+ is enabled, the returned Proc (and any
+  # unshareable replacement +self+) is recorded for mutation warnings instead
+  # of being frozen or made actually shareable. This mode is intended only for
+  # development sweeps.
+  #
   def self.shareable_proc self: nil
     Primitive.attr! :use_block
 
@@ -748,6 +753,7 @@ def self.shareable_proc self: nil
   #   Ractor.shareable_lambda(self: nil){} -> shareable lambda
   #
   # Same as Ractor.shareable_proc, but returns a lambda Proc.
+  # +Ractor.warn_frozen_error+ has the same development-mode behavior here.
   #
   def self.shareable_lambda self: nil
     Primitive.attr! :use_block

ractor_core.h

@@ -167,15 +167,24 @@ st_table *rb_ractor_targeted_hooks(rb_ractor_t *cr);
  * gate site -- they just pay one extra LIKELY-false byte load. */
 RUBY_EXTERN bool ruby_ractor_isolation_check_enabled;
 
+/* Global opt-in used by Ractor.make_shareable, Ractor.shareable_proc, and
+ * Ractor.shareable_lambda to record would-be frozen objects and warn on later
+ * mutation instead of freezing them. */
+RUBY_EXTERN bool ruby_ractor_warn_frozen_error;
+
 /* True if the current thread has Ractor.check_isolation enabled.
  * Hot-path callers should NOT call this directly; go through
  * rb_ractor_isolation_check_active(). */
 bool rb_thread_ractor_isolation_check_p(void);
 
-/* True if obj was made warning-shareable by Ractor.make_shareable while
- * Ractor.warn_frozen_error was enabled. */
+/* True if obj was recorded by Ractor.make_shareable, Ractor.shareable_proc, or
+ * Ractor.shareable_lambda while Ractor.warn_frozen_error was enabled. */
 bool rb_ractor_warn_frozen_error_marked_p(VALUE obj);
 
+/* Record obj so future mutation attempts emit :ractor_isolation warnings
+ * instead of raising FrozenError. */
+void rb_ractor_warn_frozen_error_mark(VALUE obj);
+
 /* Report a Ractor isolation violation:
  *   - if Ractor.check_isolation is active on the current thread, emit a
  *     :ractor_isolation category warning and return;

test/ruby/test_ractor.rb

@@ -637,6 +637,152 @@ def test_warn_frozen_error_warns_on_instance_variable_writes
     RUBY
   end
 
+  def test_warn_frozen_error_make_shareable_tolerates_unshareable_typed_data
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        h = Hash.new(Mutex.new)
+        assert_nothing_raised { Ractor.make_shareable(h) }
+        assert_equal false, h.frozen?
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_make_shareable_handles_proc_cycles
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        obj = Object.new
+        pr = proc { obj }
+        obj.instance_variable_set(:@proc, pr)
+
+        assert_nothing_raised { Ractor.make_shareable(obj) }
+        assert_same obj, pr.call
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_marks_shareable_proc_without_freezing
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        pr = Ractor.shareable_proc { :ok }
+
+        assert_equal false, Ractor.shareable?(pr)
+        assert_equal false, pr.frozen?
+        assert_equal :ok, pr.call
+
+        assert_warning(/would raise FrozenError.*Proc/) do
+          pr.instance_variable_set(:@mutated, true)
+        end
+        assert_equal true, pr.instance_variable_get(:@mutated)
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_marks_shareable_lambda_without_freezing
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        pr = Ractor.shareable_lambda { :ok }
+
+        assert_equal false, Ractor.shareable?(pr)
+        assert_equal false, pr.frozen?
+        assert_equal true, pr.lambda?
+        assert_equal :ok, pr.call
+
+        assert_warning(/would raise FrozenError.*Proc/) do
+          pr.instance_variable_set(:@mutated, true)
+        end
+        assert_equal true, pr.instance_variable_get(:@mutated)
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_preserves_shareable_proc_outer_variables
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        ary = []
+        pr = nil
+
+        assert_warning(/cannot make a shareable Proc because it can refer unshareable object.*variable 'ary'/) do
+          pr = Ractor.shareable_proc { ary << :called; ary }
+        end
+
+        assert_equal [:called], pr.call
+        assert_equal false, ary.frozen?
+        assert_warning(/would raise FrozenError.*Array/) do
+          ary << :mutated
+        end
+        assert_equal [:called, :mutated], ary
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_warns_but_preserves_reassigned_outer_variables
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        counter = 0
+        pr = nil
+
+        assert_warning(/can not make a Proc shareable because it accesses outer variables \(counter\)/) do
+          pr = Ractor.shareable_proc { counter += 1 }
+        end
+
+        assert_equal 1, pr.call
+        assert_equal 2, pr.call
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_marks_shareable_proc_self_without_freezing
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+        replacement_self = Object.new
+        nested = []
+        replacement_self.instance_variable_set(:@nested, nested)
+        pr = Ractor.shareable_proc(self: replacement_self) { self }
+
+        assert_same replacement_self, pr.call
+        assert_equal false, replacement_self.frozen?
+        assert_equal false, nested.frozen?
+
+        assert_warning(/would raise FrozenError.*Object/) do
+          replacement_self.instance_variable_set(:@mutated, true)
+        end
+        assert_equal true, replacement_self.instance_variable_get(:@mutated)
+        assert_warning(/would raise FrozenError.*Array/) do
+          nested << :mutated
+        end
+        assert_equal [:mutated], nested
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
   def test_warn_frozen_error_off_uses_normal_make_shareable_freezing
     assert_ractor(<<~'RUBY')
       old = Ractor.warn_frozen_error
@@ -646,6 +792,10 @@ def test_warn_frozen_error_off_uses_normal_make_shareable_freezing
         Ractor.make_shareable(ary)
         assert_equal true, ary.frozen?
         assert_raise(FrozenError) { ary << :mutated }
+
+        pr = Ractor.shareable_proc { :ok }
+        assert_equal true, pr.frozen?
+        assert_raise(FrozenError) { pr.instance_variable_set(:@mutated, true) }
       ensure
         Ractor.warn_frozen_error = old
       end