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;
@@ -1714,7 +1714,7 @@ make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
 
         if (type->flags & RUBY_TYPED_FROZEN_SHAREABLE_NO_REC) {
             if (obj_refer_only_shareables_p(obj)) {
-                ractor_warn_frozen_error_mark(obj);
+                rb_ractor_warn_frozen_error_mark(obj);
                 return traverse_skip;
             }
             else {
@@ -1754,7 +1754,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;
 }
 
@@ -2699,9 +2699,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,77 @@ def test_warn_frozen_error_warns_on_instance_variable_writes
     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_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 +717,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

vm.c

@@ -1609,9 +1609,14 @@ rb_proc_ractor_make_shareable_continue(VALUE self, VALUE replace_self, VALUE *ch
         if (!RB_SPECIAL_CONST_P(block_self) &&
                 !RB_OBJ_SHAREABLE_P(block_self)) {
             if (!rb_ractor_shareable_p_continue(block_self, chain)) {
-                rb_ractor_error_chain_append(chain, "\n  from block's self (an instance of %"PRIsVALUE")",
-                                             rb_class_real(CLASS_OF(block_self)));
-                return false;
+                if (ruby_ractor_warn_frozen_error) {
+                    rb_ractor_make_shareable(block_self);
+                }
+                else {
+                    rb_ractor_error_chain_append(chain, "\n  from block's self (an instance of %"PRIsVALUE")",
+                                                 rb_class_real(CLASS_OF(block_self)));
+                    return false;
+                }
             }
         }
 
@@ -1631,13 +1636,23 @@ rb_proc_ractor_make_shareable_continue(VALUE self, VALUE replace_self, VALUE *ch
 
         VALUE proc_self = vm_block_self(block);
         if (!rb_ractor_shareable_p_continue(proc_self, chain)) {
-            rb_ractor_error_chain_append(chain, "\n  from proc's self (an instance of %"PRIsVALUE")",
-                                             rb_class_real(CLASS_OF(proc_self)));
-            return false;
+            if (ruby_ractor_warn_frozen_error) {
+                rb_ractor_make_shareable(proc_self);
+            }
+            else {
+                rb_ractor_error_chain_append(chain, "\n  from proc's self (an instance of %"PRIsVALUE")",
+                                                 rb_class_real(CLASS_OF(proc_self)));
+                return false;
+            }
         }
     }
 
-    RB_OBJ_SET_FROZEN_SHAREABLE(self);
+    if (ruby_ractor_warn_frozen_error) {
+        rb_ractor_warn_frozen_error_mark(self);
+    }
+    else {
+        RB_OBJ_SET_FROZEN_SHAREABLE(self);
+    }
     return true;
 }