test_jit.rb: verify tested insns

and fix some untested insns

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@63323 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 102 insertions, 68 deletions

diff --git a/test/ruby/test_jit.rb b/test/ruby/test_jit.rb
index d4bd819c43..48a26e658f 100644
--- a/test/ruby/test_jit.rb
+++ b/test/ruby/test_jit.rb
@@ -7,7 +7,6 @@ require_relative '../lib/jit_support'
 class TestJIT < Test::Unit::TestCase
   include JITSupport
   # Ensure all supported insns can be compiled. Only basic tests are included.
-  # TODO: ensure --dump=insns includes the expected insn
 
   def setup
     unless JITSupport.supported?
@@ -16,11 +15,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_nop
-    assert_compile_once('nil rescue true', result_inspect: 'nil')
+    assert_compile_once('nil rescue true', result_inspect: 'nil', insns: %i[nop])
   end
 
   def test_compile_insn_local
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[setlocal_WC_0 getlocal_WC_0])
     begin;
       foo = 1
       foo
@@ -28,7 +27,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_blockparam
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '3', success_count: 2)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '3', success_count: 2, insns: %i[getblockparam setblockparam])
     begin;
       def foo(&b)
         a = b
@@ -45,18 +44,18 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_getspecial
-    assert_compile_once('$1', result_inspect: 'nil')
+    assert_compile_once('$1', result_inspect: 'nil', insns: %i[getspecial])
   end
 
   def test_compile_insn_setspecial
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true', insns: %i[setspecial])
     begin;
       true if nil.nil?..nil.nil?
     end;
   end
 
   def test_compile_insn_instancevariable
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[getinstancevariable setinstancevariable])
     begin;
       @foo = 1
       @foo
@@ -64,7 +63,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_classvariable
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[getclassvariable setclassvariable])
     begin;
       @@foo = 1
       @@foo
@@ -72,7 +71,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_constant
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[getconstant setconstant])
     begin;
       FOO = 1
       FOO
@@ -80,7 +79,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_global
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[getglobal setglobal])
     begin;
       $foo = 1
       $foo
@@ -88,24 +87,24 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_putnil
-    assert_compile_once('nil', result_inspect: 'nil')
+    assert_compile_once('nil', result_inspect: 'nil', insns: %i[putnil])
   end
 
   def test_compile_insn_putself
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'hello', success_count: 1)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'hello', success_count: 1, insns: %i[putself])
     begin;
       proc { print "hello" }.call
     end;
   end
 
   def test_compile_insn_putobject
-    assert_compile_once('0', result_inspect: '0') # putobject_OP_INT2FIX_O_0_C_
-    assert_compile_once('1', result_inspect: '1') # putobject_OP_INT2FIX_O_1_C_
-    assert_compile_once('2', result_inspect: '2')
+    assert_compile_once('0', result_inspect: '0', insns: %i[putobject_INT2FIX_0_])
+    assert_compile_once('1', result_inspect: '1', insns: %i[putobject_INT2FIX_1_])
+    assert_compile_once('2', result_inspect: '2', insns: %i[putobject])
   end
 
   def test_compile_insn_putspecialobject_putiseq
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'hello', success_count: 2)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'hello', success_count: 2, insns: %i[putspecialobject putiseq])
     begin;
       print proc {
         def method_definition
@@ -117,11 +116,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_putstring_concatstrings_tostring
-    assert_compile_once('"a#{}b" + "c"', result_inspect: '"abc"')
+    assert_compile_once('"a#{}b" + "c"', result_inspect: '"abc"', insns: %i[tostring])
   end
 
   def test_compile_insn_freezestring
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~'end;'}", stdout: 'true', success_count: 1)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~'end;'}", stdout: 'true', success_count: 1, insns: %i[freezestring])
     begin;
       # frozen_string_literal: true
       print proc { "#{true}".frozen? }.call
@@ -129,11 +128,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_toregexp
-    assert_compile_once('/#{true}/ =~ "true"', result_inspect: '0')
+    assert_compile_once('/#{true}/ =~ "true"', result_inspect: '0', insns: %i[toregexp])
   end
 
   def test_compile_insn_newarray
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '[1, 2, 3]')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '[1, 2, 3]', insns: %i[newarray])
     begin;
       a, b, c = 1, 2, 3
       [a, b, c]
