And Ractor.warn_frozen_error. This is to pair with Ractor.check_isolation. In this mode objects are not frozen by Ractor.make_shareable. But a warning will be emitted if the object is mutated.

Author: andrewn617

error.c

@@ -227,7 +227,9 @@ 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).
+ *   (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.
  */
 
 static VALUE

include/ruby/internal/intern/error.h

@@ -201,6 +201,22 @@ RBIMPL_ATTR_NORETURN()
  */
 void rb_error_frozen_object(VALUE what);
 
+/**
+ * True once Ractor.warn_frozen_error has marked 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.
+ *
+ * @internal
+ */
+bool rb_ractor_warn_frozen_error_warn(VALUE obj);
+
 /**
  * Queries  if the  passed  object is  frozen.
  *
@@ -253,8 +269,16 @@ static inline void
 rb_check_frozen_inline(VALUE obj)
 {
     if (RB_UNLIKELY(RB_OBJ_FROZEN(obj))) {
+        if (RB_UNLIKELY(ruby_ractor_warn_frozen_error_objects_enabled) &&
+            rb_ractor_warn_frozen_error_warn(obj)) {
+            return;
+        }
         rb_error_frozen_object(obj);
     }
+    else if (RB_UNLIKELY(ruby_ractor_warn_frozen_error_objects_enabled) &&
+             !(RB_TYPE_P(obj, T_STRING) && FL_TEST_RAW(obj, RUBY_FL_USER2 | RUBY_FL_USER3))) {
+        rb_ractor_warn_frozen_error_warn(obj);
+    }
 
     /* ref: internal CHILLED_STRING_P()
        This is an implementation detail subject to change. */

ractor.c

@@ -1229,6 +1229,67 @@ rb_obj_set_shareable(VALUE obj)
     return obj;
 }
 
+/* Global opt-in that makes Ractor.make_shareable record objects as
+ * "warning-shareable" instead of freezing them. Those objects are kept in an
+ * identity hash so rb_check_frozen() and selected fast paths can warn if they
+ * are mutated. */
+bool ruby_ractor_warn_frozen_error = false;
+bool ruby_ractor_warn_frozen_error_objects_enabled = false;
+static VALUE ractor_warn_frozen_error_objects = Qnil;
+
+static VALUE
+ractor_warn_frozen_error_objects_hash(void)
+{
+    if (NIL_P(ractor_warn_frozen_error_objects)) {
+        ractor_warn_frozen_error_objects = rb_ident_hash_new();
+        rb_obj_hide(ractor_warn_frozen_error_objects);
+        rb_gc_register_mark_object(ractor_warn_frozen_error_objects);
+    }
+    return ractor_warn_frozen_error_objects;
+}
+
+bool
+rb_ractor_warn_frozen_error_marked_p(VALUE obj)
+{
+    if (RB_SPECIAL_CONST_P(obj) || !ruby_ractor_warn_frozen_error_objects_enabled) {
+        return false;
+    }
+
+    if (NIL_P(ractor_warn_frozen_error_objects)) {
+        return false;
+    }
+
+    return RTEST(rb_hash_lookup2(ractor_warn_frozen_error_objects, obj, Qfalse));
+}
+
+bool
+rb_ractor_warn_frozen_error_warn(VALUE obj)
+{
+    if (!rb_ractor_warn_frozen_error_marked_p(obj)) {
+        return false;
+    }
+
+    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,
+                     rb_obj_class(obj));
+    return true;
+}
+
+static void
+ractor_warn_frozen_error_mark(VALUE obj)
+{
+    if (RB_SPECIAL_CONST_P(obj)) {
+        return;
+    }
+
+    if (RB_TYPE_P(obj, T_STRING)) {
+        rb_str_make_independent(obj);
+    }
+
+    rb_hash_aset(ractor_warn_frozen_error_objects_hash(), obj, Qtrue);
+    ruby_ractor_warn_frozen_error_objects_enabled = true;
+}
+
 /// traverse function
 
 // 2: stop search
@@ -1639,6 +1700,64 @@ make_shareable_check_shareable(VALUE obj, struct obj_traverse_data *data)
     return make_shareable_check_shareable_freeze(obj, traverse_cont, data);
 }
 
+static enum obj_traverse_iterator_result
+make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
+{
+    VM_ASSERT(!SPECIAL_CONST_P(obj));
+
+    if (rb_ractor_shareable_p(obj)) {
+        return traverse_skip;
+    }
+    else 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);
+            }
+        }
+        else if (rb_obj_is_proc(obj)) {
+            if (!rb_proc_ractor_make_shareable_continue(obj, Qundef, data->chain)) {
+                rb_proc_t *proc = (rb_proc_t *)RTYPEDDATA_DATA(obj);
+                if (proc->block.type != block_type_iseq) rb_raise(rb_eRuntimeError, "not supported yet");
+
+                if (data->exception) {
+                    *data->exception = rb_exc_new3(rb_eRactorIsolationError, rb_sprintf("Proc's self is not shareable: %" PRIsVALUE, obj));
+                }
+                return traverse_stop;
+            }
+            return traverse_cont;
+        }
+        else {
+            return traverse_stop;
+        }
+    }
+
+    switch (TYPE(obj)) {
+      case T_IMEMO:
+        return traverse_skip;
+      case T_OBJECT:
+        break;
+      default:
+        break;
+    }
+
+    return traverse_cont;
+}
+
+static enum obj_traverse_iterator_result
+mark_warn_shareable(VALUE obj)
+{
+    ractor_warn_frozen_error_mark(obj);
+    return traverse_cont;
+}
+
 static enum obj_traverse_iterator_result
 mark_shareable(VALUE obj)
 {
@@ -1655,7 +1774,12 @@ rb_ractor_make_shareable(VALUE obj)
 {
     VALUE chain = Qnil;
     VALUE exception = Qfalse;
-    if (rb_obj_traverse(obj, make_shareable_check_shareable, null_leave, mark_shareable, &chain, &exception)) {
+    rb_obj_traverse_enter_func enter_func = ruby_ractor_warn_frozen_error ?
+        make_shareable_warn_check_shareable : make_shareable_check_shareable;
+    rb_obj_traverse_final_func final_func = ruby_ractor_warn_frozen_error ?
+        mark_warn_shareable : mark_shareable;
+
+    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));
         }
