1 files changed, 90 insertions, 16 deletions

diff --git a/test/-ext-/debug/test_debug.rb b/test/-ext-/debug/test_debug.rb
index 4c45057b5d..c9263d76fa 100644
--- a/test/-ext-/debug/test_debug.rb
+++ b/test/-ext-/debug/test_debug.rb
@@ -1,44 +1,48 @@
+# frozen_string_literal: false
 require 'test/unit'
 require '-test-/debug'
 
 class TestDebug < Test::Unit::TestCase
 
-  def binds_check binds
+  def binds_check(binds, msg = nil)
     count = Hash.new(0)
-    assert_instance_of(Array, binds)
+    assert_instance_of(Array, binds, msg)
     binds.each{|(_self, bind, klass, iseq, loc)|
       if _self == self
         count[:self] += 1
       end
 
       if bind
-        assert_instance_of(Binding, bind)
+        assert_instance_of(Binding, bind, msg)
         count[:bind] += 1
       end
 
       if klass
-        assert(klass.instance_of?(Module) || klass.instance_of?(Class))
+        assert(klass.instance_of?(Module) || klass.instance_of?(Class), msg)
         count[:class] += 1
       end
 
       if iseq
         count[:iseq] += 1
-        assert_instance_of(RubyVM::InstructionSequence, iseq)
+        assert_instance_of(RubyVM::InstructionSequence, iseq, msg)
 
-        # check same location
-        assert_equal(loc.path, iseq.path)
-        assert_equal(loc.absolute_path, iseq.absolute_path)
-        assert_equal(loc.label, iseq.label)
-        assert_operator(loc.lineno, :>=, iseq.first_lineno)
+        # Backtraces and source locations don't match for :c_trace methods
+        unless iseq.disasm.include?('C_TRACE')
+          # check same location
+          assert_equal(loc.path, iseq.path, msg)
+          assert_equal(loc.absolute_path, iseq.absolute_path, msg)
+          #assert_equal(loc.label, iseq.label, msg)
+          assert_operator(loc.lineno, :>=, iseq.first_lineno, msg)
+        end
       end
 
-      assert_instance_of(Thread::Backtrace::Location, loc)
+      assert_instance_of(Thread::Backtrace::Location, loc, msg)
 
     }
-    assert_operator(0, :<, count[:self])
-    assert_operator(0, :<, count[:bind])
-    assert_operator(0, :<, count[:iseq])
-    assert_operator(0, :<, count[:class])
+    assert_operator(0, :<, count[:self], msg)
+    assert_operator(0, :<, count[:bind], msg)
+    assert_operator(0, :<, count[:iseq], msg)
+    assert_operator(0, :<, count[:class], msg)
   end
 
   def test_inspector_open
@@ -53,6 +57,76 @@ class TestDebug < Test::Unit::TestCase
   def test_inspector_open_in_eval
     bug7635 = '[ruby-core:51640]'
     binds = inspector_in_eval
-    binds_check binds
+    binds_check binds, bug7635
+  end
+
+  class MyRelation
+    include Enumerable
+
+    def each
+      yield :each_entry
+    end
+  end
+
+  def test_lazy_block
+    x = MyRelation.new.any? do
+      Bug::Debug.inspector
+      true
+    end
+    assert_equal true, x, '[Bug #15105]'
   end
 end
+
+# This is a YJIT test, but we can't test this without a C extension that calls
+# rb_debug_inspector_open(), so we're testing it using "-test-/debug" here.
+class TestDebugWithYJIT < Test::Unit::TestCase
+  class LocalSetArray
+    def to_a
+      Bug::Debug.inspector.each do |_, binding,|
+        binding.local_variable_set(:local, :ok) if binding
+      end
+      [:ok]
+    end
+  end
+
+  class DebugArray
+    def to_a
+      Bug::Debug.inspector
+      [:ok]
+    end
+  end
+
+  def test_yjit_invalidates_getlocal_after_splatarray
+    val = getlocal_after_splatarray(LocalSetArray.new)
+    assert_equal [:ok, :ok], val
+  end
+
+  def test_yjit_invalidates_setlocal_after_splatarray
+    val = setlocal_after_splatarray(DebugArray.new)
+    assert_equal [:ok], val
+  end
+
+  def test_yjit_invalidates_setlocal_after_proc_call
+    val = setlocal_after_proc_call(proc { Bug::Debug.inspector; :ok })
+    assert_equal :ok, val
+  end
+
+  private
+
+  def getlocal_after_splatarray(array)
+    local = 1
+    [*array, local]
+  end
+
+  def setlocal_after_splatarray(array)
+    local = *array # setlocal followed by splatarray
+    itself # split a block using a C call
+    local # getlocal
+  end
+
+  def setlocal_after_proc_call(block)
+    local = block.call # setlocal followed by OPTIMIZED_METHOD_TYPE_CALL
+    itself # split a block using a C call
+    local # getlocal
+  end
+end if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?