@@ -141,31 +140,31 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_intern_duparray
-    assert_compile_once('[:"#{0}"] + [1,2,3]', result_inspect: '[:"0", 1, 2, 3]')
+    assert_compile_once('[:"#{0}"] + [1,2,3]', result_inspect: '[:"0", 1, 2, 3]', insns: %i[duparray])
   end
 
   def test_compile_insn_expandarray
-    assert_compile_once('y = [ true, false, nil ]; x, = y; x', result_inspect: 'true')
+    assert_compile_once('y = [ true, false, nil ]; x, = y; x', result_inspect: 'true', insns: %i[expandarray])
   end
 
   def test_compile_insn_concatarray
-    assert_compile_once('["t", "r", *x = "u", "e"].join', result_inspect: '"true"')
+    assert_compile_once('["t", "r", *x = "u", "e"].join', result_inspect: '"true"', insns: %i[concatarray])
   end
 
   def test_compile_insn_splatarray
-    assert_compile_once('[*(1..2)]', result_inspect: '[1, 2]')
+    assert_compile_once('[*(1..2)]', result_inspect: '[1, 2]', insns: %i[splatarray])
   end
 
   def test_compile_insn_newhash
-    assert_compile_once('a = 1; { a: a }', result_inspect: '{:a=>1}')
+    assert_compile_once('a = 1; { a: a }', result_inspect: '{:a=>1}', insns: %i[newhash])
   end
 
   def test_compile_insn_newrange
-    assert_compile_once('a = 1; 0..a', result_inspect: '0..1')
+    assert_compile_once('a = 1; 0..a', result_inspect: '0..1', insns: %i[newrange])
   end
 
   def test_compile_insn_pop
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[pop])
     begin;
       a = false
       b = 1
@@ -174,7 +173,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_dup
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '3')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '3', insns: %i[dup])
     begin;
       a = 1
       a&.+(2)
@@ -182,7 +181,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_dupn
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true', insns: %i[dupn])
     begin;
       klass = Class.new
       klass::X ||= true
@@ -190,11 +189,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_swap_topn
-    assert_compile_once('{}["true"] = true', result_inspect: 'true')
+    assert_compile_once('{}["true"] = true', result_inspect: 'true', insns: %i[swap topn])
   end
 
   def test_compile_insn_reverse
-    assert_compile_once('q, (w, e), r = 1, [2, 3], 4; e == 3', result_inspect: 'true')
+    assert_compile_once('q, (w, e), r = 1, [2, 3], 4; e == 3', result_inspect: 'true', insns: %i[reverse])
   end
 
   def test_compile_insn_reput
@@ -202,11 +201,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_setn
-    assert_compile_once('[nil][0] = 1', result_inspect: '1')
+    assert_compile_once('[nil][0] = 1', result_inspect: '1', insns: %i[setn])
   end
 
   def test_compile_insn_adjuststack
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: 'true', insns: %i[adjuststack])
     begin;
       x = [true]
       x[0] ||= nil
@@ -215,11 +214,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_defined
-    assert_compile_once('defined?(a)', result_inspect: 'nil')
+    assert_compile_once('defined?(a)', result_inspect: 'nil', insns: %i[defined])
   end
 
   def test_compile_insn_checkkeyword
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'true', success_count: 1)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: 'true', success_count: 1, insns: %i[checkkeyword])
     begin;
       def test(x: rand)
         x
@@ -237,28 +236,28 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_send
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '1', success_count: 2)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '1', success_count: 2, insns: %i[send])
     begin;
       print proc { yield_self { 1 } }.call
     end;
   end
 
   def test_compile_insn_opt_str_freeze
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"foo"')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"foo"', insns: %i[opt_str_freeze])
     begin;
       'foo'.freeze
     end;
   end
 
   def test_compile_insn_opt_str_uminus
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"bar"')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"bar"', insns: %i[opt_str_uminus])
     begin;
       -'bar'
     end;
   end
 
   def test_compile_insn_opt_newarray_max
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '2')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '2', insns: %i[opt_newarray_max])
     begin;
       a = 1
       b = 2
@@ -267,7 +266,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_opt_newarray_min
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '1', insns: %i[opt_newarray_min])
     begin;
       a = 1
       b = 2