@@ -2235,7 +2359,11 @@ ractor_obj_clone(VALUE obj)
 static enum obj_traverse_iterator_result
 copy_enter(VALUE obj, struct obj_traverse_replace_data *data)
 {
-    if (rb_ractor_shareable_p(obj)) {
+    if (rb_ractor_warn_frozen_error_marked_p(obj)) {
+        data->replacement = ractor_obj_clone(obj);
+        return traverse_cont;
+    }
+    else if (rb_ractor_shareable_p(obj)) {
         data->replacement = obj;
         return traverse_skip;
     }
@@ -2914,4 +3042,17 @@ ractor_check_isolation_p(rb_execution_context_t *ec, VALUE self)
     return rb_thread_ractor_isolation_check_p() ? Qtrue : Qfalse;
 }
 
+static VALUE
+ractor_warn_frozen_error(rb_execution_context_t *ec, VALUE self)
+{
+    return ruby_ractor_warn_frozen_error ? Qtrue : Qfalse;
+}
+
+static VALUE
+ractor_warn_frozen_error_set(rb_execution_context_t *ec, VALUE self, VALUE enabled)
+{
+    ruby_ractor_warn_frozen_error = RTEST(enabled);
+    return enabled;
+}
+
 #include "ractor.rbinc"

ractor.rb

@@ -433,6 +433,10 @@ def self.shareable? obj
   # If +copy+ keyword is +true+, it will copy objects before freezing them, and will not
   # modify +obj+ or its internal objects.
   #
+  # If +Ractor.warn_frozen_error+ is enabled, this method records the reachable
+  # object graph for mutation warnings instead of freezing it or making it
+  # actually shareable. This mode is intended only for development sweeps.
+  #
   # Note that the specification and implementation of this method are not
   # mature and may be changed in the future.
   #
@@ -565,6 +569,37 @@ def self.check_isolation?
     Primitive.ractor_check_isolation_p
   end
 
+  # call-seq:
+  #   Ractor.warn_frozen_error -> true or false
+  #   Ractor.warn_frozen_error? -> true or false
+  #   Ractor.warn_frozen_error = flag -> flag
+  #
+  # When enabled, +Ractor.make_shareable+ records the reachable object graph as
+  # warning-shareable instead of freezing it or making it actually shareable
+  # between real ractors. Later attempts to mutate those objects emit a
+  # +:ractor_isolation+ category warning that identifies the operation that
+  # would have raised +FrozenError+, then allow the mutation to continue. This
+  # is intended for development sweeps alongside +Ractor.check_isolation+, so
+  # code can discover objects that would be frozen by production
+  # +make_shareable+ without changing runtime behaviour as much.
+  #
+  # The setting affects future +make_shareable+ calls. Objects already marked
+  # warning-shareable keep warning on mutation even if the setting is disabled.
+  # Suppress the warnings with +Warning[:ractor_isolation] = false+ or
+  # +-W:no-ractor_isolation+.
+  def self.warn_frozen_error
+    Primitive.ractor_warn_frozen_error
+  end
+
+  def self.warn_frozen_error=(flag)
+    Primitive.ractor_warn_frozen_error_set(flag)
+  end
+
+  # Returns true when Ractor.warn_frozen_error is enabled.
+  def self.warn_frozen_error?
+    Primitive.ractor_warn_frozen_error
+  end
+
   # internal method
   def self._require feature # :nodoc:
     if main?

ractor_core.h

@@ -172,6 +172,10 @@ RUBY_EXTERN bool ruby_ractor_isolation_check_enabled;
  * 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. */
+bool rb_ractor_warn_frozen_error_marked_p(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;

ractor_sync.c

@@ -777,7 +777,11 @@ ractor_prepare_payload(rb_execution_context_t *ec, VALUE obj, enum ractor_basket
       case basket_type_move:
         return ractor_move(obj);
       default:
-        if (rb_ractor_shareable_p(obj)) {
+        if (rb_ractor_warn_frozen_error_marked_p(obj)) {
+            *ptype = basket_type_copy;
+            return ractor_copy(obj);
+        }
+        else if (rb_ractor_shareable_p(obj)) {
             *ptype = basket_type_ref;
             return obj;
         }

string.c

@@ -2673,6 +2673,9 @@ str_modifiable(VALUE str)
         rb_check_lockedtmp(str);
         rb_check_frozen(str);
     }
+    else if (RB_UNLIKELY(ruby_ractor_warn_frozen_error_objects_enabled)) {
+        rb_check_frozen(str);
+    }
 }
 
 static inline int
@@ -2694,7 +2697,7 @@ str_independent(VALUE str)
 {
     RUBY_ASSERT(ruby_thread_has_gvl_p());
 
-    if (RB_UNLIKELY(FL_ANY_RAW(str, STR_DEPENDANT_MASK))) {
+    if (RB_UNLIKELY(FL_ANY_RAW(str, STR_DEPENDANT_MASK) || ruby_ractor_warn_frozen_error_objects_enabled)) {
         str_modifiable(str);
         return !str_dependent_p(str);
     }