Use TracePoint.allow_reentry to support TracePoint events while eval

Author: marshall-lee

ext/byebug/threads.c

@@ -180,8 +180,16 @@ release_lock(void)
 static VALUE
 Unlock(VALUE self)
 {
+  debug_context_t *dc;
+  VALUE context;
+
   UNUSED(self);
 
+  thread_context_lookup(rb_thread_current(), &context);
+  Data_Get_Struct(context, debug_context_t, dc);
+
+  CTX_FL_SET(dc, CTX_FL_IGNORE);
+
   release_lock();
 
   return locker;
@@ -209,6 +217,8 @@ Lock(VALUE self)
 
   acquire_lock(dc);
 
+  CTX_FL_UNSET(dc, CTX_FL_IGNORE);
+
   return locker;
 }
 

lib/byebug/helpers/eval.rb

@@ -88,14 +88,12 @@ def warning_msg(exception)
       # creating new threads won't be properly evaluated because new threads
       # will get blocked by byebug's main thread.
       #
-      def allowing_other_threads
+      def allowing_other_threads(&block)
         Byebug.unlock
 
-        res = yield
-
+        tracepoint_allow_reentry(&block)
+      ensure
         Byebug.lock
-
-        res
       end
 
       #
@@ -121,6 +119,16 @@ def safe_to_s(var)
       rescue StandardError
         "*Error in evaluation*"
       end
+
+      if TracePoint.respond_to?(:allow_reentry)
+        def tracepoint_allow_reentry(&block)
+          TracePoint.allow_reentry(&block)
+        end
+      else
+        def tracepoint_allow_reentry
+          yield
+        end
+      end
     end
   end
 end

test/commands/eval_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Byebug
+  #
+  # Tests expression evaluation.
+  #
+  class EvalTest < TestCase
+    def program
+      strip_line_numbers <<-RUBY
+         1:  module Byebug
+         2:    Foo = "Foo constant"
+         3:    foo = :foo_variable
+         4:    byebug
+         5:  end
+      RUBY
+    end
+
+    def test_eval_prints_values
+      enter "Foo", "foo"
+      debug_code(program)
+      check_output_includes('"Foo constant"')
+      check_output_includes(":foo_variable")
+    end
+  end
+
+  #
+  # Tests expression evalution of the code that uses TracePoint.
+  #
+  class EvalTracePointClassTest < TestCase
+    def program
+      strip_line_numbers <<-RUBY
+         1:  result = :tp_class_not_called
+         2:  autoload :Foo, "./foo"
+         3:  TracePoint.new(:class) { |tp| result = :tp_class_called }.enable
+         4:  byebug
+         5:  result
+      RUBY
+    end
+
+    def foo_program
+      strip_line_numbers <<-RUBY
+         1:  module Foo
+         2:    def self.bar
+         3:      "Foo.bar called"
+         4:    end
+         5:  end
+      RUBY
+    end
+
+    def test_eval_triggers_class_tracepoint
+      skip unless TracePoint.respond_to?(:allow_reentry) # TracePoint.allow_reentry only supported in >= 3.1
+
+      with_new_file("foo.rb", foo_program) do
+        enter "Foo.bar", "result"
+        debug_code(program)
+        check_output_includes('"Foo.bar called"')
+        check_output_includes(":tp_class_called")
+      end
+    end
+  end
+end