Run user #freeze side effects under Ractor.warn_frozen_error

Real Ractor.make_shareable freezes objects, which runs any user-defined
#freeze. Some classes rely on that to migrate mutable state into
Ractor-local storage on freeze (e.g. ActiveSupport::CachingKeyGenerator,
which moves its cache into Ractor[] and nils the ivar in #freeze).

Ractor.warn_frozen_error mode deliberately does not freeze objects so a
program can keep running and report every would-be FrozenError instead of
crashing. But because it never froze, it also never ran those #freeze
methods, so such objects never set themselves up and emitted spurious
"would raise FrozenError" warnings even though they are Ractor-safe.

Resolve the chicken-and-egg by invoking #freeze for its side effects while
intercepting the actual freeze so the object is only marked, never frozen:

- make_shareable_warn_check_shareable now invokes a non-default #freeze on
  T_OBJECTs before marking/descending, so the method's own setup writes are
  not reported and any state it moves out of the object graph is neither
  walked nor marked. An in-flight guard breaks recursion when #freeze calls
  Ractor.make_shareable(self).
- rb_obj_freeze records the object for mutation warnings instead of setting
  FL_FREEZE while ruby_ractor_warn_freeze_as_mark is set (scoped to the
  traversal), so super inside a user #freeze marks instead of freezes.

Genuine unsafe mutations still warn; the object stays unfrozen.

Assisted-By: devx/e2120fdf-5247-4bd8-86e5-49513fcb7cda

Author: Edouard-chin

include/ruby/internal/intern/error.h

@@ -209,6 +209,16 @@ void rb_error_frozen_object(VALUE what);
  */
 RUBY_EXTERN bool ruby_ractor_warn_frozen_error_objects_enabled;
 
+/**
+ * True while Ractor.make_shareable (under Ractor.warn_frozen_error) is running
+ * an object's user-defined #freeze for its side effects. While set, rb_obj_freeze
+ * records the object for mutation warnings instead of actually freezing it, so
+ * the program can keep running and reporting warnings end to end.
+ *
+ * @internal
+ */
+RUBY_EXTERN bool ruby_ractor_warn_freeze_as_mark;
+
 /**
  * Emits a warning and returns true if +obj+ was recorded for Ractor
  * shareability while Ractor.warn_frozen_error was enabled.
@@ -217,6 +227,14 @@ RUBY_EXTERN bool ruby_ractor_warn_frozen_error_objects_enabled;
  */
 bool rb_ractor_warn_frozen_error_warn(VALUE obj);
 
+/**
+ * Records +obj+ so that subsequent mutations are reported as would-be
+ * FrozenError warnings under Ractor.warn_frozen_error, without freezing it.
+ *
+ * @internal
+ */
+void rb_ractor_warn_frozen_error_mark(VALUE obj);
+
 /**
  * Queries  if the  passed  object is  frozen.
  *

object.c

@@ -1375,6 +1375,14 @@ rb_obj_dummy1(VALUE _x, VALUE _y)
 VALUE
 rb_obj_freeze(VALUE obj)
 {
+    if (RB_UNLIKELY(ruby_ractor_warn_freeze_as_mark) && !SPECIAL_CONST_P(obj)) {
+        /* Ractor.warn_frozen_error mode is invoking this object's #freeze for
+         * its Ractor setup side effects. We must not actually freeze it, so a
+         * full request can keep running and reporting warnings; just record it
+         * so later mutations are reported as would-be FrozenError. */
+        rb_ractor_warn_frozen_error_mark(obj);
+        return obj;
+    }
     if (!OBJ_FROZEN(obj)) {
         OBJ_FREEZE(obj);
         if (SPECIAL_CONST_P(obj)) {

ractor.c

@@ -18,6 +18,7 @@
 #include "internal/struct.h"
 #include "internal/st.h"
 #include "internal/thread.h"
+#include "internal/vm.h"
 #include "variable.h"
 #include "yjit.h"
 #include "zjit.h"
@@ -1290,6 +1291,37 @@ rb_ractor_warn_frozen_error_mark(VALUE obj)
     ruby_ractor_warn_frozen_error_objects_enabled = true;
 }
 
+/* Set while we invoke a user-defined #freeze during warn-mode make_shareable.
+ * rb_obj_freeze() checks this and records the object for mutation warnings
+ * instead of actually freezing it (see object.c). */
+bool ruby_ractor_warn_freeze_as_mark = false;
+
+/* Objects whose #freeze is currently being invoked by warn-mode make_shareable.
+ * Used to break recursion when an object's #freeze calls Ractor.make_shareable
+ * on itself (in real mode the object would already be frozen/shareable and be
+ * skipped; in warn mode it never freezes, so we need an explicit guard). */
+static VALUE ractor_warn_freeze_inflight = Qnil;
+
+static VALUE
+ractor_warn_freeze_inflight_hash(void)
+{
+    if (NIL_P(ractor_warn_freeze_inflight)) {
+        ractor_warn_freeze_inflight = rb_ident_hash_new();
+        rb_obj_hide(ractor_warn_freeze_inflight);
+        rb_gc_register_mark_object(ractor_warn_freeze_inflight);
+    }
+    return ractor_warn_freeze_inflight;
+}
+
+static bool
+ractor_warn_freeze_inflight_p(VALUE obj)
+{
+    if (NIL_P(ractor_warn_freeze_inflight)) {
+        return false;
+    }
+    return RTEST(rb_hash_lookup2(ractor_warn_freeze_inflight, obj, Qfalse));
+}
+
 /// traverse function
 
 // 2: stop search
@@ -1711,6 +1743,34 @@ make_shareable_warn_check_shareable(VALUE obj, struct obj_traverse_data *data)
     else if (rb_ractor_warn_frozen_error_marked_p(obj)) {
         return traverse_skip;
     }
+    else if (ractor_warn_freeze_inflight_p(obj)) {
+        /* We are already inside this object's #freeze (reached again via a
+         * re-entrant Ractor.make_shareable). Skip to break the recursion; the
+         * outer traversal will finish walking its children. */
+        return traverse_skip;
+    }
+
+    /* Real Ractor.make_shareable freezes objects, which runs any user-defined
+     * #freeze and lets classes migrate mutable state into Ractor-local storage
+     * (e.g. ActiveSupport::CachingKeyGenerator). Warn mode must not freeze, so
+     * we invoke #freeze here for its side effects while rb_obj_freeze is
+     * intercepted (ruby_ractor_warn_freeze_as_mark) to only record the object.
+     * Running #freeze *before* marking obj means #freeze's own setup writes are
+     * not reported, and running it *before* descending means state it moves out
+     * of the object graph is neither walked nor marked -- so it stops the
+     * spurious warnings without ever freezing anything. */
+    if (BUILTIN_TYPE(obj) == T_OBJECT &&
+            !RB_OBJ_FROZEN_RAW(obj) &&
+            !rb_method_basic_definition_p(CLASS_OF(obj), idFreeze)) {
+        struct rescue_freeze_data rescue_freeze_data = { 0 };
+        bool prev = ruby_ractor_warn_freeze_as_mark;
+
+        rb_hash_aset(ractor_warn_freeze_inflight_hash(), obj, Qtrue);
+        ruby_ractor_warn_freeze_as_mark = true;
+        rb_rescue(try_freeze, obj, rescue_freeze, (VALUE)&rescue_freeze_data);
+        ruby_ractor_warn_freeze_as_mark = prev;
+        rb_hash_delete(ractor_warn_freeze_inflight_hash(), obj);
+    }
 
     /* Mark on entry, not as a finalizer, so recursive warning-mode
      * make_shareable calls that come from Proc self / outer-variable checks

test/ruby/test_ractor.rb

@@ -783,6 +783,96 @@ def test_warn_frozen_error_marks_shareable_proc_self_without_freezing
     RUBY
   end
 
+  def test_warn_frozen_error_runs_custom_freeze_side_effects_without_freezing
+    # Real Ractor.make_shareable freezes objects, which runs any user-defined
+    # #freeze. Some classes rely on that to migrate mutable state into
+    # Ractor-local storage on freeze (e.g. ActiveSupport::CachingKeyGenerator).
+    # Warn mode must not freeze, but it must still run #freeze for its side
+    # effects, otherwise those objects never set themselves up and emit
+    # spurious FrozenError warnings even though they are Ractor-safe.
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+
+        klass = Class.new do
+          def initialize
+            @cache = {}
+            @ractor_key = nil
+          end
+
+          def freeze
+            @ractor_key = "_klass_cache_#{object_id}".to_sym
+            Ractor[@ractor_key] = @cache
+            @cache = nil
+            super
+          end
+
+          def store(k, v)
+            cache[k] = v
+          end
+
+          private
+
+          def cache
+            @cache || (Ractor[@ractor_key] ||= {})
+          end
+        end
+
+        obj = klass.new
+        Ractor.make_shareable(obj)
+
+        # #freeze ran (state migrated) but the object was not actually frozen.
+        assert_equal false, obj.frozen?
+        assert_nil obj.instance_variable_get(:@cache)
+        refute_nil obj.instance_variable_get(:@ractor_key)
+
+        # The migrated-away cache is not part of the object graph any more, so
+        # it was never marked: writing to it must NOT warn.
+        assert_warning("") do
+          obj.store(:a, 1)
+        end
+      ensure
+        Ractor.warn_frozen_error = old
+      end
+    RUBY
+  end
+
+  def test_warn_frozen_error_custom_freeze_calling_make_shareable_on_self
+    # A #freeze that re-enters Ractor.make_shareable(self) must not recurse
+    # forever: in real mode the object would already be frozen/shareable and be
+    # skipped, but in warn mode it never freezes, so make_shareable relies on an
+    # explicit in-flight guard to break the recursion.
+    assert_ractor(<<~'RUBY')
+      old = Ractor.warn_frozen_error
+      begin
+        Ractor.warn_frozen_error = true
+
+        klass = Class.new do
+          attr_reader :froze
+          def freeze
+            @froze = true
+            Ractor.make_shareable(self)
+            super
+          end
+        end
+
+        obj = klass.new
+        assert_nothing_raised do
+          Ractor.make_shareable(obj)
+        end
+        assert_equal true, obj.froze
+        assert_equal false, obj.frozen?
+
+        assert_warning(/would raise FrozenError/) do
+          obj.instance_variable_set(:@mutated, true)
+        end
+      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