From 188ece8c29df6130c7d861119d2e1458d5b54718 Mon Sep 17 00:00:00 2001 From: Kristoffer Carlsson Date: Fri, 17 Jul 2026 22:22:24 +0200 Subject: [PATCH] Restore UI tests on supported Julia versions --- .github/workflows/CI.yml | 8 +- Project.toml | 10 +- README.md | 20 +- src/Debugger.jl | 6 + src/commands.jl | 28 +- src/printing.jl | 61 +++-- src/repl.jl | 64 ++--- test/misc.jl | 12 +- test/runtests.jl | 2 +- test/ui.jl | 173 ++++++++---- test/ui/big_repr_ui.multiout | 18 +- test/ui/bp_ui.multiout | 16 +- test/ui/history_apply.multiout | 20 +- test/ui/history_break_error.multiout | 42 +-- test/ui/history_floor.multiout | 8 +- test/ui/history_gcd.multiout | 116 ++++---- test/ui/history_kw.multiout | 12 +- test/ui/history_noinfo.multiout | 396 +++++++++++++-------------- test/ui/history_until.multiout | 26 +- test/ui/history_updown.multiout | 76 ++--- 20 files changed, 608 insertions(+), 506 deletions(-) diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml index e842eaa..c71134e 100644 --- a/.github/workflows/CI.yml +++ b/.github/workflows/CI.yml @@ -11,10 +11,14 @@ jobs: test: name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }} runs-on: ${{ matrix.os }} + env: + DEBUGGER_RUN_UI_TESTS: ${{ matrix.version == '1' }} strategy: fail-fast: false matrix: version: + - '1.10' + - '1.11' - '1' - 'nightly' os: @@ -22,7 +26,7 @@ jobs: - macOS-latest - windows-latest arch: - - x64 + - default steps: - uses: actions/checkout@v6 - uses: julia-actions/setup-julia@v3 @@ -31,6 +35,8 @@ jobs: arch: ${{ matrix.arch }} - uses: julia-actions/cache@v2 - uses: julia-actions/julia-buildpkg@v1 + - name: Use TerminalRegressionTests Julia 1.12 support branch + run: julia --project=. --color=yes -e 'using Pkg; Pkg.add(Pkg.PackageSpec(url="https://github.com/JuliaDebug/TerminalRegressionTests.jl", rev="kc/terminal-1.12-support"))' - uses: julia-actions/julia-runtest@v1 - uses: julia-actions/julia-processcoverage@v1 - uses: codecov/codecov-action@v5 diff --git a/Project.toml b/Project.toml index 6eeff64..30cc5df 100644 --- a/Project.toml +++ b/Project.toml @@ -1,6 +1,6 @@ name = "Debugger" uuid = "31a5f54b-26ea-5ae9-a837-f05ce5417438" -version = "0.7.16" +version = "0.8.0" [deps] CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2" @@ -11,11 +11,15 @@ Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" tree_sitter_julia_jll = "52be201e-a5e9-5cfe-8bf2-2dc4b062171c" +[sources] +TerminalRegressionTests = {url = "https://github.com/JuliaDebug/TerminalRegressionTests.jl", rev = "kc/terminal-1.12-support"} + [compat] CodeTracking = "2, 3" Highlights = "0.6" -JuliaInterpreter = "0.10" -julia = "1.6" +JuliaInterpreter = "0.10, 0.11" +TerminalRegressionTests = "0.3" +julia = "1.10" tree_sitter_julia_jll = "0.25.0" [extras] diff --git a/README.md b/README.md index bf79893..740f73c 100644 --- a/README.md +++ b/README.md @@ -76,21 +76,21 @@ Evaluation: - `w` - `w add expr`: add an expression to the watch list - `w`: show all watch expressions evaluated in the current function's context - - `w rm [i::Int]`: remove all or the `i`:th watch expression + - `w rm [i::Int]`: remove all or the `i`-th watch expression Breakpoints: - `bp` - `bp add` - - `bp add "file.jl":line [cond]`: add a breakpoint att file `file.jl` on line `line` with condition `cond` - - `bp add func [:line] [cond]`: add a breakpoint to function `func` at line `line` (defaulting to first line) with condition `cond` - - `bp add func(::Float64, Int)[:line] [cond]`: add a breakpoint to methods matching the signature at line `line` (defaulting to first line) with condition `cond` + - `bp add "file.jl":line [cond]`: add a breakpoint at file `file.jl` on line `line` with condition `cond` + - `bp add func [:line] [cond]`: add a breakpoint to function `func` at line `line` (defaulting to first line) with condition `cond` + - `bp add func(::Float64, Int)[:line] [cond]`: add a breakpoint to methods matching the signature at line `line` (defaulting to first line) with condition `cond` - `bp add func(x, y)[:line] [cond]`: add a breakpoint to the method matching the types of the local variable `x`, `y` etc with condition `cond` - - `bp add line [cond]` add a breakpoint to `line` of the file of the current function with condition `cond` + - `bp add line [cond]`: add a breakpoint to `line` of the file of the current function with condition `cond` - `bp` show all breakpoints - - `bp rm [i::Int]`: remove all or the `i`:th breakpoint - - `bp toggle [i::Int]`: toggle all or the `i`:th breakpoint - - `bp disable [i::Int]`: disable all or the `i`:th breakpoint - - `bp enable [i::Int]`: enable all or the `i`:th breakpoint + - `bp rm [i::Int]`: remove all or the `i`-th breakpoint + - `bp toggle [i::Int]`: toggle all or the `i`-th breakpoint + - `bp disable [i::Int]`: disable all or the `i`-th breakpoint + - `bp enable [i::Int]`: enable all or the `i`-th breakpoint - `bp on/off` - `bp on/off error` - turn on or off break on error - `bp on/off throw` - turn on or off break on throw @@ -239,7 +239,7 @@ union!(JuliaInterpreter.compiled_modules, SomePackage) The source code preview is syntax highlighted and this highlighting has some options. The theme can be set by calling `Debugger.set_theme(theme)` where `theme` is a [Highlights.jl theme](https://highlights.juliadocs.org/dev/themes/). -It can be completely turned off by calling `Debugger.set_highlight(false)` +It can be completely turned off by calling `Debugger.set_highlight(false)`. [travis-img]: https://travis-ci.org/JuliaDebug/Debugger.jl.svg?branch=master [travis-url]: https://travis-ci.org/JuliaDebug/Debugger.jl diff --git a/src/Debugger.jl b/src/Debugger.jl index 5756a8d..f38fba6 100644 --- a/src/Debugger.jl +++ b/src/Debugger.jl @@ -51,6 +51,12 @@ Base.@kwdef mutable struct DebuggerState overall_result = nothing end +function output_stream(state::DebuggerState) + io = Base.pipe_writer(state.terminal) + have_color = state.repl isa REPL.LineEditREPL ? state.repl.hascolor : get(io, :color, false) + return IOContext(io, :color => have_color) +end + function toggle_mode(state) state.interp = (state.interp === RecursiveInterpreter() ? (state.interp = NonRecursiveInterpreter()) : (state.interp = RecursiveInterpreter())) end diff --git a/src/commands.jl b/src/commands.jl index 7e4fa1a..95e524b 100644 --- a/src/commands.jl +++ b/src/commands.jl @@ -53,7 +53,7 @@ function execute_command(state::DebuggerState, v::Union{Val{:c},Val{:nc},Val{:n} if pc isa BreakpointRef if pc.stmtidx != 0 # This is the dummy breakpoint to stop just after entering a call if state.terminal !== nothing # fix this, it happens when a test hits this and hasn't set a terminal - show_breakpoint(Base.pipe_writer(state.terminal), pc, state) + show_breakpoint(output_stream(state), pc, state) end end if pc.err !== nothing @@ -68,7 +68,7 @@ function execute_command(state::DebuggerState, v::Union{Val{:c},Val{:nc},Val{:n} end function execute_command(state::DebuggerState, ::Val{:bt}, cmd) - io = Base.pipe_writer(state.terminal) + io = output_stream(state) iob = IOContext(IOBuffer(), io) num = 0 frame = state.frame @@ -117,7 +117,7 @@ function execute_command(state::DebuggerState, ::Union{Val{:f}, Val{:fr}}, cmd) old_level = state.level try state.level = new_level - print_frame(Base.pipe_writer(state.terminal), new_level, active_frame(state)) + print_frame(output_stream(state), new_level, active_frame(state)) finally state.level = old_level end @@ -164,7 +164,7 @@ function execute_command(state::DebuggerState, ::Val{:w}, cmd::AbstractString) end end if success_and_show - io = Base.pipe_writer(state.terminal) + io = output_stream(state) outbuf = IOContext(IOBuffer(), io) show_watch_list(outbuf, state) print(io, String(take!(outbuf.io))) @@ -179,7 +179,7 @@ function execute_command(state::DebuggerState, v::Union{Val{:bp}}, cmd::Abstract cmds = split(cmd, r" +") function repl_show_breakpoints() if state.terminal !== nothing - io = Base.pipe_writer(state.terminal) + io = output_stream(state) outbuf = IOContext(IOBuffer(), io) show_breakpoints(outbuf, state) print(io, String(take!(outbuf.io))) @@ -275,21 +275,21 @@ function execute_command(state::DebuggerState, ::Union{Val{:help}, Val{:?}}, cmd - `w`\\ - `w add expr`: add an expression to the watch list\\ - `w`: show all watch expressions evaluated in the current function's context\\ - - `w rm [i::Int]`: remove all or the `i`:th watch expression\\ + - `w rm [i::Int]`: remove all or the `i`-th watch expression\\ Breakpoints:\\ - `bp add`\\ - - `bp add "file.jl":line [cond]`: add a breakpoint att file `file.jl` on line `line` with condition `cond`\\ - - `bp add func [:line] [cond]`: add a breakpoint to function `func` at line `line` (defaulting to first line) with condition `cond`\\ - - `bp add func(::Float64, Int)[:line] [cond]`: add a breakpoint to methods matching the signature at line `line` (defaulting to first line) with condition `cond`\\ + - `bp add "file.jl":line [cond]`: add a breakpoint at file `file.jl` on line `line` with condition `cond`\\ + - `bp add func [:line] [cond]`: add a breakpoint to function `func` at line `line` (defaulting to first line) with condition `cond`\\ + - `bp add func(::Float64, Int)[:line] [cond]`: add a breakpoint to methods matching the signature at line `line` (defaulting to first line) with condition `cond`\\ - `bp add func(x, y)[:line] [cond]`: add a breakpoint to the method matching the types of the local variable `x`, `y` etc with condition `cond`\\ - - `bp add line [cond]` add a breakpoint to `line` of the file of the current function with condition `cond`\\ + - `bp add line [cond]`: add a breakpoint to `line` of the file of the current function with condition `cond`\\ - `bp` show all breakpoints\\ - - `bp rm [i::Int]`: remove all or the `i`:th breakpoint\\ - - `bp toggle [i::Int]`: toggle all or the `i`:th breakpoint\\ - - `bp disable [i::Int]`: disable all or the `i`:th breakpoint\\ - - `bp enable [i::Int]`: enable all or the `i`:th breakpoint\\ + - `bp rm [i::Int]`: remove all or the `i`-th breakpoint\\ + - `bp toggle [i::Int]`: toggle all or the `i`-th breakpoint\\ + - `bp disable [i::Int]`: disable all or the `i`-th breakpoint\\ + - `bp enable [i::Int]`: enable all or the `i`-th breakpoint\\ - `bp on/off`\\ - `bp on/off error` - turn on or off break on error\\ - `bp on/off throw` - turn on or off break on throw\\ diff --git a/src/printing.jl b/src/printing.jl index 5d8201a..d058bc0 100644 --- a/src/printing.jl +++ b/src/printing.jl @@ -60,11 +60,7 @@ function pattern_match_kw_call(expr) return :($f($(args...); $(kws...))) end -@static if VERSION < v"1.3.0-DEV.179" - const append_any = Base.append_any -else - append_any(@nospecialize x...) = append!([], Core.svec((x...)...)) -end +append_any(@nospecialize x...) = append!([], Core.svec((x...)...)) function pattern_match_apply_call(expr, frame) if !(isexpr(expr, :call) && expr.args[1] == Core._apply) @@ -79,23 +75,58 @@ function pattern_match_apply_call(expr, frame) return new_expr end -# Replace functions with their symbol so that calls print like `f(x)` instead of `(f)(x)`. +# Replace functions with their symbol so that calls print like `f(x)` instead of `(f)(x)`, +# and function arguments do not gain a version-dependent `Main.` qualification. function replace_function_with_symbol(expr) if isexpr(expr, :call) - f = expr.args[1] - if f isa Function - s = Symbol(f) + for i in eachindex(expr.args) + arg = expr.args[i] + arg isa Function || continue + s = Symbol(arg) if Base.isidentifier(s) - expr.args[1] = s - return expr + expr.args[i] = s end end end return expr end -function print_next_expr(io::IO, frame::Frame) +function expression_for_display(frame::Frame) expr = pc_expr(frame) + if expr isa GlobalRef && frame.pc < nstatements(frame.framecode) + # Julia 1.12 may pause on a global lookup followed by separate argument + # loads and then a call. Preview that call so the status still shows its + # arguments rather than just `Main.:+`. + for next_pc in (frame.pc + 1):nstatements(frame.framecode) + stmt = pc_expr(frame, next_pc) + call = isexpr(stmt, :(=)) ? stmt.args[2] : stmt + if isexpr(call, :call) + f = call.args[1] + if f isa JuliaInterpreter.SSAValue && f.id == frame.pc + call = copy(call) + for i in eachindex(call.args) + arg = call.args[i] + if arg isa JuliaInterpreter.SSAValue && frame.pc <= arg.id < next_pc + source = pc_expr(frame, arg.id) + if source isa Union{GlobalRef, JuliaInterpreter.SlotNumber, QuoteNode} + call.args[i] = source + else + return expr + end + end + end + return call + end + end + + stmt isa Union{GlobalRef, JuliaInterpreter.SlotNumber, QuoteNode} || break + end + end + return expr +end + +function print_next_expr(io::IO, frame::Frame) + expr = expression_for_display(frame) @assert expr !== nothing print(io, "About to run: ") isa(expr, Expr) && (expr = copy(expr)) @@ -202,12 +233,6 @@ function compute_source_offsets(code::AbstractString, current_offsetline::Intege startoffset, stopoffset end -# TODO: Remove on next breaking change. These exist for back compat -const HIGHLIGHT_OFF = false -const HIGHLIGHT_SYSTEM_COLORS = true -const HIGHLIGHT_256_COLORS = true -const HIGHLIGHT_24_BIT = true - const _syntax_highlighting = Ref(true) const _current_theme = Ref("Monokai Dark") set_theme(theme::String) = _current_theme[] = theme diff --git a/src/repl.jl b/src/repl.jl index 07c07f7..f5dbd59 100644 --- a/src/repl.jl +++ b/src/repl.jl @@ -2,11 +2,7 @@ promptname(level, name) = "$level|$name> " function write_prompt(terminal, mode) - @static if VERSION ≥ v"1.6.0-DEV.517" - LineEdit.write_prompt(terminal, mode, LineEdit.hascolor(terminal)) - else - LineEdit.write_prompt(terminal, mode) - end + LineEdit.write_prompt(terminal, mode, LineEdit.hascolor(terminal)) end function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue=false) @@ -68,14 +64,14 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue do_print_status = try execute_command(state, Val{Symbol(cmd1)}(), command) catch err - # This will only show the stacktrae up to the current frame because + # This will only show the stacktrace up to the current frame because # currently, the unwinding in JuliaInterpreter unlinks the frames to # where the error is thrown # Buffer error printing - io = IOContext(IOBuffer(), Base.pipe_writer(terminal)) + io = IOContext(IOBuffer(), output_stream(state)) Base.display_error(io, err, JuliaInterpreter.leaf(state.frame)) - print(Base.pipe_writer(terminal), String(take!(io.io))) + print(output_stream(state), String(take!(io.io))) # Comment below out if you are debugging the Debugger #Base.display_error(Base.pipe_writer(terminal), err, catch_backtrace()) LineEdit.transition(s, :abort) @@ -92,7 +88,7 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue return false end if do_print_status - print_status(Base.pipe_writer(terminal), active_frame(state); force_lowered = state.lowered_status) + print_status(output_stream(state), active_frame(state); force_lowered = state.lowered_status) end return true end @@ -121,8 +117,8 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue 'L' => function (s, args...) if isempty(s) || position(LineEdit.buffer(s)) == 0 toggle_lowered(state) - println(Base.pipe_writer(terminal)) - print_status(Base.pipe_writer(terminal), active_frame(state); force_lowered=state.lowered_status) + println(output_stream(state)) + print_status(output_stream(state), active_frame(state); force_lowered=state.lowered_status) write_prompt(state.terminal, panel) else LineEdit.edit_insert(s, "L") @@ -131,8 +127,8 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue '+' => function (s, args...) if isempty(s) || position(LineEdit.buffer(s)) == 0 NUM_SOURCE_LINES_UP_DOWN[] += 1 - println(Base.pipe_writer(terminal)) - print_status(Base.pipe_writer(terminal), active_frame(state); force_lowered=state.lowered_status) + println(output_stream(state)) + print_status(output_stream(state), active_frame(state); force_lowered=state.lowered_status) write_prompt(state.terminal, panel) else LineEdit.edit_insert(s, "+") @@ -141,8 +137,8 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue '-' => function (s, args...) if isempty(s) || position(LineEdit.buffer(s)) == 0 NUM_SOURCE_LINES_UP_DOWN[] = max(1, NUM_SOURCE_LINES_UP_DOWN[] - 1) - println(Base.pipe_writer(terminal)) - print_status(Base.pipe_writer(terminal), active_frame(state); force_lowered=state.lowered_status) + println(output_stream(state)) + print_status(output_stream(state), active_frame(state); force_lowered=state.lowered_status) write_prompt(state.terminal, panel) else LineEdit.edit_insert(s, "-") @@ -164,9 +160,9 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue execute_command(state, Val(:c), "c") catch err # Buffer error printing - io = IOContext(IOBuffer(), Base.pipe_writer(terminal)) + io = IOContext(IOBuffer(), output_stream(state)) Base.display_error(io, err, JuliaInterpreter.leaf(state.frame)) - print(Base.pipe_writer(terminal), String(take!(io.io))) + print(output_stream(state), String(take!(io.io))) return end state.frame === nothing && return state.overall_result @@ -174,16 +170,24 @@ function RunDebugger(frame, repl = nothing, terminal = nothing; initial_continue if pc_expr(state.frame) === nothing JuliaInterpreter.maybe_next_call!(state.frame) end - print_status(Base.pipe_writer(terminal), active_frame(state); force_lowered=state.lowered_status) + print_status(output_stream(state), active_frame(state); force_lowered=state.lowered_status) - prompts = [panel] + prompts = LineEdit.TextInterface[panel] if VERSION < v"1.13-" push!(prompts, search_prompt) end - REPL.run_interface(terminal, LineEdit.ModalInterface(prompts)) + interface = LineEdit.ModalInterface(prompts) + mistate = LineEdit.init_state(terminal, interface) + previous_mistate = repl.mistate + repl.mistate = mistate + try + REPL.run_interface(terminal, interface, mistate) + finally + repl.mistate = previous_mistate + end return state.overall_result end @@ -234,21 +238,11 @@ function julia_prompt(state::DebuggerState) return julia_prompt end -@static if VERSION >= v"1.2.0-DEV.253" - function _eval_code(frame::Frame, code::AbstractString) - try - return JuliaInterpreter.eval_code(frame, code), false - catch - return Base.catch_stack(), true - end - end -else - function _eval_code(frame::Frame, code::AbstractString) - try - return true, JuliaInterpreter.eval_code(frame, code) - catch err - return false, (err, catch_backtrace()) - end +function _eval_code(frame::Frame, code::AbstractString) + try + return JuliaInterpreter.eval_code(frame, code), false + catch + return Base.catch_stack(), true end end diff --git a/test/misc.jl b/test/misc.jl index 762f276..5713bdc 100644 --- a/test/misc.jl +++ b/test/misc.jl @@ -49,6 +49,16 @@ execute_command(state, Val{:so}(), "c") frame = @make_frame fnothing(0) @test chomp(sprint(Debugger.print_next_expr, frame)) == "About to run: return 1" +# Julia 1.12 can initially pause on the global lookup immediately before a call. +frame = @make_frame (20 == 0) +frame.pc = 1 +@test chomp(sprint(Debugger.print_next_expr, frame)) == "About to run: (===)(20, 0)" + +f_preview_add(x, y) = x + y +frame = @make_frame f_preview_add(6, 4) +frame.pc = 1 +@test chomp(sprint(Debugger.print_next_expr, frame)) == "About to run: (+)(6, 4)" + function f() x = 1 + 1 @info "hello" @@ -73,7 +83,7 @@ try st = chomp(sprint(Debugger.print_status, frame; context = :color => true)) @test occursin("√", st) finally - Debugger.set_highlight(Debugger.HIGHLIGHT_OFF) + Debugger.set_highlight(false) end frame = @make_frame Test.TestLogger() diff --git a/test/runtests.jl b/test/runtests.jl index 70a7951..ac97fb8 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -12,7 +12,7 @@ if !isdefined(Main, :isnothing) isnothing(x) = x === nothing end -Debugger.set_highlight(Debugger.HIGHLIGHT_OFF) +Debugger.set_highlight(false) #@testset "Main tests" begin include("utils.jl") diff --git a/test/ui.jl b/test/ui.jl index 1f7262e..e225ce7 100644 --- a/test/ui.jl +++ b/test/ui.jl @@ -101,68 +101,123 @@ end @testset "UI" begin - if Sys.isunix() && (v"1.6.0-A" <= VERSION < v"1.7.0-A") + if Sys.isunix() && get(ENV, "DEBUGGER_RUN_UI_TESTS", "false") == "true" + print_full_path = Debugger._print_full_path[] + source_lines = Debugger.NUM_SOURCE_LINES_UP_DOWN[] + watch_list = copy(Debugger.WATCH_LIST) Debugger._print_full_path[] = false - using TerminalRegressionTests - - function run_terminal_test(frame, commands, validation) - TerminalRegressionTests.automated_test(joinpath(@__DIR__, validation), commands) do emuterm - #TerminalRegressionTests.create_automated_test(joinpath(@__DIR__, validation), commands) do emuterm - repl = REPL.LineEditREPL(emuterm, true) - repl.interface = REPL.setup_interface(repl) - repl.specialdisplay = REPL.REPLDisplay(repl) - RunDebugger(frame, repl, emuterm) + try + using TerminalRegressionTests + + function normalize_terminal_output(output) + output = replace(output, + r"(?m)^[ >]*\d+(?=\s)" => m -> replace(m, r"\d" => '#'), + r"(?<=:)\d+(?=\b)" => m -> replace(m, r"\d" => '#'), + r"#\d+" => "#") + return output + end + + # `A` is the default VT100 cell decoration. Normalizing generated-function + # identifiers can change a line's width, so trailing default cells are not + # meaningful even though every non-default decoration remains strict. + normalize_terminal_decorator(decorator) = + replace(decorator, r"A+$"m => "") + + function compare_terminal_output(emulator, output, decorator=nothing) + output_buffer = IOBuffer() + decorator_buffer = IOBuffer() + TerminalRegressionTests.VT100.dump(output_buffer, decorator_buffer, emulator) + expected_output = normalize_terminal_output(output) + actual_output = normalize_terminal_output(String(take!(output_buffer))) + TerminalRegressionTests._compare( + Vector{UInt8}(codeunits(expected_output)), + Vector{UInt8}(codeunits(actual_output))) + decorator === nothing && return true + expected_decorator = normalize_terminal_decorator(decorator) + actual_decorator = normalize_terminal_decorator(String(take!(decorator_buffer))) + return TerminalRegressionTests._compare( + Vector{UInt8}(codeunits(expected_decorator)), + Vector{UInt8}(codeunits(actual_decorator))) + end + + function run_terminal_test(frame, commands, validation) + run_debugger = function (emuterm) + repl = REPL.LineEditREPL(emuterm, true) + repl.interface = REPL.setup_interface(repl) + repl.specialdisplay = REPL.REPLDisplay(repl) + RunDebugger(frame, repl, emuterm) + end + output_path = joinpath(@__DIR__, validation) + if get(ENV, "DEBUGGER_UPDATE_UI_SNAPSHOTS", "false") == "true" + TerminalRegressionTests.create_automated_test(run_debugger, output_path, commands) + else + TerminalRegressionTests.automated_test( + run_debugger, compare_terminal_output, output_path, commands) + end + end + + CTRL_C = "\x3" + EOT = "\x4" + UP_ARROW = "\e[A" + + run_terminal_test(@make_frame(my_gcd(10, 20)), + ["n\n","`", "my_gc\t\n", "a\n", UP_ARROW, UP_ARROW, UP_ARROW, CTRL_C, + "w add a\n", "w add sin(a)\n", "w add b\n", "w\n", "w rm 1\n", "w\n", + "s\n", "fr 1\n", "fr 2\n", "f 2\n", "f 1\n", + "bt\n", "st\n", "C", "c\n", "C", "c\n"], + "ui/history_gcd.multiout") + + run_terminal_test(@make_frame(outer(1, 2, 5, 20)), + ["s\n", "c\n"], + "ui/history_kw.multiout") + + run_terminal_test(@make_frame(f_end(2)), + ["n\n", "n\n", "n\n"], + "ui/history_floor.multiout") + + run_terminal_test(@make_frame(f_invoke((1,2), 3, [4,5])), + ["nc\n", "s\n", "c\n"], + "ui/history_apply.multiout") + + run_terminal_test(@make_frame(f_until([1,2,3,4,5,6,7,8])), + ["+", "-", "u 76\n", "u\n", "u\n", "u\n", "c\n"], + "ui/history_until.multiout") + + run_terminal_test(@make_frame(f_up_down_1(5, 3)), + ["s\n", "s\n", "up\n", "down\n", "up 2\n", "down 2\n", "c\n"], + "ui/history_updown.multiout") + + run_terminal_test(@make_frame(mysum([1,2,3,4,5])), + ["bp add mysum:97 v > 3\n", "c\n", "bp rm\n", "c\n"], + "ui/bp_ui.multiout") + + run_terminal_test(@make_frame(mysum(collect(1:10000))), + ["bt\n", "c\n"], + "ui/big_repr_ui.multiout") + + was_breaking_on_error = JuliaInterpreter.break_on_error[] + Debugger.break_on(:error) + try + run_terminal_test(@make_frame(error("foo")), + ["c\n", "bt\n", "q\n"], + "ui/history_break_error.multiout") + finally + if was_breaking_on_error + Debugger.break_on(:error) + else + Debugger.break_off(:error) + end end - end - CTRL_C = "\x3" - EOT = "\x4" - UP_ARROW = "\e[A" - - run_terminal_test(@make_frame(my_gcd(10, 20)), - ["n\n","`", "my_gc\t\n", "a\n", UP_ARROW, UP_ARROW, UP_ARROW, CTRL_C, - "w add a\n", "w add sin(a)\n", "w add b\n", "w\n", "w rm 1\n", "w\n", - "s\n", "fr 1\n", "fr 2\n", "f 2\n", "f 1\n", - "bt\n", "st\n", "C", "c\n", "C", "c\n"], - "ui/history_gcd.multiout") - - run_terminal_test(@make_frame(outer(1, 2, 5, 20)), - ["s\n", "c\n"], - "ui/history_kw.multiout") - - run_terminal_test(@make_frame(f_end(2)), - ["n\n", "n\n", "n\n"], - "ui/history_floor.multiout") - - run_terminal_test(@make_frame(f_invoke((1,2), 3, [4,5])), - ["nc\n", "s\n", "c\n"], - "ui/history_apply.multiout") - - run_terminal_test(@make_frame(f_until([1,2,3,4,5,6,7,8])), - ["+", "-", "u 76\n", "u\n", "u\n", "u\n", "c\n"], - "ui/history_until.multiout") - - run_terminal_test(@make_frame(f_up_down_1(5, 3)), - ["s\n", "s\n", "up\n", "down\n", "up 2\n", "down 2\n", "c\n"], - "ui/history_updown.multiout") - - run_terminal_test(@make_frame(mysum([1,2,3,4,5])), - ["bp add mysum:97 v > 3\n", "c\n", "bp rm\n", "c\n"], - "ui/bp_ui.multiout") - - run_terminal_test(@make_frame(mysum(collect(1:10000))), - ["bt\n", "c\n"], - "ui/big_repr_ui.multiout") - - Debugger.break_on(:error) - run_terminal_test(@make_frame(error("foo")), - ["c\n", "bt\n", "q\n"], - "ui/history_break_error.multiout") - Debugger.break_off(:error) - - run_terminal_test(@make_frame(my_gcd_noinfo(10, 20)), - ["n\n","`", "a\n", UP_ARROW, UP_ARROW, CTRL_C, EOT], - "ui/history_noinfo.multiout") + run_terminal_test(@make_frame(my_gcd_noinfo(10, 20)), + ["n\n","`", "a\n", UP_ARROW, UP_ARROW, CTRL_C, EOT], + "ui/history_noinfo.multiout") + finally + Debugger._print_full_path[] = print_full_path + Debugger.NUM_SOURCE_LINES_UP_DOWN[] = source_lines + empty!(Debugger.WATCH_LIST) + append!(Debugger.WATCH_LIST, watch_list) + end else @warn "Skipping UI tests" end diff --git a/test/ui/big_repr_ui.multiout b/test/ui/big_repr_ui.multiout index 59465f2..32857ee 100644 --- a/test/ui/big_repr_ui.multiout +++ b/test/ui/big_repr_ui.multiout @@ -8,22 +8,22 @@ | 99 return s | 100 end | -|About to run: <(iterate)([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, -| 17, 18, 19, 20, 21, 22, 23, 24, 25,...> +|About to run: |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAA |BBBBBBAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAA +|CCCCCCAAAAAAAAAAAAAA |AAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCCCCC +|DDDDDDDDD ++++++++++++++++++++++++++++++++++++++++++++++++++ |In mysum(x) at ui.jl:94 | 94 function mysum(x) @@ -34,8 +34,8 @@ | 99 return s | 100 end | -|About to run: <(iterate)([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, -| 17, 18, 19, 20, 21, 22, 23, 24, 25,...> +|About to run: |1|debug> bt |[1] mysum(x) at ui.jl:96 | | x::Vector{Int64} = <[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, @@ -47,16 +47,16 @@ |AAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAA |BBBBBBAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAA +|CCCCCCAAAAAAAAAAAAAA |AAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCCCCCAA +|DDDDDDDDDAA |AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAA -|CCCCCCCCC \ No newline at end of file +|DDDDDDDDD \ No newline at end of file diff --git a/test/ui/bp_ui.multiout b/test/ui/bp_ui.multiout index 9f5f7d5..f259f56 100644 --- a/test/ui/bp_ui.multiout +++ b/test/ui/bp_ui.multiout @@ -8,7 +8,7 @@ | 99 return s | 100 end | -|About to run: (iterate)([1, 2, 3, 4, 5]) +|About to run: iterate([1, 2, 3, 4, 5]) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAA @@ -20,7 +20,7 @@ |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In mysum(x) at ui.jl:94 @@ -32,7 +32,7 @@ | 99 return s | 100 end | -|About to run: (iterate)([1, 2, 3, 4, 5]) +|About to run: iterate([1, 2, 3, 4, 5]) |1|debug> bp add mysum:97 v > 3 |1] mysum:97 v > 3 | @@ -47,7 +47,7 @@ |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAA | @@ -62,7 +62,7 @@ | 99 return s | 100 end | -|About to run: (iterate)([1, 2, 3, 4, 5]) +|About to run: iterate([1, 2, 3, 4, 5]) |1|debug> bp add mysum:97 v > 3 |1] mysum:97 v > 3 | @@ -89,7 +89,7 @@ |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAA | @@ -116,7 +116,7 @@ | 99 return s | 100 end | -|About to run: (iterate)([1, 2, 3, 4, 5]) +|About to run: iterate([1, 2, 3, 4, 5]) |1|debug> bp add mysum:97 v > 3 |1] mysum:97 v > 3 | @@ -144,7 +144,7 @@ |AAAAAAAAAAAAAAAAAA |AAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAA | diff --git a/test/ui/history_apply.multiout b/test/ui/history_apply.multiout index 2f490a7..201fb6a 100644 --- a/test/ui/history_apply.multiout +++ b/test/ui/history_apply.multiout @@ -4,7 +4,7 @@ |>70 return g_invoke(x..., y, z...) | 71 end | -|About to run: (tuple)(3) +|About to run: tuple(3) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -12,7 +12,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_invoke(x, y, z) at ui.jl:69 @@ -20,14 +20,14 @@ |>70 return g_invoke(x..., y, z...) | 71 end | -|About to run: (tuple)(3) +|About to run: tuple(3) |1|debug> nc |In f_invoke(x, y, z) at ui.jl:69 | 69 function f_invoke(x, y, z) |>70 return g_invoke(x..., y, z...) | 71 end | -|About to run: (Core._apply_iterate)(iterate, g_invoke, (1, 2), (3,), [4, 5]) +|About to run: _apply_iterate(iterate, g_invoke, (1, 2), (3,), [4, 5]) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -35,14 +35,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_invoke(x, y, z) at ui.jl:69 @@ -50,14 +50,14 @@ |>70 return g_invoke(x..., y, z...) | 71 end | -|About to run: (tuple)(3) +|About to run: tuple(3) |1|debug> nc |In f_invoke(x, y, z) at ui.jl:69 | 69 function f_invoke(x, y, z) |>70 return g_invoke(x..., y, z...) | 71 end | -|About to run: (Core._apply_iterate)(iterate, g_invoke, (1, 2), (3,), [4, 5]) +|About to run: _apply_iterate(iterate, g_invoke, (1, 2), (3,), [4, 5]) |1|debug> s |In g_invoke(a, b, c, d, e) at ui.jl:68 |>68 g_invoke(a, b, c, d, e) = a + b + c + d + e @@ -70,14 +70,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA diff --git a/test/ui/history_break_error.multiout b/test/ui/history_break_error.multiout index 2ae9468..dc62da2 100644 --- a/test/ui/history_break_error.multiout +++ b/test/ui/history_break_error.multiout @@ -1,6 +1,6 @@ ++++++++++++++++++++++++++++++++++++++++++++++++++ -|In error(s) at error.jl:33 -|>33 error(s::AbstractString) = throw(ErrorException(s)) +|In error(s) at error.jl:44 +|>44 error(s::AbstractString) = throw(ErrorException(s)) | |About to run: (ErrorException)("foo") |1|debug> @@ -11,8 +11,8 @@ |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ -|In error(s) at error.jl:33 -|>33 error(s::AbstractString) = throw(ErrorException(s)) +|In error(s) at error.jl:44 +|>44 error(s::AbstractString) = throw(ErrorException(s)) | |About to run: (ErrorException)("foo") |1|debug> c @@ -20,12 +20,12 @@ |ERROR: foo |Stacktrace: | [1] error(s::String) -| @ Base error.jl:33 +| @ Base error.jl:44 | -|In error(s) at error.jl:33 -|>33 error(s::AbstractString) = throw(ErrorException(s)) +|In error(s) at error.jl:44 +|>44 error(s::AbstractString) = throw(ErrorException(s)) | -|About to run: (throw)(ErrorException("foo")) +|About to run: throw(ErrorException("foo")) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAA @@ -36,17 +36,17 @@ |AAAAAAAAAAAAAAAAAAA |DDDDDDDAAA |AAAAAAAAAAA -|AAAAAEEEEEEFEEAAAAAAE -|FFFFFGGGGEHHHHHHHHHHH +|AAAAAEEEEEEFAAAAAAAAE +|FFFFAGGGGAHHHHHHHHHHH | |AAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ -|In error(s) at error.jl:33 -|>33 error(s::AbstractString) = throw(ErrorException(s)) +|In error(s) at error.jl:44 +|>44 error(s::AbstractString) = throw(ErrorException(s)) | |About to run: (ErrorException)("foo") |1|debug> c @@ -54,14 +54,14 @@ |ERROR: foo |Stacktrace: | [1] error(s::String) -| @ Base error.jl:33 +| @ Base error.jl:44 | -|In error(s) at error.jl:33 -|>33 error(s::AbstractString) = throw(ErrorException(s)) +|In error(s) at error.jl:44 +|>44 error(s::AbstractString) = throw(ErrorException(s)) | -|About to run: (throw)(ErrorException("foo")) +|About to run: throw(ErrorException("foo")) |1|debug> bt -|[1] error(s) at error.jl:33 +|[1] error(s) at error.jl:44 | | s::String = "foo" |1|debug> -------------------------------------------------- @@ -73,13 +73,13 @@ |AAAAAAAAAAAAAAAAAAA |DDDDDDDAAA |AAAAAAAAAAA -|AAAAAEEEEEEFEEAAAAAAE -|FFFFFGGGGEHHHHHHHHHHH +|AAAAAEEEEEEFAAAAAAAAE +|FFFFAGGGGAHHHHHHHHHHH | |AAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAA |AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAA diff --git a/test/ui/history_floor.multiout b/test/ui/history_floor.multiout index 3174ebc..1344e0d 100644 --- a/test/ui/history_floor.multiout +++ b/test/ui/history_floor.multiout @@ -31,7 +31,7 @@ |>64 return sin(x) | 65 end | -|About to run: (sin)(6) +|About to run: sin(6) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAA @@ -48,7 +48,7 @@ |BBBBBAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_end(x) at ui.jl:62 @@ -65,7 +65,7 @@ |>64 return sin(x) | 65 end | -|About to run: (sin)(6) +|About to run: sin(6) |1|debug> n |In f_end(x) at ui.jl:62 | 62 function f_end(x) @@ -90,7 +90,7 @@ |BBBBBAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAA diff --git a/test/ui/history_gcd.multiout b/test/ui/history_gcd.multiout index 5980918..0802332 100644 --- a/test/ui/history_gcd.multiout +++ b/test/ui/history_gcd.multiout @@ -1087,8 +1087,8 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> @@ -1211,12 +1211,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -1345,12 +1345,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -1489,12 +1489,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -1657,12 +1657,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -1684,8 +1684,8 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> @@ -1835,12 +1835,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -1862,12 +1862,12 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> bt -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2031,12 +2031,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2058,12 +2058,12 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> bt -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2072,8 +2072,8 @@ | | b::Int64 = 20 | | T::DataType = Int64 |1|debug> st -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> @@ -2237,12 +2237,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2264,12 +2264,12 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> bt -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2278,8 +2278,8 @@ | | b::Int64 = 20 | | T::DataType = Int64 |1|debug> st -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> @@ -2443,12 +2443,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2470,12 +2470,12 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> bt -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2484,8 +2484,8 @@ | | b::Int64 = 20 | | T::DataType = Int64 |1|debug> st -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> c @@ -2611,8 +2611,8 @@ |AAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|FFFFFGGGGGGGGGGGG -|HHHHHGGGGGGGGGGGG +|FFFFFAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAA |AAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAA @@ -2677,12 +2677,12 @@ |2] b: 20 | |1|debug> s -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> fr 1 -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2704,12 +2704,12 @@ | |About to run: (==)(20, 0) |2|debug> f 1 -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> bt -|[1] ==(x, y) at promotion.jl:410 +|[1] ==(x, y) at promotion.jl:637 | | x::Int64 = 20 | | y::Int64 = 0 | | T::DataType = Int64 @@ -2718,8 +2718,8 @@ | | b::Int64 = 20 | | T::DataType = Int64 |1|debug> st -|In ==(x, y) at promotion.jl:410 -|>410 (==)(x::T, y::T) where {T<:Number} = x === y +|In ==(x, y) at promotion.jl:637 +|>637 (==)(x::T, y::T) where {T<:Number} = x === y | |About to run: (===)(20, 0) |1|debug> c @@ -2845,8 +2845,8 @@ |AAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|FFFFFGGGGGGGGGGGG -|HHHHHGGGGGGGGGGGG +|FFFFFAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAA |AAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAA diff --git a/test/ui/history_kw.multiout b/test/ui/history_kw.multiout index 6bdffa7..14e919c 100644 --- a/test/ui/history_kw.multiout +++ b/test/ui/history_kw.multiout @@ -4,7 +4,7 @@ |>52 inner_kw(a, b; c = c) | 53 end | -|About to run: (var"#inner_kw##kw"())((c = 5,), inner_kw, 1, 2) +|About to run: inner_kw(1, 2; c = 5) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -12,7 +12,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In outer(a, b, c, d) at ui.jl:51 @@ -20,9 +20,9 @@ |>52 inner_kw(a, b; c = c) | 53 end | -|About to run: (var"#inner_kw##kw"())((c = 5,), inner_kw, 1, 2) +|About to run: inner_kw(1, 2; c = 5) |1|debug> s -|In #inner_kw#10(c, d, , a, b) at ui.jl:55 +|In #inner_kw#9(c, d, , a, b) at ui.jl:55 | 55 function inner_kw(a, b; c = 3, d = 10) |>56 return a + b + c + d | 57 end @@ -35,9 +35,9 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA diff --git a/test/ui/history_noinfo.multiout b/test/ui/history_noinfo.multiout index 355c64a..1cdaf9c 100644 --- a/test/ui/history_noinfo.multiout +++ b/test/ui/history_noinfo.multiout @@ -1,168 +1,168 @@ ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEE +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|EEEEEEEEE +|CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|julia> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|GGGGGGGGG +|EEEEEEEEE ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|julia> a @@ -172,59 +172,59 @@ -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|GGGGGGGGGA +|EEEEEEEEEA |AA | -|GGGGGGGGG +|EEEEEEEEE ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|julia> a @@ -234,59 +234,59 @@ -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|GGGGGGGGGA +|EEEEEEEEEA |AA | -|GGGGGGGGGA +|EEEEEEEEEA ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|julia> a @@ -296,59 +296,59 @@ -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|GGGGGGGGGA +|EEEEEEEEEA |AA | -|EEEEEEEEEA +|CCCCCCCCCA ++++++++++++++++++++++++++++++++++++++++++++++++++ |In my_gcd_noinfo(a, b) at nope.jl:1 -| 3 │ Core.NewvarNode(:(u)) | 4 │ Core.NewvarNode(:(k)) | 5 │ Core.NewvarNode(:(zb)) | 6 │ Core.NewvarNode(:(za)) -|> 7 │ %7 = a == 0 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing +| 7 │ %7 = Main.:(==) +|> 8 │ %8 = dynamic (%7)(a, 0) +| 9 └─── goto #4 if not %8 +| 10 2 ── %10 = Main.abs +| 11 │ %11 = dynamic (%10)(b) +| 12 └─── return %11 | |About to run: (==)(10, 0) |1|debug> n |Hit breakpoint: |In my_gcd_noinfo(a, b) at nope.jl:1 -| 8 └─── goto #3 if not %7 -| 9 2 ── %9 = Base.abs(b) -| 10 └─── return %9 -|●11 3 ── nothing -|>12 │ %12 = b == 0 -| 13 └─── goto #5 if not %12 -| 14 4 ── %14 = Base.abs(a) -| 15 └─── return %14 -| 16 5 ── za = Base.trailing_zeros(a) +| 12 └─── return %11 +| 13 3 ── goto #4 +|●14 4 ┄─ nothing +| 15 │ %15 = Main.:(==) +|>16 │ %16 = dynamic (%15)(b, 0) +| 17 └─── goto #7 if not %16 +| 18 5 ── %18 = Main.abs +| 19 │ %19 = dynamic (%18)(a) +| 20 └─── return %19 | |About to run: (==)(20, 0) |1|julia> a @@ -360,33 +360,33 @@ -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|BBBBBAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA | -|DDDDDDDDDDDDDDDDDDDDDDDDD -|EEEEEEEEEA +|AAAAAAAAAAAAAAAAAAAAAAAAA +|CCCCCCCCCA |AAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAA -|CCCCCDDDDDDDDDDDDDDDDDD -|FFFFFDDDDDDDDDDDDDDDDD +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAA +|DDDDDAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAA +|BBBBBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA | |AAAAAAAAAAAAAAAAAAAAAAAAA -|GGGGGGGGGA +|EEEEEEEEEA |AA | -|EEEEEEEEEAAA +|CCCCCCCCCAAA | -|EEEEEEEEE \ No newline at end of file +|CCCCCCCCC \ No newline at end of file diff --git a/test/ui/history_until.multiout b/test/ui/history_until.multiout index 7ead5ab..ab6f7f9 100644 --- a/test/ui/history_until.multiout +++ b/test/ui/history_until.multiout @@ -274,7 +274,7 @@ | 80 return s | 81 end | -|About to run: (iterate)([1, 2, 3, 4, 5, 6, 7, 8]) +|About to run: iterate([1, 2, 3, 4, 5, 6, 7, 8]) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAA @@ -332,7 +332,7 @@ |AAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_until(x) at ui.jl:73 @@ -390,7 +390,7 @@ | 80 return s | 81 end | -|About to run: (iterate)([1, 2, 3, 4, 5, 6, 7, 8]) +|About to run: iterate([1, 2, 3, 4, 5, 6, 7, 8]) |1|debug> u |In f_until(x) at ui.jl:73 | 74 s = 1 + 1 @@ -460,7 +460,7 @@ |AAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAA @@ -530,7 +530,7 @@ | 80 return s | 81 end | -|About to run: (iterate)([1, 2, 3, 4, 5, 6, 7, 8]) +|About to run: iterate([1, 2, 3, 4, 5, 6, 7, 8]) |1|debug> u |In f_until(x) at ui.jl:73 | 74 s = 1 + 1 @@ -545,14 +545,15 @@ |About to run: (+)(6, 1) |1|debug> u |In f_until(x) at ui.jl:73 +| 75 s = 2 + 2 | 76 s = 3 + 3 | 77 for v in x | 78 s += v -| 79 end -|>80 return s +|>79 end +| 80 return s | 81 end | -|About to run: return 42 +|About to run: iterate([1, 2, 3, 4, 5, 6, 7, 8], 2) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAA @@ -610,7 +611,7 @@ |AAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAA @@ -626,11 +627,12 @@ |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAA -|AAAAAAAAAAAA -|BBBBBAAAAAAAAAAAA +|BBBBBAAAAAAA +|AAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC \ No newline at end of file diff --git a/test/ui/history_updown.multiout b/test/ui/history_updown.multiout index 8b01d5e..4baf8ae 100644 --- a/test/ui/history_updown.multiout +++ b/test/ui/history_updown.multiout @@ -4,7 +4,7 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -12,7 +12,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_up_down_1(x, y) at ui.jl:83 @@ -20,14 +20,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -35,14 +35,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_up_down_1(x, y) at ui.jl:83 @@ -50,14 +50,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> s |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -72,14 +72,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -94,14 +94,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> s |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -115,7 +115,7 @@ |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |2|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -123,14 +123,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -144,7 +144,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_up_down_1(x, y) at ui.jl:83 @@ -152,14 +152,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> s |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -173,7 +173,7 @@ |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |2|debug> down |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -188,14 +188,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -209,7 +209,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -224,14 +224,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> s |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -245,7 +245,7 @@ |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |2|debug> down |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -259,7 +259,7 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |3|debug> -------------------------------------------------- |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -267,14 +267,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -288,7 +288,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -302,7 +302,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCC ++++++++++++++++++++++++++++++++++++++++++++++++++ |In f_up_down_1(x, y) at ui.jl:83 @@ -310,14 +310,14 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |1|debug> s |In f_up_down_2(x, y) at ui.jl:86 | 86 function f_up_down_2(x, y) |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |1|debug> s |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -331,7 +331,7 @@ |>87 f_up_down_3(x, y) | 88 end | -|About to run: (f_up_down_3)(5, 3) +|About to run: f_up_down_3(5, 3) |2|debug> down |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -345,7 +345,7 @@ |>84 f_up_down_2(x, y) | 85 end | -|About to run: (f_up_down_2)(5, 3) +|About to run: f_up_down_2(5, 3) |3|debug> down 2 |In f_up_down_3(x, y) at ui.jl:89 | 89 function f_up_down_3(x, y) @@ -360,14 +360,14 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -381,7 +381,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -395,7 +395,7 @@ |BBBBBAAAAAAAAAAAAAAAAAAAAA |AAAAAAAA | -|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA +|AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |CCCCCCCCCAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA