Fix CI failures across Ruby versions and platforms

Three separate failures:

Ruby 2.6 and earlier have no rb_gc_mark_movable, rb_gc_location, or
dcompact field, so closure.c did not compile. Detect rb_gc_mark_movable
in extconf. Without it there is no compaction either, so plain marking
holds the reference in place and the compact callback can be omitted.

Ruby 3.1 and earlier spell GC.verify_compaction_references's
expand_heap: keyword as double_heap:, so the new test raised
ArgumentError there. Rescue and retry with the old spelling, and treat
a Ruby without compaction support as nothing to provoke.

expand_heap: doubles the heap, and the pages stay. That changes how
often the collector runs for the rest of the suite, and
test_no_memory_leak read the extra growth inside its measured block as
a leak on Linux. Run the compaction scenario in a separate process, so
the expansion dies with it. The subprocess still reports the fault: the
child dies with SIGSEGV when closure.c stores the closure address
without the mark and compact callbacks.

Author: jeremy

ext/fiddle/closure.c

@@ -55,6 +55,12 @@ closure_memsize(const void * ptr)
     return size;
 }
 
+/* Ruby 2.6 and earlier have no compaction, so marking the reference plainly
+ * holds it in place there. */
+#ifndef HAVE_RB_GC_MARK_MOVABLE
+# define rb_gc_mark_movable rb_gc_mark
+#endif
+
 /* Fiddle::Closure#free and initialize_rescue set the data pointer to NULL.
  * The garbage collector does not call these functions with a NULL pointer,
  * but this file is the only one in the extension that clears the pointer,
@@ -68,6 +74,7 @@ closure_mark(void *ptr)
     }
 }
 
+#ifdef HAVE_RB_GC_MARK_MOVABLE
 static void
 closure_compact(void *ptr)
 {
@@ -76,14 +83,17 @@ closure_compact(void *ptr)
         closure->self = rb_gc_location(closure->self);
     }
 }
+#endif
 
 const rb_data_type_t closure_data_type = {
     .wrap_struct_name = "fiddle/closure",
     .function = {
         .dmark = closure_mark,
         .dfree = dealloc,
         .dsize = closure_memsize,
-        .dcompact = closure_compact
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+        .dcompact = closure_compact,
+#endif
     },
     .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };

ext/fiddle/extconf.rb

@@ -241,6 +241,7 @@ def enable_debug_build_flag(flags)
 end
 
 have_func("rb_str_to_interned_str")
+have_func("rb_gc_mark_movable") # RUBY_VERSION >= 2.7
 have_const("RUBY_TYPED_EMBEDDABLE", "ruby.h") # RUBY_VERSION >= 3.3
 create_makefile 'fiddle' do |conf|
   if !libffi

test/fiddle/test_closure.rb

@@ -177,24 +177,47 @@ def test_call_after_compaction
         omit("Need GC.verify_compaction_references")
       end
       omit("Need CRuby") unless RUBY_ENGINE == "ruby"
+      require "envutil" unless defined?(EnvUtil)
 
-      closure_class = Class.new(Closure) do
-        def call(a, b)
-          a + b
+      # A separate process, because expand_heap: doubles the heap and the pages
+      # stay. Expanding this process's heap changes how often the collector runs
+      # afterwards, and test_no_memory_leak reads that as growth.
+      script = <<~'RUBY'
+        require "fiddle"
+
+        closure_class = Class.new(Fiddle::Closure) do
+          def call(a, b)
+            a + b
+          end
         end
-      end
 
-      # The closure must be reachable only through the heap. A local variable is
-      # pinned by the conservative machine-stack scan. A pinned closure does not
-      # move, and then this test cannot fail.
-      holder = [closure_class.new(TYPE_INT, [TYPE_INT, TYPE_INT])]
-      begin
-        GC.verify_compaction_references(expand_heap: true, toward: :empty)
-        func = Function.new(holder[0].to_i, [TYPE_INT, TYPE_INT], TYPE_INT)
-        assert_equal(42, func.call(40, 2))
-      ensure
+        # The closure must be reachable only through the heap. A local variable is
+        # pinned by the conservative machine-stack scan. A pinned closure does not
+        # move, and then this test cannot fail.
+        holder = [closure_class.new(Fiddle::TYPE_INT,
+                                    [Fiddle::TYPE_INT, Fiddle::TYPE_INT])]
+        begin
+          begin
+            GC.verify_compaction_references(expand_heap: true, toward: :empty)
+          rescue ArgumentError
+            # Ruby 3.1 and earlier spell expand_heap: as double_heap:
+            GC.verify_compaction_references(double_heap: true, toward: :empty)
+          end
+        rescue NotImplementedError
+          # A Ruby without compaction cannot move the closure. The call below
+          # still exercises the plain path.
+        end
+        func = Fiddle::Function.new(holder[0].to_i,
+                                    [Fiddle::TYPE_INT, Fiddle::TYPE_INT],
+                                    Fiddle::TYPE_INT)
+        puts(func.call(40, 2))
         holder[0].free
-      end
+      RUBY
+      load_path_args = $LOAD_PATH.flat_map {|path| ["-I", path]}
+      stdout, stderr, status = EnvUtil.invoke_ruby([*load_path_args, "-e", script],
+                                                   "", true, true)
+      assert(status.success?, stderr)
+      assert_equal("42", stdout.chomp)
     end
 
     def test_ractor_shareable