Rename all the things

Author: oxinabox

README.md

@@ -6,9 +6,10 @@
 
 # Commands
 
-`@iron_debug foo()`: run `foo()` inside the debugger.
+`@run foo()`: run `foo()` inside the debugger.
 When a breakpoint is hit, then you will be given an Iron REPL to work with-in,
 allowing you to view/manipulate the arguments.
+`@enter foo()` performs similarly, after immediately breaking on the first line.
 
 Within this you can read (and write) variables,
  - Step-Next: to move to the next IR statement
@@ -21,12 +22,12 @@ Within this you can read (and write) variables,
 
  - `set_breakpoint!([function|method])`: Set a breakpoint on call to the argument
  - `set_breakpoint!(filename, line number)`: Set a breakpoint on the given line in the given function
- - `set_nodebug!([function|module])`: Disable debugging in the given function/module
+ - `set_uninstrumented!([function|module])`: Disable debugging in the given function/module
     - Not having debugging enabled for modules/functions you do not need to debug massively speeds up the running of your program.
     - However, debugging is fully disabled for those modules/functions, so if those functions would then call functions you do want to debug (say by using `map`) then that will also not be caught by the debugger.
- - `list_breakpoints()`, `list_nodebugs()`: list all the breakpoints/nodebugs
- - `rm_breakpoint!(arg...)`, `rm_nodebug!(args...)`: remove breakpoints/nodebugs. Takes same arguments as `set_...`.
- - `clear_breakpoints!()`, `clear_nodebugs!()`: remove all breakpoints/nodebugs.
+ - `list_breakpoints()`, `list_uninstrumenteds()`: list all the breakpoints/uninstrumenteds
+ - `rm_breakpoint!(arg...)`, `rm_uninstrumented!(args...)`: remove breakpoints/uninstrumenteds. Takes same arguments as `set_...`.
+ - `clear_breakpoints!()`, `clear_uninstrumenteds!()`: remove all breakpoints/uninstrumenteds.
 
 
 [![asciicast](https://asciinema.org/a/DxgPaaLQQYVV5xXCMuwF5Aa36.svg)](https://asciinema.org/a/DxgPaaLQQYVV5xXCMuwF5Aa36)

src/MagneticReadHead.jl

@@ -9,7 +9,7 @@ using CodeTracking
 using Revise: Revise
 using OrderedCollections
 
-export @iron_debug
+export @run, @enter
 
 
 include("utils.jl")
@@ -29,20 +29,33 @@ include("breakpoints.jl")
 
 struct UserAbortedException <: Exception end
 
-
-macro iron_debug(body)
-    quote
-        ctx = HandEvalCtx($(__module__), StepContinue)
-        try
-            return Cassette.recurse(ctx, ()->$(esc(body)))
-        catch err
-            err isa UserAbortedException || rethrow()
-            nothing
-        finally
-            # Disable any stepping left-over
-            ctx.metadata.stepping_mode =  StepContinue
-        end
+function iron_debug(body, _module, mode)
+    ctx = HandEvalCtx(_module, mode)
+    try
+        return Cassette.recurse(ctx, body)
+    catch err
+        err isa UserAbortedException || rethrow()
+        nothing
+    finally
+        # Disable any stepping left-over
+        ctx.metadata.stepping_mode =  StepContinue
     end
 end
 
+"""
+    @run the_code
+Run until the_code until a breakpoint is hit.
+"""
+macro run(body)
+    :(iron_debug(()->$(esc(body)), $(__module__), StepContinue))
+end
+
+"""
+    @enter the_code
+Begin debugging and break on the start of the_code.
+"""
+macro enter(body)
+    :(iron_debug(()->$(esc(body)), $(__module__), StepContinue))
+end
+
 end # module

src/breakpoints.jl

@@ -25,12 +25,12 @@ function set_breakpoint!(the_rules::BreakpointRules, args...)
     return append!(the_rules.breakon_rules, rules(args...))
 end
 
-function set_nodebug!(the_rules::BreakpointRules, arg::T) where T
+function set_uninstrumented!(the_rules::BreakpointRules, arg::T) where T
     T !== Method || throw(ArgumentError("Disabling instrumentation per method, is not supported."))
     return push!(the_rules.no_instrument_rules, Rule(arg))
 end
 
-for (name, list) in ((:breakpoint, :breakon_rules), (:nodebug, :no_instrument_rules))
+for (name, list) in ((:breakpoint, :breakon_rules), (:uninstrumented, :no_instrument_rules))
     set! = Symbol(:set_, name, :!)
     @eval export $(set!)
     @eval $(set!)(args...) = $(set!)(GLOBAL_BREAKPOINT_RULES, args...)
@@ -47,7 +47,7 @@ for (name, list) in ((:breakpoint, :breakon_rules), (:nodebug, :no_instrument_ru
         end
         return the_rules.$list
     end
-    
+
     list_all = Symbol(:list_, name,:s)
     @eval export $(list_all)
     @eval $(list_all)()=$(list_all)(GLOBAL_BREAKPOINT_RULES)

src/inner_repl.jl

@@ -18,8 +18,8 @@ end
 ###############
 
 function get_user_input(io=stdin)
-    printstyled("iron>"; color=:light_red)
-    
+    printstyled("debug> "; color=:light_red)
+
     ast = nothing
     line = ""
     while true

test/setup_ui_test_module.jl

@@ -60,7 +60,7 @@ function reset_patched_functions!()
     @eval MagneticReadHead function breakpoint_hit(meth, statement_ind)
         return nothing
     end
-    
+
     @eval MagneticReadHead function better_readline(io)
         # This is not technically the same as the better_readline defined in utils
         # but we will only be doing automated tests so that doesn't matter.

test/test_behavour.jl

@@ -10,9 +10,9 @@ end
 
 @testset "Should not block throwing errors" begin
     foo() = throw(DemoException())
-    @test_throws(DemoException, (@iron_debug foo()))
+    @test_throws(DemoException, (@run foo()))
 
 
     bar() = map(_->foo(), 1:10)
-    @test_throws(DemoException, (@iron_debug foo()))
+    @test_throws(DemoException, (@run bar()))
 end

test/test_ui.jl

@@ -1,11 +1,11 @@
 include("setup_ui_test_module.jl")
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "No breakpoints" begin
     make_readline_patch([])
     record = make_recording_breakpoint_hit_patch()
 
-    @iron_debug eg1()
+    @run eg1()
     @test record == []
 #end
 
@@ -15,96 +15,96 @@ clear_breakpoints!(); clear_nodebugs!()
     set_breakpoint!(eg2)
 
     @show list_breakpoints()
-    @iron_debug eg1()
+    @run eg1()
     @test first(record).f == eg2
 #end
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "Two breakpoints" begin
     make_readline_patch(["CC", "CC"])
     record = make_recording_breakpoint_hit_patch()
     set_breakpoint!(eg2)
     set_breakpoint!(eg3)
-    @iron_debug eg1()
+    @run eg1()
     @test first.(record) == [eg2, eg3]
 #end
 
 ###################################################
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "No breakpoints, With no instrumenting of Base" begin
     make_readline_patch([])
     record = make_recording_breakpoint_hit_patch()
-    set_nodebug!(Base)
-    @iron_debug eg1()
+    set_uninstrumented!(Base)
+    @run eg1()
     @test record == []
 #end
 ###########################
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "breakpoint by file and linenum" begin
     make_readline_patch(["CC"])
     record = make_recording_breakpoint_hit_patch()
 
     set_breakpoint!("demo.jl", 9)
     @test !isempty(list_breakpoints())
-    @iron_debug eg1()
+    @run eg1()
     @test first.(record) == [eg2]
 #end
 
 
 #########################################################
  # Stepping Mode
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "step in" begin
     make_readline_patch(["SI", "CC"])
     record = make_recording_breakpoint_hit_patch()
 
     set_breakpoint!(eg2)
-    @iron_debug eg1()
+    @run eg1()
     @test first.(record) == [eg2, eg21]
 #end
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "step out" begin
     set_breakpoint!(eg2)
     make_readline_patch(["SO", "CC"])
     record = make_recording_breakpoint_hit_patch()
 
-    @iron_debug eg1()
+    @run eg1()
     @test first.(record) == [eg2, eg1]
 #end
 
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "step next" begin
     set_breakpoint!(eg2)
     make_readline_patch(["SN", "SN", "CC"])
     record = make_recording_breakpoint_hit_patch()
 
-    @iron_debug eg1()
+    @run eg1()
     @test first.(record) == [eg2, eg2, eg2]
 #end
 
 
 ###############################################
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "Influence calling enviroment" begin
     global zzz = 10
     make_readline_patch(["zzz = 20", "CC"])
 
     set_breakpoint!(eg2)
-    @iron_debug eg1()
+    @run eg1()
     @test zzz==20
 #end
 
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "Abort" begin
     make_readline_patch(["XX"])
 
     set_breakpoint!(eg2)
-    @test nothing==@iron_debug eg1()
+    @test nothing==@run eg1()
 #end
 
 ########################################
@@ -116,12 +116,12 @@ function var_demo1(x)
     z=1
 end
 
-clear_breakpoints!(); clear_nodebugs!()
+clear_breakpoints!(); clear_uninstrumenteds!()
 #@testset "Variables stepping" begin
     set_breakpoint!(var_demo1)
     make_readline_patch(["SN", "SN", "SN", "CC"])
     record = make_recording_breakpoint_hit_patch()
-    @iron_debug var_demo1(5)
+    @run var_demo1(5)
 
     @test record[1].variables == LittleDict(:x=>5)
     @test record[2].variables == LittleDict(:x=>5, :z=>10)