ZJIT: Move JIT code tests from test_zjit.rb to Rust (#16130)

1 files changed, 0 insertions, 4494 deletions

diff --git a/test/ruby/test_zjit.rb b/test/ruby/test_zjit.rb
index 095b690c7b..333e34e927 100644
--- a/test/ruby/test_zjit.rb
+++ b/test/ruby/test_zjit.rb
@@ -112,167 +112,6 @@ class TestZJIT < Test::Unit::TestCase
     RUBY
   end
 
-  def test_call_itself
-    assert_compiles '42', <<~RUBY, call_threshold: 2
-      def test = 42.itself
-      test
-      test
-    RUBY
-  end
-
-  def test_nil
-    assert_compiles 'nil', %q{
-      def test = nil
-      test
-    }
-  end
-
-  def test_putobject
-    assert_compiles '1', %q{
-      def test = 1
-      test
-    }
-  end
-
-  def test_putstring
-    assert_compiles '""', %q{
-      def test = "#{""}"
-      test
-    }, insns: [:putstring]
-  end
-
-  def test_putchilldedstring
-    assert_compiles '""', %q{
-      def test = ""
-      test
-    }, insns: [:putchilledstring]
-  end
-
-  def test_leave_param
-    assert_compiles '5', %q{
-      def test(n) = n
-      test(5)
-    }
-  end
-
-  def test_getglobal_with_warning
-    assert_compiles('"rescued"', %q{
-      Warning[:deprecated] = true
-
-      module Warning
-        def warn(message)
-          raise
-        end
-      end
-
-      def test
-        $=
-      rescue
-        "rescued"
-      end
-
-      $VERBOSE = true
-      test
-    }, insns: [:getglobal])
-  end
-
-  def test_setglobal
-    assert_compiles '1', %q{
-      def test
-        $a = 1
-        $a
-      end
-
-      test
-    }, insns: [:setglobal]
-  end
-
-  def test_string_intern
-    assert_compiles ':foo123', %q{
-      def test
-        :"foo#{123}"
-      end
-
-      test
-    }, insns: [:intern]
-  end
-
-  def test_duphash
-    assert_compiles '{a: 1}', %q{
-      def test
-        {a: 1}
-      end
-
-      test
-    }, insns: [:duphash]
-  end
-
-  def test_pushtoarray
-    assert_compiles '[1, 2, 3]', %q{
-      def test
-        [*[], 1, 2, 3]
-      end
-      test
-    }, insns: [:pushtoarray]
-  end
-
-  def test_splatarray_new_array
-    assert_compiles '[1, 2, 3]', %q{
-      def test a
-        [*a, 3]
-      end
-      test [1, 2]
-    }, insns: [:splatarray]
-  end
-
-  def test_splatarray_existing_array
-    assert_compiles '[1, 2, 3]', %q{
-      def foo v
-        [1, 2, v]
-      end
-      def test a
-        foo(*a)
-      end
-      test [3]
-    }, insns: [:splatarray]
-  end
-
-  def test_concattoarray
-    assert_compiles '[1, 2, 3]', %q{
-      def test(*a)
-        [1, 2, *a]
-      end
-      test 3
-    }, insns: [:concattoarray]
-  end
-
-  def test_definedivar
-    assert_compiles '[nil, "instance-variable", nil]', %q{
-      def test
-        v0 = defined?(@a)
-        @a = nil
-        v1 = defined?(@a)
-        remove_instance_variable :@a
-        v2 = defined?(@a)
-        [v0, v1, v2]
-      end
-      test
-    }, insns: [:definedivar]
-  end
-
-  def test_setglobal_with_trace_var_exception
-    assert_compiles '"rescued"', %q{
-      def test
-        $a = 1
-      rescue
-        "rescued"
-      end
-
-      trace_var(:$a) { raise }
-      test
-    }, insns: [:setglobal]
-  end
-
   def test_toplevel_binding
     # Not using assert_compiles, which doesn't use the toplevel frame for `test_script`.
     out, err, status = eval_with_jit(%q{
@@ -286,391 +125,6 @@ class TestZJIT < Test::Unit::TestCase
     assert_equal "[1, 3, 4]", out
   end
 
-  def test_toplevel_local_after_eval
-    # Not using assert_compiles, which doesn't use the toplevel frame for `test_script`.
-    out, err, status = eval_with_jit(%q{
-      a = 1
-      b = 2
-      eval('b = 3')
-      c = 4
-      print [a, b, c]
-    })
-    assert_success(out, err, status)
-    assert_equal "[1, 3, 4]", out
-  end
-
-  def test_getlocal_after_eval
-    assert_compiles '2', %q{
-      def test
-        a = 1
-        eval('a = 2')
-        a
-      end
-      test
-    }
-  end
-
-  def test_getlocal_after_instance_eval
-    assert_compiles '2', %q{
-      def test
-        a = 1
-        instance_eval('a = 2')
-        a
-      end
-      test
-    }
-  end
-
-  def test_getlocal_after_module_eval
-    assert_compiles '2', %q{
-      def test
-        a = 1
-        Kernel.module_eval('a = 2')
-        a
-      end
-      test
-    }
-  end
-
-  def test_getlocal_after_class_eval
-    assert_compiles '2', %q{
-      def test
-        a = 1
-        Kernel.class_eval('a = 2')
-        a
-      end
-      test
-    }
-  end
-
-  def test_setlocal
-    assert_compiles '3', %q{
-      def test(n)
-        m = n
-        m
-      end
-      test(3)
-    }
-  end
-
-  def test_return_nonparam_local
-    # Use dead code (if false) to create a local without initialization instructions.
-    assert_compiles 'nil', %q{
-      def foo(a)
-        if false
-          x = nil
-        end
-        x
-      end
-      def test = foo(1)
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_nonparam_local_nil_in_jit_call
-    # Non-parameter locals must be initialized to nil in JIT-to-JIT calls.
-    # Use dead code (if false) to create locals without initialization instructions.
-    # Then eval a string that accesses the uninitialized locals.
-    assert_compiles '["x", "x", "x", "x"]', %q{
-      def f(a)
-        a ||= 1
-        if false; b = 1; end
-        eval("-> { p 'x#{b}' }")
-      end
-
-      4.times.map { f(1).call }
-    }, call_threshold: 2
-  end
-
-  def test_kwargs_with_exit_and_local_invalidation
-    assert_compiles ':ok', %q{
-      def a(b:, c:)
-        if c == :b
-          return -> {}
-        end
-        Class # invalidate locals
-
-        raise "c is :b!" if c == :b
-      end
-
-      def test
-        # note opposite order of kwargs
-        a(c: :c, b: :b)
-      end
-
-      4.times { test }
-      :ok
-    }, call_threshold: 2
-  end
-
-  def test_kwargs_with_max_direct_send_arg_count
-    # Ensure that we only reorder the args when we _can_ use direct send (< 6 args).
-    assert_compiles '[[1, 2, 3, 4, 5, 6, 7, 8]]', %q{
-      def kwargs(five, six, a:, b:, c:, d:, e:, f:)
-        [a, b, c, d, five, six, e, f]
-      end
-
-      5.times.flat_map do
-        [
-          kwargs(5, 6, d: 4, c: 3, a: 1, b: 2, e: 7, f: 8),
-          kwargs(5, 6, d: 4, c: 3, b: 2, a: 1, e: 7, f: 8)
-        ]
-      end.uniq
-    }, call_threshold: 2
-  end
-
-  def test_setlocal_on_eval
-    assert_compiles '1', %q{
-      @b = binding
-      eval('a = 1', @b)
-      eval('a', @b)
-    }
-  end
-
-  def test_optional_arguments
-    assert_compiles '[[1, 2, 3], [10, 20, 3], [100, 200, 300]]', %q{
-      def test(a, b = 2, c = 3)
-        [a, b, c]
-      end
-      [test(1), test(10, 20), test(100, 200, 300)]
-    }
-  end
-
-  def test_optional_arguments_setlocal
-    assert_compiles '[[2, 2], [1, nil]]', %q{
-      def test(a = (b = 2))
-        [a, b]
-      end
-      [test, test(1)]
-    }
-  end
-
-  def test_optional_arguments_cyclic
-    assert_compiles '[nil, 1]', %q{
-      test = proc { |a=a| a }
-      [test.call, test.call(1)]
-    }
-  end
-
-  def test_optional_arguments_side_exit
-    # This leads to FailedOptionalArguments, so not using assert_compiles
-    assert_runs '[:foo, nil, 1]', %q{
-      def test(a = (def foo = nil)) = a
-      [test, (undef :foo), test(1)]
-    }
-  end
-
-  def test_getblockparamproxy
-    assert_compiles '1', %q{
-      def test(&block)
-        0.then(&block)
-      end
-      test { 1 }
-    }, insns: [:getblockparamproxy]
-  end
-
-  def test_getblockparam
-    assert_compiles '2', %q{
-      def test(&blk)
-        blk
-      end
-      test { 2 }.call
-      test { 2 }.call
-    }, insns: [:getblockparam]
-  end
-
-  def test_getblockparam_proxy_side_exit_restores_block_local
-    assert_compiles '2', %q{
-      def test(&block)
-        b = block
-        # sideexits here
-        raise "test" unless block
-        b ? 2 : 3
-      end
-      test {}
-      test {}
-    }, insns: [:getblockparam, :getblockparamproxy]
-  end
-
-  def test_getblockparam_used_twice_in_args
-    assert_compiles '1', %q{
-      def f(*args) = args
-      def test(&blk)
-        b = blk
-        f(*[1], blk)
-        blk
-      end
-      test {1}.call
-      test {1}.call
-    }, insns: [:getblockparam]
-  end
-
-  def test_optimized_method_call_proc_call
-    assert_compiles '2', %q{
-      p = proc { |x| x * 2 }
-      def test(p)
-        p.call(1)
-      end
-      test(p)
-      test(p)
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_optimized_method_call_proc_aref
-    assert_compiles '4', %q{
-      p = proc { |x| x * 2 }
-      def test(p)
-        p[2]
-      end
-      test(p)
-      test(p)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_optimized_method_call_proc_yield
-    assert_compiles '6', %q{
-      p = proc { |x| x * 2 }
-      def test(p)
-        p.yield(3)
-      end
-      test(p)
-      test(p)
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_optimized_method_call_proc_kw_splat
-    assert_compiles '3', %q{
-      p = proc { |**kw| kw[:a] + kw[:b] }
-      def test(p, h)
-        p.call(**h)
-      end
-      h = { a: 1, b: 2 }
-      test(p, h)
-      test(p, h)
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_optimized_method_call_proc_call_splat
-    assert_compiles '43', %q{
-      p = proc { |x| x + 1 }
-      def test(p)
-        ary = [42]
-        p.call(*ary)
-      end
-      test(p)
-      test(p)
-    }, call_threshold: 2
-  end
-
-  def test_optimized_method_call_proc_call_kwarg
-    assert_compiles '1', %q{
-      p = proc { |a:| a }
-      def test(p)
-        p.call(a: 1)
-      end
-      test(p)
-      test(p)
-    }, call_threshold: 2
-  end
-
-  def test_call_a_forwardable_method
-    assert_runs '[]', %q{
-      def test_root = forwardable
-      def forwardable(...) = Array.[](...)
-      test_root
-      test_root
-    }, call_threshold: 2
-  end
-
-  def test_setlocal_on_eval_with_spill
-    assert_compiles '1', %q{
-      @b = binding
-      eval('a = 1; itself', @b)
-      eval('a', @b)
-    }
-  end
-
-  def test_nested_local_access
-    assert_compiles '[1, 2, 3]', %q{
-      1.times do |l2|
-        1.times do |l1|
-          define_method(:test) do
-            l1 = 1
-            l2 = 2
-            l3 = 3
-            [l1, l2, l3]
-          end
-        end
-      end
-
-      test
-      test
-      test
-    }, call_threshold: 3, insns: [:getlocal, :setlocal, :getlocal_WC_0, :setlocal_WC_1]
-  end
-
-  def test_send_with_local_written_by_blockiseq
-    assert_compiles '[1, 2]', %q{
-      def test
-        l1 = nil
-        l2 = nil
-        tap do |_|
-          l1 = 1
-          tap do |_|
-            l2 = 2
-          end
-        end
-
-        [l1, l2]
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_without_block
-    assert_compiles '[1, 2, 3]', %q{
-      def foo = 1
-      def bar(a) = a - 1
-      def baz(a, b) = a - b
-
-      def test1 = foo
-      def test2 = bar(3)
-      def test3 = baz(4, 1)
-
-      [test1, test2, test3]
-    }
-  end
-
-  def test_send_with_six_args
-    assert_compiles '[1, 2, 3, 4, 5, 6]', %q{
-      def foo(a1, a2, a3, a4, a5, a6)
-        [a1, a2, a3, a4, a5, a6]
-      end
-
-      def test
-        foo(1, 2, 3, 4, 5, 6)
-      end
-
-      test # profile send
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_on_heap_object_in_spilled_arg
-    # This leads to a register spill, so not using `assert_compiles`
-    assert_runs 'Hash', %q{
-      def entry(a1, a2, a3, a4, a5, a6, a7, a8, a9)
-        a9.itself.class
-      end
-
-      entry(1, 2, 3, 4, 5, 6, 7, 8, {}) # profile
-      entry(1, 2, 3, 4, 5, 6, 7, 8, {})
-    }, call_threshold: 2
-  end
-
   def test_send_exit_with_uninitialized_locals
     assert_runs 'nil', %q{
       def entry(init)
@@ -687,1467 +141,6 @@ class TestZJIT < Test::Unit::TestCase
     }, call_threshold: 2, allowed_iseqs: 'entry@-e:2'
   end
 
-  def test_send_optional_arguments
-    assert_compiles '[[1, 2], [3, 4]]', %q{
-      def test(a, b = 2) = [a, b]
-      def entry = [test(1), test(3, 4)]
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_nil_block_arg
-    assert_compiles 'false', %q{
-      def test = block_given?
-      def entry = test(&nil)
-      test
-    }
-  end
-
-  def test_send_symbol_block_arg
-    assert_compiles '["1", "2"]', %q{
-      def test = [1, 2].map(&:to_s)
-      test
-    }
-  end
-
-  def test_send_variadic_with_block
-    assert_compiles '[[1, "a"], [2, "b"], [3, "c"]]', %q{
-      A = [1, 2, 3]
-      B = ["a", "b", "c"]
-
-      def test
-        result = []
-        A.zip(B) { |x, y| result << [x, y] }
-        result
-      end
-
-      test; test
-    }, call_threshold: 2
-  end
-
-  def test_send_splat
-    assert_runs '[1, 2]', %q{
-      def test(a, b) = [a, b]
-      def entry(arr) = test(*arr)
-      entry([1, 2])
-    }
-  end
-
-  def test_send_kwarg
-    assert_runs '[1, 2]', %q{
-      def test(a:, b:) = [a, b]
-      def entry = test(b: 2, a: 1) # change order
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_optional
-    assert_compiles '[1, 2]', %q{
-      def test(a: 1, b: 2) = [a, b]
-      def entry = test
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_optional_too_many
-    assert_compiles '[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]', %q{
-      def test(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10) = [a, b, c, d, e, f, g, h, i, j]
-      def entry = test
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_required_and_optional
-    assert_compiles '[3, 2]', %q{
-      def test(a:, b: 2) = [a, b]
-      def entry = test(a: 3)
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_to_hash
-    assert_compiles '{a: 3}', %q{
-      def test(hash) = hash
-      def entry = test(a: 3)
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_to_ccall
-    assert_compiles '["a", "b", "c"]', %q{
-      def test(s) = s.each_line(chomp: true).to_a
-      def entry = test(%(a\nb\nc))
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_and_block_to_ccall
-    assert_compiles '["a", "b", "c"]', %q{
-      def test(s)
-        a = []
-        s.each_line(chomp: true) { |l| a << l }
-        a
-      end
-      def entry = test(%(a\nb\nc))
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_with_too_many_args_to_c_call
-    assert_compiles '"a b c d {kwargs: :e}"', %q{
-      def test(a:, b:, c:, d:, e:) = sprintf("%s %s %s %s %s", a, b, c, d, kwargs: e)
-      def entry = test(e: :e, d: :d, c: :c, a: :a, b: :b)
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwsplat
-    assert_compiles '3', %q{
-      def test(a:) = a
-      def entry = test(**{a: 3})
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwrest
-    assert_compiles '{a: 3}', %q{
-      def test(**kwargs) = kwargs
-      def entry = test(a: 3)
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_req_kwreq
-    assert_compiles '[1, 3]', %q{
-      def test(a, c:) = [a, c]
-      def entry = test(1, c: 3)
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_req_opt_kwreq
-    assert_compiles '[[1, 2, 3], [-1, -2, -3]]', %q{
-      def test(a, b = 2, c:) = [a, b, c]
-      def entry = [test(1, c: 3), test(-1, -2, c: -3)] # specify all, change kw order
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_req_opt_kwreq_kwopt
-    assert_compiles '[[1, 2, 3, 4], [-1, -2, -3, -4]]', %q{
-      def test(a, b = 2, c:, d: 4) = [a, b, c, d]
-      def entry = [test(1, c: 3), test(-1, -2, d: -4, c: -3)] # specify all, change kw order
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_unexpected_keyword
-    assert_compiles ':error', %q{
-      def test(a: 1) = a*2
-      def entry
-        test(z: 2)
-      rescue ArgumentError
-        :error
-      end
-
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_pos_optional_with_maybe_too_many_args
-    assert_compiles '[[1, 2, 3, 4, 5, 6], [10, 20, 30, 4, 5, 6], [10, 20, 30, 40, 50, 60]]', %q{
-      def target(a = 1, b = 2, c = 3, d = 4, e = 5, f:) = [a, b, c, d, e, f]
-      def test = [target(f: 6), target(10, 20, 30, f: 6), target(10, 20, 30, 40, 50, f: 60)]
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_partial_optional
-    assert_compiles '[[1, 2, 3], [1, 20, 3], [10, 2, 30]]', %q{
-      def test(a: 1, b: 2, c: 3) = [a, b, c]
-      def entry = [test, test(b: 20), test(c: 30, a: 10)]
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_optional_a_lot
-    assert_compiles '[[1, 2, 3, 4, 5, 6], [1, 2, 3, 7, 8, 9], [2, 4, 6, 8, 10, 12]]', %q{
-      def test(a: 1, b: 2, c: 3, d: 4, e: 5, f: 6) = [a, b, c, d, e, f]
-      def entry = [test, test(d: 7, f: 9, e: 8), test(f: 12, e: 10, d: 8, c: 6, b: 4, a: 2)]
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_non_constant_default
-    assert_compiles '[[1, 2], [10, 2]]', %q{
-      def make_default = 2
-      def test(a: 1, b: make_default) = [a, b]
-      def entry = [test, test(a: 10)]
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_kwarg_optional_static_with_side_exit
-    # verify frame reconstruction with synthesized keyword defaults is correct
-    assert_compiles '[10, 2, 10]', %q{
-      def callee(a: 1, b: 2)
-        # use binding to force side-exit
-        x = binding.local_variable_get(:a)
-        [a, b, x]
-      end
-
-      def entry
-        callee(a: 10) # b should get default value
-      end
-
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_all_arg_types
-    assert_compiles '[:req, :opt, :post, :kwr, :kwo, true]', %q{
-      def test(a, b = :opt, c, d:, e: :kwo) = [a, b, c, d, e, block_given?]
-      def entry = test(:req, :post, d: :kwr) {}
-      entry
-      entry
-    }, call_threshold: 2
-  end
-
-  def test_send_ccall_variadic_with_different_receiver_classes
-    assert_compiles '[true, true]', %q{
-      def test(obj) = obj.start_with?("a")
-      [test("abc"), test(:abc)]
-    }, call_threshold: 2
-  end
-
-  def test_forwardable_iseq
-    assert_compiles '1', %q{
-      def test(...) = 1
-      test
-    }
-  end
-
-  def test_sendforward
-    assert_compiles '[1, 2]', %q{
-      def callee(a, b) = [a, b]
-      def test(...) = callee(...)
-      test(1, 2)
-    }, insns: [:sendforward]
-  end
-
-  def test_iseq_with_optional_arguments
-    assert_compiles '[[1, 2], [3, 4]]', %q{
-      def test(a, b = 2) = [a, b]
-      [test(1), test(3, 4)]
-    }
-  end
-
-  def test_invokesuper
-    assert_compiles '[6, 60]', %q{
-      class Foo
-        def foo(a) = a + 1
-        def bar(a) = a + 10
-      end
-
-      class Bar < Foo
-        def foo(a) = super(a) + 2
-        def bar(a) = super + 20
-      end
-
-      bar = Bar.new
-      [bar.foo(3), bar.bar(30)]
-    }
-  end
-
-  def test_invokesuper_with_local_written_by_blockiseq
-    # Using `assert_runs` because we don't compile invokeblock yet
-    assert_runs '3', %q{
-      class Foo
-        def test
-          yield
-        end
-      end
-
-      class Bar < Foo
-        def test
-          a = 1
-          super do
-            a += 2
-          end
-          a
-        end
-      end
-
-      Bar.new.test
-    }
-  end
-
-  def test_invokesuper_to_iseq
-    assert_compiles '["B", "A"]', %q{
-      class A
-        def foo
-          "A"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]
-        end
-      end
-
-      def test
-        B.new.foo
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_args
-    assert_compiles '["B", 11]', %q{
-      class A
-        def foo(x)
-          x * 2
-        end
-      end
-
-      class B < A
-        def foo(x)
-          ["B", super(x) + 1]
-        end
-      end
-
-      def test
-        B.new.foo(5)
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test super with explicit args when callee has rest parameter.
-  # This should fall back to dynamic dispatch since we can't handle rest params yet.
-  def test_invokesuper_with_args_to_rest_param
-    assert_compiles '["B", "a", ["b", "c"]]', %q{
-      class A
-        def foo(x, *rest)
-          [x, rest]
-        end
-      end
-
-      class B < A
-        def foo(x, y, z)
-          ["B", *super(x, y, z)]
-        end
-      end
-
-      def test
-        B.new.foo("a", "b", "c")
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_block
-    assert_compiles '["B", "from_block"]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no_block"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super { "from_block" }]
-        end
-      end
-
-      def test
-        B.new.foo
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_to_cfunc_no_args
-    assert_compiles '["MyString", 3]', %q{
-      class MyString < String
-        def length
-          ["MyString", super]
-        end
-      end
-
-      def test
-        MyString.new("abc").length
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_to_cfunc_simple_args
-    assert_compiles '["MyString", true]', %q{
-      class MyString < String
-        def include?(other)
-          ["MyString", super(other)]
-        end
-      end
-
-      def test
-        MyString.new("abc").include?("bc")
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-
-  def test_invokesuper_to_cfunc_with_optional_arg
-    assert_compiles '["MyString", 6]', %q{
-      class MyString < String
-        def byteindex(needle, offset = 0)
-          ["MyString", super(needle, offset)]
-        end
-      end
-
-      def test
-        MyString.new("hello world").byteindex("world")
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_to_cfunc_varargs
-    assert_compiles '["MyString", true]', %q{
-      class MyString < String
-        def end_with?(str)
-          ["MyString", super(str)]
-        end
-      end
-
-      def test
-        MyString.new("abc").end_with?("bc")
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_multilevel
-    assert_compiles '["C", ["B", "A"]]', %q{
-      class A
-        def foo
-          "A"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]
-        end
-      end
-
-      class C < B
-        def foo
-          ["C", super]
-        end
-      end
-
-      def test
-        C.new.foo
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test implicit block forwarding - super without explicit block should forward caller's block
-  # Note: We call test twice to ensure ZJIT compiles it before the final call that we check
-  def test_invokesuper_forwards_block_implicitly
-    assert_compiles '["B", "forwarded_block"]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no_block"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]  # should forward the block from caller
-        end
-      end
-
-      def test
-        B.new.foo { "forwarded_block" }
-      end
-
-      test  # profile invokesuper
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test implicit block forwarding with explicit arguments
-  def test_invokesuper_forwards_block_implicitly_with_args
-    assert_compiles '["B", ["arg_value", "forwarded"]]', %q{
-      class A
-        def foo(x)
-          [x, (block_given? ? yield : "no_block")]
-        end
-      end
-
-      class B < A
-        def foo(x)
-          ["B", super(x)]  # explicit args, but block should still be forwarded
-        end
-      end
-
-      def test
-        B.new.foo("arg_value") { "forwarded" }
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test implicit block forwarding when no block is given (should not fail)
-  def test_invokesuper_forwards_block_implicitly_no_block_given
-    assert_compiles '["B", "no_block"]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no_block"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]  # no block given by caller
-        end
-      end
-
-      def test
-        B.new.foo  # called without a block
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test implicit block forwarding through multiple inheritance levels
-  def test_invokesuper_forwards_block_implicitly_multilevel
-    assert_compiles '["C", ["B", "deep_block"]]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no_block"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]  # forwards block to A
-        end
-      end
-
-      class C < B
-        def foo
-          ["C", super]  # forwards block to B, which forwards to A
-        end
-      end
-
-      def test
-        C.new.foo { "deep_block" }
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test implicit block forwarding with block parameter syntax
-  def test_invokesuper_forwards_block_param
-    assert_compiles '["B", "block_param_forwarded"]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no_block"
-        end
-      end
-
-      class B < A
-        def foo(&block)
-          ["B", super]  # should forward &block implicitly
-        end
-      end
-
-      def test
-        B.new.foo { "block_param_forwarded" }
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_blockarg
-    assert_compiles '["B", "different block"]', %q{
-      class A
-        def foo
-          block_given? ? yield : "no block"
-        end
-      end
-
-      class B < A
-        def foo(&blk)
-          other_block = proc { "different block" }
-          ["B", super(&other_block)]
-        end
-      end
-
-      def test
-        B.new.foo { "passed block" }
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_symbol_to_proc
-    assert_compiles '["B", [3, 5, 7]]', %q{
-      class A
-        def foo(items, &blk)
-          items.map(&blk)
-        end
-      end
-
-      class B < A
-        def foo(items)
-          ["B", super(items, &:succ)]
-        end
-      end
-
-      def test
-        B.new.foo([2, 4, 6])
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_splat
-    assert_compiles '["B", 6]', %q{
-      class A
-        def foo(a, b, c)
-          a + b + c
-        end
-      end
-
-      class B < A
-        def foo(*args)
-          ["B", super(*args)]
-        end
-      end
-
-      def test
-        B.new.foo(1, 2, 3)
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_kwargs
-    assert_compiles '["B", "x=1, y=2"]', %q{
-      class A
-        def foo(x:, y:)
-          "x=#{x}, y=#{y}"
-        end
-      end
-
-      class B < A
-        def foo(x:, y:)
-          ["B", super(x: x, y: y)]
-        end
-      end
-
-      def test
-        B.new.foo(x: 1, y: 2)
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_kw_splat
-    assert_compiles '["B", "x=1, y=2"]', %q{
-      class A
-        def foo(x:, y:)
-          "x=#{x}, y=#{y}"
-        end
-      end
-
-      class B < A
-        def foo(**kwargs)
-          ["B", super(**kwargs)]
-        end
-      end
-
-      def test
-        B.new.foo(x: 1, y: 2)
-      end
-
-      test  # profile
-      test  # compile + run compiled code
-    }, call_threshold: 2
-  end
-
-  # Test that including a module after compilation correctly changes the super target.
-  # The included module's method should be called, not the original super target.
-  def test_invokesuper_with_include
-    assert_compiles '["B", "M"]', %q{
-      class A
-        def foo
-          "A"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]
-        end
-      end
-
-      def test
-        B.new.foo
-      end
-
-      test  # profile invokesuper (super -> A#foo)
-      test  # compile with super -> A#foo
-
-      # Now include a module in B that defines foo - super should go to M#foo instead
-      module M
-        def foo
-          "M"
-        end
-      end
-      B.include(M)
-
-      test  # should call M#foo, not A#foo
-    }, call_threshold: 2
-  end
-
-  # Test that prepending a module after compilation correctly changes the super target.
-  # The prepended module's method should be called, not the original super target.
-  def test_invokesuper_with_prepend
-    assert_compiles '["B", "M"]', %q{
-      class A
-        def foo
-          "A"
-        end
-      end
-
-      class B < A
-        def foo
-          ["B", super]
-        end
-      end
-
-      def test
-        B.new.foo
-      end
-
-      test  # profile invokesuper (super -> A#foo)
-      test  # compile with super -> A#foo
-
-      # Now prepend a module that defines foo - super should go to M#foo instead
-      module M
-        def foo
-          "M"
-        end
-      end
-      A.prepend(M)
-
-      test  # should call M#foo, not A#foo
-    }, call_threshold: 2
-  end
-
-  # Test super with positional and keyword arguments (pattern from chunky_png)
-  def test_invokesuper_with_keyword_args
-    assert_compiles '{content: "image data"}', %q{
-      class A
-        def foo(attributes = {})
-          @attributes = attributes
-        end
-      end
-
-      class B < A
-        def foo(content = '')
-          super(content: content)
-        end
-      end
-
-      def test
-        B.new.foo("image data")
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_invokesuper_with_optional_keyword_args
-    assert_compiles '[1, 2, 3]', %q{
-      class Parent
-        def foo(a, b: 2, c: 3) = [a, b, c]
-      end
-
-      class Child < Parent
-        def foo(a) = super(a)
-      end
-
-      def test = Child.new.foo(1)
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_invokesuperforward
-    assert_compiles '[1, 2, 3]', %q{
-      class A
-        def foo(a,b,c) = [a,b,c]
-      end
-
-      class B < A
-        def foo(...) = super
-      end
-
-      def test
-        B.new.foo(1, 2, 3)
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_invokesuperforward_with_args_kwargs_and_block
-    assert_compiles '[[1, 2], {x: 3}, 4]', %q{
-      class A
-        def foo(*args, **kwargs, &block)
-          [args, kwargs, block&.call]
-        end
-      end
-
-      class B < A
-        def foo(...) = super
-      end
-
-      def test
-        B.new.foo(1, 2, x: 3) { 4 }
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default
-    assert_compiles '[[2, 4, 16], [10, 4, 16], [2, 20, 16], [2, 4, 30], [10, 20, 30]]', %q{
-      def dbl(x = 1) = x * 2
-
-      def foo(a: dbl, b: dbl(2), c: dbl(2 ** 3))
-        [a, b, c]
-      end
-
-      def test
-        [
-          foo,
-          foo(a: 10),
-          foo(b: 20),
-          foo(c: 30),
-          foo(a: 10, b: 20, c: 30)
-        ]
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default_not_evaluated_when_provided
-    assert_compiles '[1, 2, 3]', %q{
-      def foo(a: raise, b: raise, c: raise)
-        [a, b, c]
-      end
-
-      def test
-        foo(a: 1, b: 2, c: 3)
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default_evaluated_when_not_provided
-    assert_compiles '["a", "b", "c"]', %q{
-      def raise_a = raise "a"
-      def raise_b = raise "b"
-      def raise_c = raise "c"
-
-      def foo(a: raise_a, b: raise_b, c: raise_c)
-        [a, b, c]
-      end
-
-      def test_a
-        foo(b: 2, c: 3)
-      rescue RuntimeError => e
-        e.message
-      end
-
-      def test_b
-        foo(a: 1, c: 3)
-      rescue RuntimeError => e
-        e.message
-      end
-
-      def test_c
-        foo(a: 1, b: 2)
-      rescue RuntimeError => e
-        e.message
-      end
-
-      def test
-        [test_a, test_b, test_c]
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default_jit_to_jit
-    # Test that kw_bits passing works correctly in JIT-to-JIT calls
-    assert_compiles '[2, 4, 6]', %q{
-      def make_default(x) = x * 2
-
-      def callee(a: make_default(1), b: make_default(2), c: make_default(3))
-        [a, b, c]
-      end
-
-      def caller_method
-        callee
-      end
-
-      # Warm up callee first so it gets JITted
-      callee
-      callee
-
-      # Now warm up caller - this creates JIT-to-JIT call
-      caller_method
-      caller_method
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default_side_exit
-    # Verify frame reconstruction includes correct values for non-constant defaults
-    assert_compiles '[10, 2, 30]', %q{
-      def make_b = 2
-
-      def callee(a: 1, b: make_b, c: 3)
-        x = binding.local_variable_get(:a)
-        y = binding.local_variable_get(:b)
-        z = binding.local_variable_get(:c)
-        [x, y, z]
-      end
-
-      def test
-        callee(a: 10, c: 30)
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_non_constant_keyword_default_evaluation_order
-    # Verify defaults are evaluated left-to-right and only when not provided
-    assert_compiles '[["a", "b", "c"], ["b", "c"], ["a", "c"], ["a", "b"]]', %q{
-      def log(x)
-        $order << x
-        x
-      end
-
-      def foo(a: log("a"), b: log("b"), c: log("c"))
-        [a, b, c]
-      end
-
-      def test
-        results = []
-
-        $order = []
-        foo
-        results << $order.dup
-
-        $order = []
-        foo(a: "A")
-        results << $order.dup
-
-        $order = []
-        foo(b: "B")
-        results << $order.dup
-
-        $order = []
-        foo(c: "C")
-        results << $order.dup
-
-        results
-      end
-
-      test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_send_with_too_many_non_constant_keyword_defaults
-    assert_compiles '35', %q{
-      def many_kwargs( k1: 1, k2: 2, k3: 3, k4: 4, k5: 5, k6: 6, k7: 7, k8: 8, k9: 9, k10: 10, k11: 11, k12: 12, k13: 13, k14: 14, k15: 15, k16: 16, k17: 17, k18: 18, k19: 19, k20: 20, k21: 21, k22: 22, k23: 23, k24: 24, k25: 25, k26: 26, k27: 27, k28: 28, k29: 29, k30: 30, k31: 31, k32: 32, k33: 33, k34: k33 + 1) = k1 + k34
-      def t = many_kwargs
-      t
-      t
-    }, call_threshold: 2
-  end
-
-  def test_invokebuiltin
-    # Not using assert_compiles due to register spill
-    assert_runs '["."]', %q{
-      def test = Dir.glob(".")
-      test
-    }
-  end
-
-  def test_invokebuiltin_delegate
-    assert_compiles '[[], true]', %q{
-      def test = [].clone(freeze: true)
-      r = test
-      [r, r.frozen?]
-    }
-  end
-
-  def test_opt_plus_const
-    assert_compiles '3', %q{
-      def test = 1 + 2
-      test # profile opt_plus
-      test
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_fixnum
-    assert_compiles '3', %q{
-      def test(a, b) = a + b
-      test(0, 1) # profile opt_plus
-      test(1, 2)
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_chain
-    assert_compiles '6', %q{
-      def test(a, b, c) = a + b + c
-      test(0, 1, 2) # profile opt_plus
-      test(1, 2, 3)
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_left_imm
-    assert_compiles '3', %q{
-      def test(a) = 1 + a
-      test(1) # profile opt_plus
-      test(2)
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_type_guard_exit
-    assert_compiles '[3, 3.0]', %q{
-      def test(a) = 1 + a
-      test(1) # profile opt_plus
-      [test(2), test(2.0)]
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_type_guard_exit_with_locals
-    assert_compiles '[6, 6.0]', %q{
-      def test(a)
-        local = 3
-        1 + a + local
-      end
-      test(1) # profile opt_plus
-      [test(2), test(2.0)]
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_type_guard_nested_exit
-    assert_compiles '[4, 4.0]', %q{
-      def side_exit(n) = 1 + n
-      def jit_frame(n) = 1 + side_exit(n)
-      def entry(n) = jit_frame(n)
-      entry(2) # profile send
-      [entry(2), entry(2.0)]
-    }, call_threshold: 2
-  end
-
-  def test_opt_plus_type_guard_nested_exit_with_locals
-    assert_compiles '[9, 9.0]', %q{
-      def side_exit(n)
-        local = 2
-        1 + n + local
-      end
-      def jit_frame(n)
-        local = 3
-        1 + side_exit(n) + local
-      end
-      def entry(n) = jit_frame(n)
-      entry(2) # profile send
-      [entry(2), entry(2.0)]
-    }, call_threshold: 2
-  end
-
-  # Test argument ordering
-  def test_opt_minus
-    assert_compiles '2', %q{
-      def test(a, b) = a - b
-      test(2, 1) # profile opt_minus
-      test(6, 4)
-    }, call_threshold: 2
-  end
-
-  def test_opt_mult
-    assert_compiles '6', %q{
-      def test(a, b) = a * b
-      test(1, 2) # profile opt_mult
-      test(2, 3)
-    }, call_threshold: 2
-  end
-
-  def test_opt_mult_overflow
-    assert_compiles '[6, -6, 9671406556917033397649408, -9671406556917033397649408, 21267647932558653966460912964485513216]', %q{
-      def test(a, b)
-        a * b
-      end
-      test(1, 1) # profile opt_mult
-
-      r1 = test(2, 3)
-      r2 = test(2, -3)
-      r3 = test(2 << 40, 2 << 41)
-      r4 = test(2 << 40, -2 << 41)
-      r5 = test(1 << 62, 1 << 62)
-
-      [r1, r2, r3, r4, r5]
-    }, call_threshold: 2
-  end
-
-  def test_opt_eq
-    assert_compiles '[true, false]', %q{
-      def test(a, b) = a == b
-      test(0, 2) # profile opt_eq
-      [test(1, 1), test(0, 1)]
-    }, insns: [:opt_eq], call_threshold: 2
-  end
-
-  def test_opt_eq_with_minus_one
-    assert_compiles '[false, true]', %q{
-      def test(a) = a == -1
-      test(1) # profile opt_eq
-      [test(0), test(-1)]
-    }, insns: [:opt_eq], call_threshold: 2
-  end
-
-  def test_opt_neq_dynamic
-    # TODO(max): Don't split this test; instead, run all tests with and without
-    # profiling.
-    assert_compiles '[false, true]', %q{
-      def test(a, b) = a != b
-      test(0, 2) # profile opt_neq
-      [test(1, 1), test(0, 1)]
-    }, insns: [:opt_neq], call_threshold: 1
-  end
-
-  def test_opt_neq_fixnum
-    assert_compiles '[false, true]', %q{
-      def test(a, b) = a != b
-      test(0, 2) # profile opt_neq
-      [test(1, 1), test(0, 1)]
-    }, call_threshold: 2
-  end
-
-  def test_opt_lt
-    assert_compiles '[true, false, false]', %q{
-      def test(a, b) = a < b
-      test(2, 3) # profile opt_lt
-      [test(0, 1), test(0, 0), test(1, 0)]
-    }, insns: [:opt_lt], call_threshold: 2
-  end
-
-  def test_opt_lt_with_literal_lhs
-    assert_compiles '[false, false, true]', %q{
-      def test(n) = 2 < n
-      test(2) # profile opt_lt
-      [test(1), test(2), test(3)]
-    }, insns: [:opt_lt], call_threshold: 2
-  end
-
-  def test_opt_le
-    assert_compiles '[true, true, false]', %q{
-      def test(a, b) = a <= b
-      test(2, 3) # profile opt_le
-      [test(0, 1), test(0, 0), test(1, 0)]
-    }, insns: [:opt_le], call_threshold: 2
-  end
-
-  def test_opt_gt
-    assert_compiles '[false, false, true]', %q{
-      def test(a, b) = a > b
-      test(2, 3) # profile opt_gt
-      [test(0, 1), test(0, 0), test(1, 0)]
-    }, insns: [:opt_gt], call_threshold: 2
-  end
-
-  def test_opt_empty_p
-    assert_compiles('[false, false, true]', <<~RUBY, insns: [:opt_empty_p])
-      def test(x) = x.empty?
-      return test([1]), test("1"), test({})
-    RUBY
-  end
-
-  def test_opt_succ
-    assert_compiles('[0, "B"]', <<~RUBY, insns: [:opt_succ])
-      def test(obj) = obj.succ
-      return test(-1), test("A")
-    RUBY
-  end
-
-  def test_opt_and
-    assert_compiles('[1, [3, 2, 1]]', <<~RUBY, insns: [:opt_and])
-      def test(x, y) = x & y
-      return test(0b1101, 3), test([3, 2, 1, 4], [8, 1, 2, 3])
-    RUBY
-  end
-
-  def test_opt_or
-    assert_compiles('[11, [3, 2, 1]]', <<~RUBY, insns: [:opt_or])
-      def test(x, y) = x | y
-      return test(0b1000, 3), test([3, 2, 1], [1, 2, 3])
-    RUBY
-  end
-
-  def test_fixnum_and
-    assert_compiles '[1, 2, 4]', %q{
-      def test(a, b) = a & b
-      [
-        test(5, 3),
-        test(0b011, 0b110),
-        test(-0b011, 0b110)
-      ]
-    }, call_threshold: 2, insns: [:opt_and]
-  end
-
-  def test_fixnum_and_side_exit
-    assert_compiles '[2, 2, false]', %q{
-      def test(a, b) = a & b
-      [
-        test(2, 2),
-        test(0b011, 0b110),
-        test(true, false)
-      ]
-    }, call_threshold: 2, insns: [:opt_and]
-  end
-
-  def test_fixnum_or
-    assert_compiles '[7, 3, -3]', %q{
-      def test(a, b) = a | b
-      [
-        test(5, 3),
-        test(1, 2),
-        test(1, -4)
-      ]
-    }, call_threshold: 2, insns: [:opt_or]
-  end
-
-  def test_fixnum_or_side_exit
-    assert_compiles '[3, 2, true]', %q{
-      def test(a, b) = a | b
-      [
-        test(1, 2),
-        test(2, 2),
-        test(true, false)
-      ]
-    }, call_threshold: 2, insns: [:opt_or]
-  end
-
-  def test_fixnum_xor
-    assert_compiles '[6, -8, 3]', %q{
-      def test(a, b) = a ^ b
-      [
-        test(5, 3),
-        test(-5, 3),
-        test(1, 2)
-      ]
-    }, call_threshold: 2
-  end
-
-  def test_fixnum_xor_side_exit
-    assert_compiles '[6, 6, true]', %q{
-      def test(a, b) = a ^ b
-      [
-        test(5, 3),
-        test(5, 3),
-        test(true, false)
-      ]
-    }, call_threshold: 2
-  end
-
-  def test_fixnum_mul
-    assert_compiles '12', %q{
-      C = 3
-      def test(n) = C * n
-      test(4)
-      test(4)
-      test(4)
-    }, call_threshold: 2, insns: [:opt_mult]
-  end
-
-  def test_fixnum_div
-    assert_compiles '12', %q{
-      C = 48
-      def test(n) = C / n
-      test(4)
-      test(4)
-    }, call_threshold: 2, insns: [:opt_div]
-  end
-
-  def test_fixnum_floor
-    assert_compiles '0', %q{
-      C = 3
-      def test(n) = C / n
-      test(4)
-      test(4)
-    }, call_threshold: 2, insns: [:opt_div]
-  end
-
-  def test_fixnum_div_zero
-    assert_runs '"divided by 0"', %q{
-      def test(n)
-        n / 0
-      rescue ZeroDivisionError => e
-        e.message
-      end
-
-      test(0)
-      test(0)
-    }, call_threshold: 2, insns: [:opt_div]
-  end
-
-  def test_opt_not
-    assert_compiles('[true, true, false]', <<~RUBY, insns: [:opt_not])
-      def test(obj) = !obj
-      return test(nil), test(false), test(0)
-    RUBY
-  end
-
-  def test_opt_regexpmatch2
-    assert_compiles('[1, nil]', <<~RUBY, insns: [:opt_regexpmatch2])
-      def test(haystack) = /needle/ =~ haystack
-      return test("kneedle"), test("")
-    RUBY
-  end
-
-  def test_opt_ge
-    assert_compiles '[false, true, true]', %q{
-      def test(a, b) = a >= b
-      test(2, 3) # profile opt_ge
-      [test(0, 1), test(0, 0), test(1, 0)]
-    }, insns: [:opt_ge], call_threshold: 2
-  end
-
-  def test_opt_new_does_not_push_frame
-    assert_compiles 'nil', %q{
-      class Foo
-        attr_reader :backtrace
-
-        def initialize
-          @backtrace = caller
-        end
-      end
-      def test = Foo.new
-
-      foo = test
-      foo.backtrace.find do |frame|
-        frame.include?('Class#new')
-      end
-    }, insns: [:opt_new]
-  end
-
-  def test_opt_new_with_redefined
-    assert_compiles '"foo"', %q{
-      class Foo
-        def self.new = "foo"
-
-        def initialize = raise("unreachable")
-      end
-      def test = Foo.new
-
-      test
-    }, insns: [:opt_new]
-  end
-
-  def test_opt_new_invalidate_new
-    assert_compiles '["Foo", "foo"]', %q{
-      class Foo; end
-      def test = Foo.new
-      test; test
-      result = [test.class.name]
-      def Foo.new = "foo"
-      result << test
-      result
-    }, insns: [:opt_new], call_threshold: 2
-  end
-
   def test_opt_new_with_custom_allocator
     assert_compiles '"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"', %q{
       require "digest"
@@ -2171,1208 +164,6 @@ class TestZJIT < Test::Unit::TestCase
     }, insns: [:opt_new], call_threshold: 2
   end
 
-  def test_opt_newarray_send_include_p
-    assert_compiles '[true, false]', %q{
-      def test(x)
-        [:y, 1, Object.new].include?(x)
-      end
-      [test(1), test("n")]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_include_p_redefined
-    assert_compiles '[:true, :false]', %q{
-      class Array
-        alias_method :old_include?, :include?
-        def include?(x)
-          old_include?(x) ? :true : :false
-        end
-      end
-
-      def test(x)
-        [:y, 1, Object.new].include?(x)
-      end
-      [test(1), test("n")]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_duparray_send_include_p
-    assert_compiles '[true, false]', %q{
-      def test(x)
-        [:y, 1].include?(x)
-      end
-      [test(1), test("n")]
-    }, insns: [:opt_duparray_send], call_threshold: 1
-  end
-
-  def test_opt_duparray_send_include_p_redefined
-    assert_compiles '[:true, :false]', %q{
-      class Array
-        alias_method :old_include?, :include?
-        def include?(x)
-          old_include?(x) ? :true : :false
-        end
-      end
-
-      def test(x)
-        [:y, 1].include?(x)
-      end
-      [test(1), test("n")]
-    }, insns: [:opt_duparray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_pack_buffer
-    assert_compiles '["ABC", "ABC", "ABC", "ABC"]', %q{
-      def test(num, buffer)
-        [num].pack('C', buffer:)
-      end
-      buf = ""
-      [test(65, buf), test(66, buf), test(67, buf), buf]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_pack_buffer_redefined
-    assert_compiles '["b", "A"]', %q{
-      class Array
-        alias_method :old_pack, :pack
-        def pack(fmt, buffer: nil)
-          old_pack(fmt, buffer: buffer)
-          "b"
-        end
-      end
-
-      def test(num, buffer)
-        [num].pack('C', buffer:)
-      end
-      buf = ""
-      [test(65, buf), buf]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_hash
-    assert_compiles 'Integer', %q{
-      def test(x)
-        [1, 2, x].hash
-      end
-      test(20).class
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_hash_redefined
-    assert_compiles '42', %q{
-      Array.class_eval { def hash = 42 }
-
-      def test(x)
-        [1, 2, x].hash
-      end
-      test(20)
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_max
-    assert_compiles '[20, 40]', %q{
-      def test(a,b) = [a,b].max
-      [test(10, 20), test(40, 30)]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_opt_newarray_send_max_redefined
-    assert_compiles '[60, 90]', %q{
-      class Array
-        alias_method :old_max, :max
-        def max
-          old_max * 2
-        end
-      end
-
-      def test(a,b) = [a,b].max
-      [test(15, 30), test(45, 35)]
-    }, insns: [:opt_newarray_send], call_threshold: 1
-  end
-
-  def test_new_hash_empty
-    assert_compiles '{}', %q{
-      def test = {}
-      test
-    }, insns: [:newhash]
-  end
-
-  def test_new_hash_nonempty
-    assert_compiles '{"key" => "value", 42 => 100}', %q{
-      def test
-        key = "key"
-        value = "value"
-        num = 42
-        result = 100
-        {key => value, num => result}
-      end
-      test
-    }, insns: [:newhash]
-  end
-
-  def test_new_hash_single_key_value
-    assert_compiles '{"key" => "value"}', %q{
-      def test = {"key" => "value"}
-      test
-    }, insns: [:newhash]
-  end
-
-  def test_new_hash_with_computation
-    assert_compiles '{"sum" => 5, "product" => 6}', %q{
-      def test(a, b)
-        {"sum" => a + b, "product" => a * b}
-      end
-      test(2, 3)
-    }, insns: [:newhash]
-  end
-
-  def test_new_hash_with_user_defined_hash_method
-    assert_runs 'true', %q{
-      class CustomKey
-        attr_reader :val
-
-        def initialize(val)
-          @val = val
-        end
-
-        def hash
-          @val.hash
-        end
-
-        def eql?(other)
-          other.is_a?(CustomKey) && @val == other.val
-        end
-      end
-
-      def test
-        key = CustomKey.new("key")
-        hash = {key => "value"}
-        hash[key] == "value"
-      end
-      test
-    }
-  end
-
-  def test_new_hash_with_user_hash_method_exception
-    assert_runs 'RuntimeError', %q{
-      class BadKey
-        def hash
-          raise "Hash method failed!"
-        end
-      end
-
-      def test
-        key = BadKey.new
-        {key => "value"}
-      end
-
-      begin
-        test
-      rescue => e
-        e.class
-      end
-    }
-  end
-
-  def test_new_hash_with_user_eql_method_exception
-    assert_runs 'RuntimeError', %q{
-      class BadKey
-        def hash
-          42
-        end
-
-        def eql?(other)
-          raise "Eql method failed!"
-        end
-      end
-
-      def test
-        key1 = BadKey.new
-        key2 = BadKey.new
-        {key1 => "value1", key2 => "value2"}
-      end
-
-      begin
-        test
-      rescue => e
-        e.class
-      end
-    }
-  end
-
-  def test_opt_hash_freeze
-    assert_compiles "[{}, 5]", %q{
-      def test = {}.freeze
-      result = [test]
-      class Hash
-        def freeze = 5
-      end
-      result << test
-    }, insns: [:opt_hash_freeze], call_threshold: 1
-  end
-
-  def test_opt_hash_freeze_rewritten
-    assert_compiles "5", %q{
-      class Hash
-        def freeze = 5
-      end
-      def test = {}.freeze
-      test
-    }, insns: [:opt_hash_freeze], call_threshold: 1
-  end
-
-  def test_opt_aset_hash
-    assert_compiles '42', %q{
-      def test(h, k, v)
-        h[k] = v
-      end
-      h = {}
-      test(h, :key, 42)
-      test(h, :key, 42)
-      h[:key]
-    }, call_threshold: 2, insns: [:opt_aset]
-  end
-
-  def test_opt_aset_hash_returns_value
-    assert_compiles '100', %q{
-      def test(h, k, v)
-        h[k] = v
-      end
-      test({}, :key, 100)
-      test({}, :key, 100)
-    }, call_threshold: 2
-  end
-
-  def test_opt_aset_hash_string_key
-    assert_compiles '"bar"', %q{
-      def test(h, k, v)
-        h[k] = v
-      end
-      h = {}
-      test(h, "foo", "bar")
-      test(h, "foo", "bar")
-      h["foo"]
-    }, call_threshold: 2
-  end
-
-  def test_opt_aset_hash_subclass
-    assert_compiles '42', %q{
-      class MyHash < Hash; end
-      def test(h, k, v)
-        h[k] = v
-      end
-      h = MyHash.new
-      test(h, :key, 42)
-      test(h, :key, 42)
-      h[:key]
-    }, call_threshold: 2
-  end
-
-  def test_opt_aset_hash_too_few_args
-    assert_compiles '"ArgumentError"', %q{
-      def test(h)
-        h.[]= 123
-      rescue ArgumentError
-        "ArgumentError"
-      end
-      test({})
-      test({})
-    }, call_threshold: 2
-  end
-
-  def test_opt_aset_hash_too_many_args
-    assert_compiles '"ArgumentError"', %q{
-      def test(h)
-        h[:a, :b] = :c
-      rescue ArgumentError
-        "ArgumentError"
-      end
-      test({})
-      test({})
-    }, call_threshold: 2
-  end
-
-  def test_opt_ary_freeze
-    assert_compiles "[[], 5]", %q{
-      def test = [].freeze
-      result = [test]
-      class Array
-        def freeze = 5
-      end
-      result << test
-    }, insns: [:opt_ary_freeze], call_threshold: 1
-  end
-
-  def test_opt_ary_freeze_rewritten
-    assert_compiles "5", %q{
-      class Array
-        def freeze = 5
-      end
-      def test = [].freeze
-      test
-    }, insns: [:opt_ary_freeze], call_threshold: 1
-  end
-
-  def test_opt_str_freeze
-    assert_compiles "[\"\", 5]", %q{
-      def test = ''.freeze
-      result = [test]
-      class String
-        def freeze = 5
-      end
-      result << test
-    }, insns: [:opt_str_freeze], call_threshold: 1
-  end
-
-  def test_opt_str_freeze_rewritten
-    assert_compiles "5", %q{
-      class String
-        def freeze = 5
-      end
-      def test = ''.freeze
-      test
-    }, insns: [:opt_str_freeze], call_threshold: 1
-  end
-
-  def test_opt_str_uminus
-    assert_compiles "[\"\", 5]", %q{
-      def test = -''
-      result = [test]
-      class String
-        def -@ = 5
-      end
-      result << test
-    }, insns: [:opt_str_uminus], call_threshold: 1
-  end
-
-  def test_opt_str_uminus_rewritten
-    assert_compiles "5", %q{
-      class String
-        def -@ = 5
-      end
-      def test = -''
-      test
-    }, insns: [:opt_str_uminus], call_threshold: 1
-  end
-
-  def test_new_array_empty
-    assert_compiles '[]', %q{
-      def test = []
-      test
-    }, insns: [:newarray]
-  end
-
-  def test_new_array_nonempty
-    assert_compiles '[5]', %q{
-      def a = 5
-      def test = [a]
-      test
-    }
-  end
-
-  def test_new_array_order
-    assert_compiles '[3, 2, 1]', %q{
-      def a = 3
-      def b = 2
-      def c = 1
-      def test = [a, b, c]
-      test
-    }
-  end
-
-  def test_array_dup
-    assert_compiles '[1, 2, 3]', %q{
-      def test = [1,2,3]
-      test
-    }
-  end
-
-  def test_array_fixnum_aref
-    assert_compiles '3', %q{
-      def test(x) = [1,2,3][x]
-      test(2)
-      test(2)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_array_fixnum_aref_negative_index
-    assert_compiles '3', %q{
-      def test(x) = [1,2,3][x]
-      test(-1)
-      test(-1)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_array_fixnum_aref_out_of_bounds_positive
-    assert_compiles 'nil', %q{
-      def test(x) = [1,2,3][x]
-      test(10)
-      test(10)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_array_fixnum_aref_out_of_bounds_negative
-    assert_compiles 'nil', %q{
-      def test(x) = [1,2,3][x]
-      test(-10)
-      test(-10)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_array_fixnum_aref_array_subclass
-    assert_compiles '3', %q{
-      class MyArray < Array; end
-      def test(arr, idx) = arr[idx]
-      arr = MyArray[1,2,3]
-      test(arr, 2)
-      arr = MyArray[1,2,3]
-      test(arr, 2)
-    }, call_threshold: 2, insns: [:opt_aref]
-  end
-
-  def test_array_aref_non_fixnum_index
-    assert_compiles 'TypeError', %q{
-      def test(arr, idx) = arr[idx]
-      test([1,2,3], 1)
-      test([1,2,3], 1)
-      begin
-        test([1,2,3], "1")
-      rescue => e
-        e.class
-      end
-    }, call_threshold: 2
-  end
-
-  def test_array_fixnum_aset
-    assert_compiles '[1, 2, 7]', %q{
-      def test(arr, idx)
-        arr[idx] = 7
-      end
-      arr = [1,2,3]
-      test(arr, 2)
-      arr = [1,2,3]
-      test(arr, 2)
-      arr
-    }, call_threshold: 2, insns: [:opt_aset]
-  end
-
-  def test_array_fixnum_aset_returns_value
-    assert_compiles '7', %q{
-      def test(arr, idx)
-        arr[idx] = 7
-      end
-      test([1,2,3], 2)
-      test([1,2,3], 2)
-    }, call_threshold: 2, insns: [:opt_aset]
-  end
-
-  def test_array_fixnum_aset_out_of_bounds
-    assert_compiles '[1, 2, 3, nil, nil, 7]', %q{
-      def test(arr)
-        arr[5] = 7
-      end
-      arr = [1,2,3]
-      test(arr)
-      arr = [1,2,3]
-      test(arr)
-      arr
-    }, call_threshold: 2
-  end
-
-  def test_array_fixnum_aset_negative_index
-    assert_compiles '[1, 2, 7]', %q{
-      def test(arr)
-        arr[-1] = 7
-      end
-      arr = [1,2,3]
-      test(arr)
-      arr = [1,2,3]
-      test(arr)
-      arr
-    }, call_threshold: 2
-  end
-
-  def test_array_fixnum_aset_shared
-    assert_compiles '[10, 999, -1, -2]', %q{
-      def test(arr, idx, val)
-        arr[idx] = val
-      end
-      arr = (0..50).to_a
-      test(arr, 0, -1)
-      test(arr, 1, -2)
-      shared = arr[10, 20]
-      test(shared, 0, 999)
-      [arr[10], shared[0], arr[0], arr[1]]
-    }, call_threshold: 2
-  end
-
-  def test_array_fixnum_aset_frozen
-    assert_compiles 'FrozenError', %q{
-      def test(arr, idx, val)
-        arr[idx] = val
-      end
-      arr = [1,2,3]
-      test(arr, 1, 9)
-      test(arr, 1, 9)
-      arr.freeze
-      begin
-        test(arr, 1, 9)
-      rescue => e
-        e.class
-      end
-    }, call_threshold: 2
-  end
-
-  def test_array_fixnum_aset_array_subclass
-    assert_compiles '7', %q{
-      class MyArray < Array; end
-      def test(arr, idx)
-        arr[idx] = 7
-      end
-      arr = MyArray.new
-      test(arr, 0)
-      arr = MyArray.new
-      test(arr, 0)
-      arr[0]
-    }, call_threshold: 2, insns: [:opt_aset]
-  end
-
-  def test_array_aset_non_fixnum_index
-    assert_compiles 'TypeError', %q{
-      def test(arr, idx)
-        arr[idx] = 7
-      end
-      test([1,2,3], 0)
-      test([1,2,3], 0)
-      begin
-        test([1,2,3], "0")
-      rescue => e
-        e.class
-      end
-    }, call_threshold: 2
-  end
-
-  def test_empty_array_pop
-    assert_compiles 'nil', %q{
-      def test(arr) = arr.pop
-      test([])
-      test([])
-    }, call_threshold: 2
-  end
-
-  def test_array_pop_no_arg
-    assert_compiles '42', %q{
-      def test(arr) = arr.pop
-      test([32, 33, 42])
-      test([32, 33, 42])
-    }, call_threshold: 2
-  end
-
-  def test_array_pop_arg
-    assert_compiles '[33, 42]', %q{
-      def test(arr) = arr.pop(2)
-      test([32, 33, 42])
-      test([32, 33, 42])
-    }, call_threshold: 2
-  end
-
-  def test_new_range_inclusive
-    assert_compiles '1..5', %q{
-      def test(a, b) = a..b
-      test(1, 5)
-    }
-  end
-
-  def test_new_range_exclusive
-    assert_compiles '1...5', %q{
-      def test(a, b) = a...b
-      test(1, 5)
-    }
-  end
-
-  def test_new_range_with_literal
-    assert_compiles '3..10', %q{
-      def test(n) = n..10
-      test(3)
-    }
-  end
-
-  def test_new_range_fixnum_both_literals_inclusive
-    assert_compiles '1..2', %q{
-      def test()
-        a = 2
-        (1..a)
-      end
-      test; test
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_new_range_fixnum_both_literals_exclusive
-    assert_compiles '1...2', %q{
-      def test()
-        a = 2
-        (1...a)
-      end
-      test; test
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_new_range_fixnum_low_literal_inclusive
-    assert_compiles '1..3', %q{
-      def test(a)
-        (1..a)
-      end
-      test(2); test(3)
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_new_range_fixnum_low_literal_exclusive
-    assert_compiles '1...3', %q{
-      def test(a)
-        (1...a)
-      end
-      test(2); test(3)
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_new_range_fixnum_high_literal_inclusive
-    assert_compiles '3..10', %q{
-      def test(a)
-        (a..10)
-      end
-      test(2); test(3)
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_new_range_fixnum_high_literal_exclusive
-    assert_compiles '3...10', %q{
-      def test(a)
-        (a...10)
-      end
-      test(2); test(3)
-    }, call_threshold: 2, insns: [:newrange]
-  end
-
-  def test_if
-    assert_compiles '[0, nil]', %q{
-      def test(n)
-        if n < 5
-          0
-        end
-      end
-      [test(3), test(7)]
-    }
-  end
-
-  def test_if_else
-    assert_compiles '[0, 1]', %q{
-      def test(n)
-        if n < 5
-          0
-        else
-          1
-        end
-      end
-      [test(3), test(7)]
-    }
-  end
-
-  def test_if_else_params
-    assert_compiles '[1, 20]', %q{
-      def test(n, a, b)
-        if n < 5
-          a
-        else
-          b
-        end
-      end
-      [test(3, 1, 2), test(7, 10, 20)]
-    }
-  end
-
-  def test_if_else_nested
-    assert_compiles '[3, 8, 9, 14]', %q{
-      def test(a, b, c, d, e)
-        if 2 < a
-          if a < 4
-            b
-          else
-            c
-          end
-        else
-          if a < 0
-            d
-          else
-            e
-          end
-        end
-      end
-      [
-        test(-1,  1,  2,  3,  4),
-        test( 0,  5,  6,  7,  8),
-        test( 3,  9, 10, 11, 12),
-        test( 5, 13, 14, 15, 16),
-      ]
-    }
-  end
-
-  def test_if_else_chained
-    assert_compiles '[12, 11, 21]', %q{
-      def test(a)
-        (if 2 < a then 1 else 2 end) + (if a < 4 then 10 else 20 end)
-      end
-      [test(0), test(3), test(5)]
-    }
-  end
-
-  def test_if_elsif_else
-    assert_compiles '[0, 2, 1]', %q{
-      def test(n)
-        if n < 5
-          0
-        elsif 8 < n
-          1
-        else
-          2
-        end
-      end
-      [test(3), test(7), test(9)]
-    }
-  end
-
-  def test_ternary_operator
-    assert_compiles '[1, 20]', %q{
-      def test(n, a, b)
-        n < 5 ? a : b
-      end
-      [test(3, 1, 2), test(7, 10, 20)]
-    }
-  end
-
-  def test_ternary_operator_nested
-    assert_compiles '[2, 21]', %q{
-      def test(n, a, b)
-        (n < 5 ? a : b) + 1
-      end
-      [test(3, 1, 2), test(7, 10, 20)]
-    }
-  end
-
-  def test_while_loop
-    assert_compiles '10', %q{
-      def test(n)
-        i = 0
-        while i < n
-          i = i + 1
-        end
-        i
-      end
-      test(10)
-    }
-  end
-
-  def test_while_loop_chain
-    assert_compiles '[135, 270]', %q{
-      def test(n)
-        i = 0
-        while i < n
-          i = i + 1
-        end
-        while i < n * 10
-          i = i * 3
-        end
-        i
-      end
-      [test(5), test(10)]
-    }
-  end
-
-  def test_while_loop_nested
-    assert_compiles '[0, 4, 12]', %q{
-      def test(n, m)
-        i = 0
-        while i < n
-          j = 0
-          while j < m
-            j += 2
-          end
-          i += j
-        end
-        i
-      end
-      [test(0, 0), test(1, 3), test(10, 5)]
-    }
-  end
-
-  def test_while_loop_if_else
-    assert_compiles '[9, -1]', %q{
-      def test(n)
-        i = 0
-        while i < n
-          if n >= 10
-            return -1
-          else
-            i = i + 1
-          end
-        end
-        i
-      end
-      [test(9), test(10)]
-    }
-  end
-
-  def test_if_while_loop
-    assert_compiles '[9, 12]', %q{
-      def test(n)
-        i = 0
-        if n < 10
-          while i < n
-            i += 1
-          end
-        else
-          while i < n
-            i += 3
-          end
-        end
-        i
-      end
-      [test(9), test(10)]
-    }
-  end
-
-  def test_live_reg_past_ccall
-    assert_compiles '2', %q{
-      def callee = 1
-      def test = callee + callee
-      test
-    }
-  end
-
-  def test_method_call
-    assert_compiles '12', %q{
-      def callee(a, b)
-        a - b
-      end
-
-      def test
-        callee(4, 2) + 10
-      end
-
-      test # profile test
-      test
-    }, call_threshold: 2
-  end
-
-  def test_recursive_fact
-    assert_compiles '[1, 6, 720]', %q{
-      def fact(n)
-        if n == 0
-          return 1
-        end
-        return n * fact(n-1)
-      end
-      [fact(0), fact(3), fact(6)]
-    }
-  end
-
-  def test_profiled_fact
-    assert_compiles '[1, 6, 720]', %q{
-      def fact(n)
-        if n == 0
-          return 1
-        end
-        return n * fact(n-1)
-      end
-      fact(1) # profile fact
-      [fact(0), fact(3), fact(6)]
-    }, call_threshold: 3, num_profiles: 2
-  end
-
-  def test_recursive_fib
-    assert_compiles '[0, 2, 3]', %q{
-      def fib(n)
-        if n < 2
-          return n
-        end
-        return fib(n-1) + fib(n-2)
-      end
-      [fib(0), fib(3), fib(4)]
-    }
-  end
-
-  def test_profiled_fib
-    assert_compiles '[0, 2, 3]', %q{
-      def fib(n)
-        if n < 2
-          return n
-        end
-        return fib(n-1) + fib(n-2)
-      end
-      fib(3) # profile fib
-      [fib(0), fib(3), fib(4)]
-    }, call_threshold: 5, num_profiles: 3
-  end
-
-  def test_spilled_basic_block_args
-    assert_compiles '55', %q{
-      def test(n1, n2)
-        n3 = 3
-        n4 = 4
-        n5 = 5
-        n6 = 6
-        n7 = 7
-        n8 = 8
-        n9 = 9
-        n10 = 10
-        if n1 < n2
-          n1 + n2 + n3 + n4 + n5 + n6 + n7 + n8 + n9 + n10
-        end
-      end
-      test(1, 2)
-    }
-  end
-
-  def test_spilled_method_args
-    assert_runs '55', %q{
-      def foo(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10)
-        n1 + n2 + n3 + n4 + n5 + n6 + n7 + n8 + n9 + n10
-      end
-
-      def test
-        foo(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-      end
-
-      test
-    }
-
-    # TODO(Shopify/ruby#716): Support spills and change to assert_compiles
-    assert_runs '1', %q{
-      def a(n1,n2,n3,n4,n5,n6,n7,n8,n9) = n1+n9
-      a(2,0,0,0,0,0,0,0,-1)
-    }
-
-    # TODO(Shopify/ruby#716): Support spills and change to assert_compiles
-    assert_runs '0', %q{
-      def a(n1,n2,n3,n4,n5,n6,n7,n8) = n8
-      a(1,1,1,1,1,1,1,0)
-    }
-
-    # TODO(Shopify/ruby#716): Support spills and change to assert_compiles
-    # self param with spilled param
-    assert_runs '"main"', %q{
-      def a(n1,n2,n3,n4,n5,n6,n7,n8) = self
-      a(1,0,0,0,0,0,0,0).to_s
-    }
-  end
-
-  def test_spilled_param_new_arary
-    # TODO(Shopify/ruby#716): Support spills and change to assert_compiles
-    assert_runs '[:ok]', %q{
-      def a(n1,n2,n3,n4,n5,n6,n7,n8) = [n8]
-      a(0,0,0,0,0,0,0, :ok)
-    }
-  end
-
-  def test_forty_param_method
-    # This used to a trigger a miscomp on A64 due
-    # to a memory displacement larger than 9 bits.
-    # Using assert_runs again due to register spill.
-    # TODO: It should be fixed by register spill support.
-    assert_runs '1', %Q{
-      def foo(#{'_,' * 39} n40) = n40
-
-      foo(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1)
-    }
-  end
-
-  def test_putself
-    assert_compiles '3', %q{
-      class Integer
-        def minus(a)
-          self - a
-        end
-      end
-      5.minus(2)
-    }
-  end
-
-  def test_getinstancevariable
-    assert_compiles 'nil', %q{
-      def test() = @foo
-
-      test()
-    }
-    assert_compiles '3', %q{
-      @foo = 3
-      def test() = @foo
-
-      test()
-    }
-  end
-
-  def test_getinstancevariable_miss
-    assert_compiles '[1, 1, 4]', %q{
-      class C
-        def foo
-          @foo
-        end
-
-        def foo_then_bar
-          @foo = 1
-          @bar = 2
-        end
-
-        def bar_then_foo
-          @bar = 3
-          @foo = 4
-        end
-      end
-
-      o1 = C.new
-      o1.foo_then_bar
-      result = []
-      result << o1.foo
-      result << o1.foo
-      o2 = C.new
-      o2.bar_then_foo
-      result << o2.foo
-      result
-    }
-  end
-
-  def test_setinstancevariable
-    assert_compiles '1', %q{
-      def test() = @foo = 1
-
-      test()
-      @foo
-    }
-  end
-
-  def test_getclassvariable
-    assert_compiles '42', %q{
-      class Foo
-        def self.test = @@x
-      end
-
-      Foo.class_variable_set(:@@x, 42)
-      Foo.test()
-    }
-  end
-
-  def test_getclassvariable_raises
-    assert_compiles '"uninitialized class variable @@x in Foo"', %q{
-      class Foo
-        def self.test = @@x
-      end
-
-      begin
-        Foo.test
-      rescue NameError => e
-        e.message
-      end
-    }
-  end
-
-  def test_setclassvariable
-    assert_compiles '42', %q{
-      class Foo
-        def self.test = @@x = 42
-      end
-
-      Foo.test()
-      Foo.class_variable_get(:@@x)
-    }
-  end
-
-  def test_setclassvariable_raises
-    assert_compiles '"can\'t modify frozen Class: Foo"', %q{
-      class Foo
-        def self.test = @@x = 42
-        freeze
-      end
-
-      begin
-        Foo.test
-      rescue FrozenError => e
-        e.message
-      end
-    }
-  end
-
-  def test_attr_reader
-    assert_compiles '[4, 4]', %q{
-      class C
-        attr_reader :foo
-
-        def initialize
-          @foo = 4
-        end
-      end
-
-      def test(c) = c.foo
-      c = C.new
-      [test(c), test(c)]
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_attr_accessor_getivar
-    assert_compiles '[4, 4]', %q{
-      class C
-        attr_accessor :foo
-
-        def initialize
-          @foo = 4
-        end
-      end
-
-      def test(c) = c.foo
-      c = C.new
-      [test(c), test(c)]
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_attr_accessor_setivar
-    assert_compiles '[5, 5]', %q{
-      class C
-        attr_accessor :foo
-
-        def initialize
-          @foo = 4
-        end
-      end
-
-      def test(c)
-        c.foo = 5
-        c.foo
-      end
-
-      c = C.new
-      [test(c), test(c)]
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_attr_writer
-    assert_compiles '[5, 5]', %q{
-      class C
-        attr_writer :foo
-
-        def initialize
-          @foo = 4
-        end
-
-        def get_foo = @foo
-      end
-
-      def test(c)
-        c.foo = 5
-        c.get_foo
-      end
-      c = C.new
-      [test(c), test(c)]
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
   def test_uncached_getconstant_path
     assert_compiles RUBY_COPYRIGHT.dump, %q{
       def test = RUBY_COPYRIGHT
@@ -3380,51 +171,6 @@ class TestZJIT < Test::Unit::TestCase
     }, call_threshold: 1, insns: [:opt_getconstant_path]
   end
 
-  def test_getconstant
-    assert_compiles '1', %q{
-      class Foo
-        CONST = 1
-      end
-
-      def test(klass)
-        klass::CONST
-      end
-
-      test(Foo)
-      test(Foo)
-    }, call_threshold: 2, insns: [:getconstant]
-  end
-
-  def test_expandarray_no_splat
-    assert_compiles '[3, 4]', %q{
-      def test(o)
-        a, b = o
-        [a, b]
-      end
-      test [3, 4]
-    }, call_threshold: 1, insns: [:expandarray]
-  end
-
-  def test_expandarray_splat
-    assert_compiles '[3, [4]]', %q{
-      def test(o)
-        a, *b = o
-        [a, b]
-      end
-      test [3, 4]
-    }, call_threshold: 1, insns: [:expandarray]
-  end
-
-  def test_expandarray_splat_post
-    assert_compiles '[3, [4], 5]', %q{
-      def test(o)
-        a, *b, c = o
-        [a, b, c]
-      end
-      test [3, 4, 5]
-    }, call_threshold: 1, insns: [:expandarray]
-  end
-
   def test_getconstant_path_autoload
     # A constant-referencing expression can run arbitrary code through Kernel#autoload.
     Dir.mktmpdir('autoload') do |tmpdir|
@@ -3439,78 +185,6 @@ class TestZJIT < Test::Unit::TestCase
     end
   end
 
-  def test_constant_invalidation
-    assert_compiles '123', <<~RUBY, call_threshold: 2, insns: [:opt_getconstant_path]
-      class C; end
-      def test = C
-      test
-      test
-
-      C = 123
-      test
-    RUBY
-  end
-
-  def test_constant_path_invalidation
-    assert_compiles '["Foo::C", "Foo::C", "Bar::C"]', <<~RUBY, call_threshold: 2, insns: [:opt_getconstant_path]
-      module A
-        module B; end
-      end
-
-      module Foo
-        C = "Foo::C"
-      end
-
-      module Bar
-        C = "Bar::C"
-      end
-
-      A::B = Foo
-
-      def test = A::B::C
-
-      result = []
-
-      result << test
-      result << test
-
-      A::B = Bar
-
-      result << test
-      result
-    RUBY
-  end
-
-  def test_single_ractor_mode_invalidation
-    # Without invalidating the single-ractor mode, the test would crash
-    assert_compiles '"errored but not crashed"', <<~RUBY, call_threshold: 2, insns: [:opt_getconstant_path]
-      C = Object.new
-
-      def test
-        C
-      rescue Ractor::IsolationError
-        "errored but not crashed"
-      end
-
-      test
-      test
-
-      Ractor.new {
-        test
-      }.value
-    RUBY
-  end
-
-  def test_dupn
-    assert_compiles '[[1], [1, 1], :rhs, [nil, :rhs]]', <<~RUBY, insns: [:dupn]
-      def test(array) = (array[1, 2] ||= :rhs)
-
-      one = [1, 1]
-      start_empty = []
-      [test(one), one, test(start_empty), start_empty]
-    RUBY
-  end
-
   def test_send_backtrace
     backtrace = [
       "-e:2:in 'Object#jit_frame1'",
@@ -3527,276 +201,6 @@ class TestZJIT < Test::Unit::TestCase
     }, call_threshold: 2
   end
 
-  def test_bop_invalidation
-    assert_compiles '100', %q{
-      def test
-        eval(<<~RUBY)
-          class Integer
-            def +(_) = 100
-          end
-        RUBY
-        1 + 2
-      end
-      test
-    }
-  end
-
-  def test_defined_with_defined_values
-    assert_compiles '["constant", "method", "global-variable"]', %q{
-      class Foo; end
-      def bar; end
-      $ruby = 1
-
-      def test = return defined?(Foo), defined?(bar), defined?($ruby)
-
-      test
-    }, insns: [:defined]
-  end
-
-  def test_defined_with_undefined_values
-    assert_compiles '[nil, nil, nil]', %q{
-      def test = return defined?(Foo), defined?(bar), defined?($ruby)
-
-      test
-    }, insns: [:defined]
-  end
-
-  def test_defined_with_method_call
-    assert_compiles '["method", nil]', %q{
-      def test = return defined?("x".reverse(1)), defined?("x".reverse(1).reverse)
-
-      test
-    }, insns: [:defined]
-  end
-
-  def test_defined_method_raise
-    assert_compiles '[nil, nil, nil]', %q{
-      class C
-        def assert_equal expected, actual
-          if expected != actual
-            raise "NO"
-          end
-        end
-
-        def test_defined_method
-          assert_equal(nil, defined?("x".reverse(1).reverse))
-        end
-      end
-
-      c = C.new
-      result = []
-      result << c.test_defined_method
-      result << c.test_defined_method
-      result << c.test_defined_method
-      result
-    }
-  end
-
-  def test_defined_yield
-    assert_compiles "nil", "defined?(yield)"
-    assert_compiles '[nil, nil, "yield"]', %q{
-      def test = defined?(yield)
-      [test, test, test{}]
-    }, call_threshold: 2, insns: [:defined]
-  end
-
-  def test_defined_yield_from_block
-    # This will do some EP hopping to find the local EP,
-    # so it's slightly different than doing it outside of a block.
-
-    assert_compiles '[nil, nil, "yield"]', %q{
-      def test
-        yield_self { yield_self { defined?(yield) } }
-      end
-
-      [test, test, test{}]
-    }, call_threshold: 2
-  end
-
-  def test_block_given_p
-    assert_compiles "false", "block_given?"
-    assert_compiles '[false, false, true]', %q{
-      def test = block_given?
-      [test, test, test{}]
-    }, call_threshold: 2, insns: [:opt_send_without_block]
-  end
-
-  def test_block_given_p_from_block
-    # This will do some EP hopping to find the local EP,
-    # so it's slightly different than doing it outside of a block.
-
-    assert_compiles '[false, false, true]', %q{
-      def test
-        yield_self { yield_self { block_given? } }
-      end
-
-      [test, test, test{}]
-    }, call_threshold: 2
-  end
-
-  def test_invokeblock_without_block_after_jit_call
-    assert_compiles '"no block given (yield)"', %q{
-      def test(*arr, &b)
-        arr.class
-        yield
-      end
-      begin
-        test
-      rescue => e
-        e.message
-      end
-    }
-  end
-
-  def test_putspecialobject_vm_core_and_cbase
-    assert_compiles '10', %q{
-      def test
-        alias bar test
-        10
-      end
-
-      test
-      bar
-    }, insns: [:putspecialobject]
-  end
-
-  def test_putspecialobject_const_base
-    assert_compiles '1', %q{
-      Foo = 1
-
-      def test = Foo
-
-      # First call: populates the constant cache
-      test
-      # Second call: triggers ZJIT compilation with warm cache
-      # RubyVM::ZJIT.assert_compiles will panic if this fails to compile
-      test
-    }, call_threshold: 2
-  end
-
-  def test_branchnil
-    assert_compiles '[2, nil]', %q{
-      def test(x)
-        x&.succ
-      end
-      [test(1), test(nil)]
-    }, call_threshold: 1, insns: [:branchnil]
-  end
-
-  def test_nil_nil
-    assert_compiles 'true', %q{
-      def test = nil.nil?
-      test
-    }, insns: [:opt_nil_p]
-  end
-
-  def test_non_nil_nil
-    assert_compiles 'false', %q{
-      def test = 1.nil?
-      test
-    }, insns: [:opt_nil_p]
-  end
-
-  def test_getspecial_last_match
-    assert_compiles '"hello"', %q{
-      def test(str)
-        str =~ /hello/
-        $&
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_match_pre
-    assert_compiles '"hello "', %q{
-      def test(str)
-        str =~ /world/
-        $`
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_match_post
-    assert_compiles '" world"', %q{
-      def test(str)
-        str =~ /hello/
-        $'
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_match_last_group
-    assert_compiles '"world"', %q{
-      def test(str)
-        str =~ /(hello) (world)/
-        $+
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_numbered_match_1
-    assert_compiles '"hello"', %q{
-      def test(str)
-        str =~ /(hello) (world)/
-        $1
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_numbered_match_2
-    assert_compiles '"world"', %q{
-      def test(str)
-        str =~ /(hello) (world)/
-        $2
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_numbered_match_nonexistent
-    assert_compiles 'nil', %q{
-      def test(str)
-        str =~ /(hello)/
-        $2
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_no_match
-    assert_compiles 'nil', %q{
-      def test(str)
-        str =~ /xyz/
-        $&
-      end
-      test("hello world")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_complex_pattern
-    assert_compiles '"123"', %q{
-      def test(str)
-        str =~ /(\d+)/
-        $1
-      end
-      test("abc123def")
-    }, insns: [:getspecial]
-  end
-
-  def test_getspecial_multiple_groups
-    assert_compiles '"456"', %q{
-      def test(str)
-        str =~ /(\d+)-(\d+)/
-        $2
-      end
-      test("123-456")
-    }, insns: [:getspecial]
-  end
-
   # tool/ruby_vm/views/*.erb relies on the zjit instructions a) being contiguous and
   # b) being reliably ordered after all the other instructions.
   def test_instruction_order
@@ -3880,653 +284,6 @@ class TestZJIT < Test::Unit::TestCase
     }
   end
 
-  def test_profile_under_nested_jit_call
-    assert_compiles '[nil, nil, 3]', %q{
-      def profile
-        1 + 2
-      end
-
-      def jit_call(flag)
-        if flag
-          profile
-        end
-      end
-
-      def entry(flag)
-        jit_call(flag)
-      end
-
-      [entry(false), entry(false), entry(true)]
-    }, call_threshold: 2
-  end
-
-  def test_bop_redefined
-    assert_runs '[3, :+, 100]', %q{
-      def test
-        1 + 2
-      end
-
-      test # profile opt_plus
-      [test, Integer.class_eval { def +(_) = 100 }, test]
-    }, call_threshold: 2
-  end
-
-  def test_bop_redefined_with_adjacent_patch_points
-    assert_runs '[15, :+, 100]', %q{
-      def test
-        1 + 2 + 3 + 4 + 5
-      end
-
-      test # profile opt_plus
-      [test, Integer.class_eval { def +(_) = 100 }, test]
-    }, call_threshold: 2
-  end
-
-  # ZJIT currently only generates a MethodRedefined patch point when the method
-  # is called on the top-level self.
-  def test_method_redefined_with_top_self
-    assert_runs '["original", "redefined"]', %q{
-      def foo
-        "original"
-      end
-
-      def test = foo
-
-      test; test
-
-      result1 = test
-
-      # Redefine the method
-      def foo
-        "redefined"
-      end
-
-      result2 = test
-
-      [result1, result2]
-    }, call_threshold: 2
-  end
-
-  def test_method_redefined_with_module
-    assert_runs '["original", "redefined"]', %q{
-      module Foo
-        def self.foo = "original"
-      end
-
-      def test = Foo.foo
-      test
-      result1 = test
-
-      def Foo.foo = "redefined"
-      result2 = test
-
-      [result1, result2]
-    }, call_threshold: 2
-  end
-
-  def test_module_name_with_guard_passes
-    assert_compiles '"Integer"', %q{
-      def test(mod)
-        mod.name
-      end
-
-      test(String)
-      test(Integer)
-    }, call_threshold: 2
-  end
-
-  def test_module_name_with_guard_side_exit
-    # This test demonstrates that the guard side exit works correctly
-    # In this case, when we call with a non-Class object, it should fall back to interpreter
-    assert_compiles '["String", "Integer", "Bar"]', %q{
-      class MyClass
-        def name = "Bar"
-      end
-
-      def test(mod)
-        mod.name
-      end
-
-      results = []
-      results << test(String)
-      results << test(Integer)
-      results << test(MyClass.new)
-
-      results
-    }, call_threshold: 2
-  end
-
-  def test_objtostring_calls_to_s_on_non_strings
-    assert_compiles '["foo", "foo"]', %q{
-      results = []
-
-      class Foo
-        def to_s
-          "foo"
-        end
-      end
-
-      def test(str)
-        "#{str}"
-      end
-
-      results << test(Foo.new)
-      results << test(Foo.new)
-
-      results
-    }
-  end
-
-  def test_objtostring_rewrite_does_not_call_to_s_on_strings
-    assert_compiles '["foo", "foo"]', %q{
-      results = []
-
-      class String
-        def to_s
-          "bad"
-        end
-      end
-
-      def test(foo)
-        "#{foo}"
-      end
-
-      results << test("foo")
-      results << test("foo")
-
-      results
-    }
-  end
-
-  def test_objtostring_rewrite_does_not_call_to_s_on_string_subclasses
-    assert_compiles '["foo", "foo"]', %q{
-      results = []
-
-      class StringSubclass < String
-        def to_s
-          "bad"
-        end
-      end
-
-      foo = StringSubclass.new("foo")
-
-      def test(str)
-        "#{str}"
-      end
-
-      results << test(foo)
-      results << test(foo)
-
-      results
-    }
-  end
-
-  def test_objtostring_profiled_string_fastpath
-    assert_compiles '"foo"', %q{
-      def test(str)
-        "#{str}"
-      end
-      test('foo'); test('foo') # profile as string
-    }, call_threshold: 2
-  end
-
-  def test_objtostring_profiled_string_subclass_fastpath
-    assert_compiles '"foo"', %q{
-      class MyString < String; end
-
-      def test(str)
-        "#{str}"
-      end
-
-      foo = MyString.new("foo")
-      test(foo); test(foo) # still profiles as string
-    }, call_threshold: 2
-  end
-
-  def test_objtostring_profiled_string_fastpath_exits_on_nonstring
-    assert_compiles '"1"', %q{
-      def test(str)
-        "#{str}"
-      end
-
-      test('foo') # profile as string
-      test(1)
-    }, call_threshold: 2
-  end
-
-  def test_objtostring_profiled_nonstring_calls_to_s
-    assert_compiles '"[1, 2, 3]"', %q{
-      def test(str)
-        "#{str}"
-      end
-
-      test([1,2,3]); # profile as nonstring
-      test([1,2,3]);
-    }, call_threshold: 2
-  end
-
-  def test_objtostring_profiled_nonstring_guard_exits_when_string
-    assert_compiles '"foo"', %q{
-      def test(str)
-        "#{str}"
-      end
-
-      test([1,2,3]); # profiles as nonstring
-      test('foo');
-    }, call_threshold: 2
-  end
-
-  def test_string_bytesize_with_guard
-    assert_compiles '5', %q{
-      def test(str)
-        str.bytesize
-      end
-
-      test('hello')
-      test('world')
-    }, call_threshold: 2
-  end
-
-  def test_string_bytesize_multibyte
-    assert_compiles '4', %q{
-      def test(s)
-        s.bytesize
-      end
-
-      test("💎")
-    }, call_threshold: 2
-  end
-
-  def test_nil_value_nil_opt_with_guard
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(nil)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_nil_value_nil_opt_with_guard_side_exit
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(nil)
-      test(nil)
-      test(1)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_true_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(true)
-      test(true)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_true_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(true)
-      test(true)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_false_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(false)
-      test(false)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_false_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(false)
-      test(false)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_integer_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(1)
-      test(2)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_integer_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(1)
-      test(2)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_float_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(1.0)
-      test(2.0)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_float_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(1.0)
-      test(2.0)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_symbol_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(:foo)
-      test(:bar)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_symbol_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(:foo)
-      test(:bar)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_class_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(String)
-      test(Integer)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_class_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(String)
-      test(Integer)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_module_nil_opt_with_guard
-    assert_compiles 'false', %q{
-      def test(val) = val.nil?
-
-      test(Enumerable)
-      test(Kernel)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_module_nil_opt_with_guard_side_exit
-    assert_compiles 'true', %q{
-      def test(val) = val.nil?
-
-      test(Enumerable)
-      test(Kernel)
-      test(nil)
-    }, call_threshold: 2, insns: [:opt_nil_p]
-  end
-
-  def test_basic_object_guard_works_with_immediate
-    assert_compiles 'NilClass', %q{
-      class Foo; end
-
-      def test(val) = val.class
-
-      test(Foo.new)
-      test(Foo.new)
-      test(nil)
-    }, call_threshold: 2
-  end
-
-  def test_basic_object_guard_works_with_false
-    assert_compiles 'FalseClass', %q{
-      class Foo; end
-
-      def test(val) = val.class
-
-      test(Foo.new)
-      test(Foo.new)
-      test(false)
-    }, call_threshold: 2
-  end
-
-  def test_string_concat
-    assert_compiles '"123"', %q{
-      def test = "#{1}#{2}#{3}"
-
-      test
-    }, insns: [:concatstrings]
-  end
-
-  def test_string_concat_empty
-    assert_compiles '""', %q{
-      def test = "#{}"
-
-      test
-    }, insns: [:concatstrings]
-  end
-
-  def test_regexp_interpolation
-    assert_compiles '/123/', %q{
-      def test = /#{1}#{2}#{3}/
-
-      test
-    }, insns: [:toregexp]
-  end
-
-  def test_new_range_non_leaf
-    assert_compiles '(0/1)..1', %q{
-      def jit_entry(v) = make_range_then_exit(v)
-
-      def make_range_then_exit(v)
-        range = (v..1)
-        super rescue range # TODO(alan): replace super with side-exit intrinsic
-      end
-
-      jit_entry(0)    # profile
-      jit_entry(0)    # compile
-      jit_entry(0/1r) # run without stub
-    }, call_threshold: 2
-  end
-
-  def test_raise_in_second_argument
-    assert_compiles '{ok: true}', %q{
-      def write(hash, key)
-        hash[key] = raise rescue true
-        hash
-      end
-
-      write({}, :ok)
-    }
-  end
-
-  def test_ivar_attr_reader_optimization_with_multi_ractor_mode
-    assert_compiles '42', %q{
-      class Foo
-        class << self
-          attr_accessor :bar
-
-          def get_bar
-            bar
-          rescue Ractor::IsolationError
-            42
-          end
-        end
-      end
-
-      Foo.bar = [] # needs to be a ractor unshareable object
-
-      def test
-        Foo.get_bar
-      end
-
-      test
-      test
-
-      Ractor.new { test }.value
-    }, call_threshold: 2
-  end
-
-  def test_ivar_get_with_multi_ractor_mode
-    assert_compiles '42', %q{
-      class Foo
-        def self.set_bar
-          @bar = [] # needs to be a ractor unshareable object
-        end
-
-        def self.bar
-          @bar
-        rescue Ractor::IsolationError
-          42
-        end
-      end
-
-      Foo.set_bar
-
-      def test
-        Foo.bar
-      end
-
-      test
-      test
-
-      Ractor.new { test }.value
-    }, call_threshold: 2
-  end
-
-  def test_ivar_get_with_already_multi_ractor_mode
-    assert_compiles '42', %q{
-      class Foo
-        def self.set_bar
-          @bar = [] # needs to be a ractor unshareable object
-        end
-
-        def self.bar
-          @bar
-        rescue Ractor::IsolationError
-          42
-        end
-      end
-
-      Foo.set_bar
-      r = Ractor.new {
-        Ractor.receive
-        Foo.bar
-      }
-
-      Foo.bar
-      Foo.bar
-
-      r << :go
-      r.value
-    }, call_threshold: 2
-  end
-
-  def test_ivar_set_with_multi_ractor_mode
-    assert_compiles '42', %q{
-      class Foo
-        def self.bar
-          _foo = 1
-          _bar = 2
-          begin
-            @bar = _foo + _bar
-          rescue Ractor::IsolationError
-            42
-          end
-        end
-      end
-
-      def test
-        Foo.bar
-      end
-
-      test
-      test
-
-      Ractor.new { test }.value
-    }
-  end
-
-  def test_struct_set
-    assert_compiles '[42, 42, :frozen_error]', %q{
-      C = Struct.new(:foo).new(1)
-
-      def test
-        C.foo = Object.new
-        42
-      end
-
-      r = [test, test]
-      C.freeze
-      r << begin
-        test
-      rescue FrozenError
-        :frozen_error
-      end
-    }, call_threshold: 2
-  end
-
-  def test_global_tracepoint
-    assert_compiles 'true', %q{
-      def foo = 1
-
-      foo
-      foo
-
-      called = false
-
-      tp = TracePoint.new(:return) { |event|
-        if event.method_id == :foo
-          called = true
-        end
-      }
-      tp.enable do
-        foo
-      end
-      called
-    }
-  end
-
-  def test_local_tracepoint
-    assert_compiles 'true', %q{
-      def foo = 1
-
-      foo
-      foo
-
-      called = false
-
-      tp = TracePoint.new(:return) { |_| called = true }
-      tp.enable(target: method(:foo)) do
-        foo
-      end
-      called
-    }
-  end
-
   def test_line_tracepoint_on_c_method
     assert_compiles '"[[:line, true]]"', %q{
       events = []
@@ -4573,203 +330,6 @@ class TestZJIT < Test::Unit::TestCase
     }
   end
 
-  def test_opt_case_dispatch
-    assert_compiles '[true, false]', %q{
-      def test(x)
-        case x
-        when :foo
-          true
-        else
-          false
-        end
-      end
-
-      results = []
-      results << test(:foo)
-      results << test(1)
-      results
-    }, insns: [:opt_case_dispatch]
-  end
-
-  def test_stack_overflow
-    assert_compiles 'nil', %q{
-      def recurse(n)
-        return if n == 0
-        recurse(n-1)
-        nil # no tail call
-      end
-
-      recurse(2)
-      recurse(2)
-      begin
-        recurse(20_000)
-      rescue SystemStackError
-        # Not asserting an exception is raised here since main
-        # thread stack size is environment-sensitive. Only
-        # that we don't crash or infinite loop.
-      end
-    }, call_threshold: 2
-  end
-
-  def test_invokeblock
-    assert_compiles '42', %q{
-      def test
-        yield
-      end
-      test { 42 }
-    }, insns: [:invokeblock]
-  end
-
-  def test_invokeblock_with_args
-    assert_compiles '3', %q{
-      def test(x, y)
-        yield x, y
-      end
-      test(1, 2) { |a, b| a + b }
-    }, insns: [:invokeblock]
-  end
-
-  def test_invokeblock_no_block_given
-    assert_compiles ':error', %q{
-      def test
-        yield rescue :error
-      end
-      test
-    }, insns: [:invokeblock]
-  end
-
-  def test_invokeblock_multiple_yields
-    assert_compiles "[1, 2, 3]", %q{
-      results = []
-      def test
-        yield 1
-        yield 2
-        yield 3
-      end
-      test { |x| results << x }
-      results
-    }, insns: [:invokeblock]
-  end
-
-  def test_ccall_variadic_with_multiple_args
-    assert_compiles "[1, 2, 3]", %q{
-      def test
-        a = []
-        a.push(1, 2, 3)
-        a
-      end
-
-      test
-      test
-    }, insns: [:opt_send_without_block]
-  end
-
-  def test_ccall_variadic_with_no_args
-    assert_compiles "[1]", %q{
-      def test
-        a = [1]
-        a.push
-      end
-
-      test
-      test
-    }, insns: [:opt_send_without_block]
-  end
-
-  def test_ccall_variadic_with_no_args_causing_argument_error
-    assert_compiles ":error", %q{
-      def test
-        format
-      rescue ArgumentError
-        :error
-      end
-
-      test
-      test
-    }, insns: [:opt_send_without_block]
-  end
-
-  def test_allocating_in_hir_c_method_is
-    assert_compiles ":k", %q{
-      # Put opt_new in a frame JIT code sets up that doesn't set cfp->pc
-      def a(f) = test(f)
-      def test(f) = (f.new if f)
-      # A parallel couple methods that will set PC at the same stack height
-      def second = third
-      def third = nil
-
-      a(nil)
-      a(nil)
-
-      class Foo
-        def self.new = :k
-      end
-
-      second
-
-      a(Foo)
-    }, call_threshold: 2, insns: [:opt_new]
-  end
-
-  def test_singleton_class_invalidation_annotated_ccall
-    assert_compiles '[false, true]', %q{
-      def define_singleton(obj, define)
-        if define
-          # Wrap in C method frame to avoid exiting JIT on defineclass
-          [nil].reverse_each do
-            class << obj
-              def ==(_)
-                true
-              end
-            end
-          end
-        end
-        false
-      end
-
-      def test(define)
-        obj = BasicObject.new
-        # This == call gets compiled to a CCall
-        obj == define_singleton(obj, define)
-      end
-
-      result = []
-      result << test(false)  # Compiles BasicObject#==
-      result << test(true)   # Should use singleton#== now
-      result
-    }, call_threshold: 2
-  end
-
-  def test_singleton_class_invalidation_optimized_variadic_ccall
-    assert_compiles '[1, 1000]', %q{
-      def define_singleton(arr, define)
-        if define
-          # Wrap in C method frame to avoid exiting JIT on defineclass
-          [nil].reverse_each do
-            class << arr
-              def push(x)
-                super(x * 1000)
-              end
-            end
-          end
-        end
-        1
-      end
-
-      def test(define)
-        arr = []
-        val = define_singleton(arr, define)
-        arr.push(val)  # This CCall should be invalidated if singleton was defined
-        arr[0]
-      end
-
-      result = []
-      result << test(false)  # Compiles Array#push as CCall
-      result << test(true)   # Singleton defined, CCall should be invalidated
-      result
-    }, call_threshold: 2
-  end
-
   def test_regression_cfp_sp_set_correctly_before_leaf_gc_call
     assert_compiles ':ok', %q{
       def check(l, r)
@@ -4799,60 +359,6 @@ class TestZJIT < Test::Unit::TestCase
     }, call_threshold: 14, num_profiles: 5
   end
 
-  def test_is_a_string_special_case
-    assert_compiles '[true, false, false, false, false, false]', %q{
-      def test(x)
-        x.is_a?(String)
-      end
-      test("foo")
-      [test("bar"), test(1), test(false), test(:foo), test([]), test({})]
-    }
-  end
-
-  def test_is_a_array_special_case
-    assert_compiles '[true, true, false, false, false, false, false]', %q{
-      def test(x)
-        x.is_a?(Array)
-      end
-      test([])
-      [test([1,2,3]), test([]), test(1), test(false), test(:foo), test("foo"), test({})]
-    }
-  end
-
-  def test_is_a_hash_special_case
-    assert_compiles '[true, true, false, false, false, false, false]', %q{
-      def test(x)
-        x.is_a?(Hash)
-      end
-      test({})
-      [test({:a => "b"}), test({}), test(1), test(false), test(:foo), test([]), test("foo")]
-    }
-  end
-
-  def test_is_a_hash_subclass
-    assert_compiles 'true', %q{
-      class MyHash < Hash
-      end
-      def test(x)
-        x.is_a?(Hash)
-      end
-      test({})
-      test(MyHash.new)
-    }
-  end
-
-  def test_is_a_normal_case
-    assert_compiles '[true, false]', %q{
-      class MyClass
-      end
-      def test(x)
-        x.is_a?(MyClass)
-      end
-      test("a")
-      [test(MyClass.new), test("a")]
-    }
-  end
-
   def test_exit_tracing
     # This is a very basic smoke test. The StackProf format
     # this option generates is external to us.