@@ -276,11 +275,11 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_opt_send_without_block
-    assert_compile_once('print', result_inspect: 'nil')
+    assert_compile_once('print', result_inspect: 'nil', insns: %i[opt_send_without_block])
   end
 
   def test_compile_insn_invokesuper
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '3', success_count: 4)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '3', success_count: 4, insns: %i[invokesuper])
     begin;
       mod = Module.new {
         def test
@@ -298,7 +297,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_invokeblock_leave
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '2', success_count: 2)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '2', success_count: 2, insns: %i[invokeblock leave])
     begin;
       def foo
         yield
@@ -308,7 +307,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_throw
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '4', success_count: 2)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '4', success_count: 2, insns: %i[throw])
     begin;
       def test
         proc do
@@ -325,15 +324,15 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_jump_branchif
-    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: 'nil')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: 'nil', insns: %i[jump branchif])
     begin;
       a = false
-      1 + 1 while false
+      1 + 1 while a
     end;
   end
 
   def test_compile_insn_branchunless
-    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '1')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '1', insns: %i[branchunless])
     begin;
       a = true
       if a
@@ -345,7 +344,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_branchnil
-    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '3')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '3', insns: %i[branchnil])
     begin;
       a = 2
       a&.+(1)
@@ -353,7 +352,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_checktype
-    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '"42"')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~'end;'}", result_inspect: '"42"', insns: %i[checktype])
     begin;
       a = '2'
       "4#{a}"
@@ -361,43 +360,43 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_inlinecache
-    assert_compile_once('Struct', result_inspect: 'Struct')
+    assert_compile_once('Struct', result_inspect: 'Struct', insns: %i[getinlinecache setinlinecache])
   end
 
   def test_compile_insn_once
-    assert_compile_once('/#{true}/o =~ "true" && $~.to_a', result_inspect: '["true"]')
+    assert_compile_once('/#{true}/o =~ "true" && $~.to_a', result_inspect: '["true"]', insns: %i[once])
   end
 
   def test_compile_insn_checkmatch_opt_case_dispatch
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"world"')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '"world"', insns: %i[opt_case_dispatch])
     begin;
       case 'hello'
-      when /hello/
+      when 'hello'
         'world'
       end
     end;
   end
 
   def test_compile_insn_opt_calc
-    assert_compile_once('4 + 2 - ((2 * 3 / 2) % 2)', result_inspect: '5')
+    assert_compile_once('4 + 2 - ((2 * 3 / 2) % 2)', result_inspect: '5', insns: %i[opt_plus opt_minus opt_mult opt_div opt_mod])
     assert_compile_once('4 + 2', result_inspect: '6')
   end
 
   def test_compile_insn_opt_cmp
-    assert_compile_once('(1 == 1) && (1 != 2)', result_inspect: 'true')
+    assert_compile_once('(1 == 1) && (1 != 2)', result_inspect: 'true', insns: %i[opt_eq opt_neq])
   end
 
   def test_compile_insn_opt_rel
-    assert_compile_once('1 < 2 && 1 <= 1 && 2 > 1 && 1 >= 1', result_inspect: 'true')
+    assert_compile_once('1 < 2 && 1 <= 1 && 2 > 1 && 1 >= 1', result_inspect: 'true', insns: %i[opt_lt opt_le opt_gt opt_ge])
   end
 
   def test_compile_insn_opt_ltlt
-    assert_compile_once('[1] << 2', result_inspect: '[1, 2]')
+    assert_compile_once('[1] << 2', result_inspect: '[1, 2]', insns: %i[opt_ltlt])
   end
 
   def test_compile_insn_opt_aref
     # optimized call (optimized JIT) -> send call
-    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '21', success_count: 2, min_calls: 1)
+    assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: '21', success_count: 2, min_calls: 1, insns: %i[opt_aref])
     begin;
       obj = Object.new
       def obj.[](h)
@@ -425,7 +424,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_opt_aset
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '5')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '5', insns: %i[opt_aset])
     begin;
       hash = { '1' => 2 }
       (hash['2'] = 2) + (hash[1.to_s] = 3)
@@ -433,7 +432,7 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_opt_length_size
-    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '4')
+    assert_compile_once("#{<<~"begin;"}\n#{<<~"end;"}", result_inspect: '4', insns: %i[opt_length])
     begin;
       array = [1, 2]
       array.length + array.size
@@ -441,23 +440,23 @@ class TestJIT < Test::Unit::TestCase
   end
 
   def test_compile_insn_opt_empty_p
-    assert_compile_once('[].empty?', result_inspect: 'true')
+    assert_compile_once('[].empty?', result_inspect: 'true', insns: %i[opt_empty_p])
   end
 
   def test_compile_insn_opt_succ
-    assert_compile_once('1.succ', result_inspect: '2')
+    assert_compile_once('1.succ', result_inspect: '2', insns: %i[opt_succ])
   end
 
   def test_compile_insn_opt_not
-    assert_compile_once('!!true', result_inspect: 'true')
+    assert_compile_once('!!true', result_inspect: 'true', insns: %i[opt_not])
   end
 
   def test_compile_insn_opt_regexpmatch1
-    assert_compile_once("/true/ =~ 'true'", result_inspect: '0')
+    assert_compile_once("/true/ =~ 'true'", result_inspect: '0', insns: %i[opt_regexpmatch1])
   end
 
   def test_compile_insn_opt_regexpmatch2
-    assert_compile_once("'true' =~ /true/", result_inspect: '0')
+    assert_compile_once("'true' =~ /true/", result_inspect: '0', insns: %i[opt_regexpmatch2])
   end
 
   def test_compile_insn_opt_call_c_function
@@ -589,17 +588,17 @@ class TestJIT < Test::Unit::TestCase
   private
 
   # The shortest way to test one proc
-  def assert_compile_once(script, result_inspect:)
+  def assert_compile_once(script, result_inspect:, insns: [])
     if script.match?(/\A\n.+\n\z/m)
       script = script.gsub(/^/, '  ')
     else
       script = " #{script} "
     end
-    assert_eval_with_jit("p proc {#{script}}.call", stdout: "#{result_inspect}\n", success_count: 1)
+    assert_eval_with_jit("p proc {#{script}}.call", stdout: "#{result_inspect}\n", success_count: 1, insns: insns, uplevel: 4)
   end
 
   # Shorthand for normal test cases
-  def assert_eval_with_jit(script, stdout: nil, success_count:, min_calls: 1)
+  def assert_eval_with_jit(script, stdout: nil, success_count:, min_calls: 1, insns: [], uplevel: 3)
     out, err = eval_with_jit(script, verbose: 1, min_calls: min_calls)
     actual = err.scan(/^#{JIT_SUCCESS_PREFIX}:/).size
 
@@ -616,6 +615,15 @@ class TestJIT < Test::Unit::TestCase
       end
     end
 
+    # Make sure that the script has insns expected to be tested
+    used_insns = method_insns(script)
+    insns.each do |insn|
+      unless used_insns.include?(insn)
+        $stderr.puts
+        warn "'#{insn}' insn is not included in the script. Actual insns are: #{used_insns.join(' ')}\n", uplevel: uplevel
+      end
+    end
+
     assert_equal(
       success_count, actual,
       "Expected #{success_count} times of JIT success, but succeeded #{actual} times.\n\n"\
@@ -626,6 +634,32 @@ class TestJIT < Test::Unit::TestCase
     end
   end
 
+  # Collect block's insns or defined method's insns, which are expected to be JIT-ed.
+  def method_insns(script)
+    insns = []
+    RubyVM::InstructionSequence.compile(script).to_a.last.each do |(insn, *args)|
+      case insn
+      when :putiseq, :send
+        insns += collect_insns(args.last)
+      end
+    end
+    insns.uniq
+  end
+
+  # Recursively collect insns in iseq_array
+  def collect_insns(iseq_array)
+    return [] if iseq_array.nil?
+
+    insns = iseq_array.last.select { |x| x.is_a?(Array) }.map(&:first)
+    iseq_array.last.each do |(insn, *args)|
+      case insn
+      when :putiseq, :send
+        insns += collect_insns(args.last)
+      end
+    end
+    insns
+  end
+
   # Run Ruby script with --jit-wait (Synchronous JIT compilation).
   # Returns [stdout, stderr]
   def eval_with_jit(env = nil, script, **opts)