Revert "Revert "RFC: prettier IR-show for line number and inlining information" (JuliaLang#29118)"

This reverts commit 6caabc9.

Author: vtjnash

base/compiler/ssair/ir.jl

@@ -85,11 +85,11 @@ function basic_blocks_starts(stmts::Vector{Any})
                 push!(jump_dests, idx)
                 push!(jump_dests, idx+1)
                 # The catch block is a jump dest
-                push!(jump_dests, stmt.args[1])
+                push!(jump_dests, stmt.args[1]::Int)
             elseif stmt.head === :gotoifnot
                 # also tolerate expr form of IR
                 push!(jump_dests, idx+1)
-                push!(jump_dests, stmt.args[2])
+                push!(jump_dests, stmt.args[2]::Int)
             elseif stmt.head === :return
                 # also tolerate expr form of IR
                 # This is a fake dest to force the next stmt to start a bb
@@ -130,7 +130,7 @@ function compute_basic_blocks(stmts::Vector{Any})
     # Compute successors/predecessors
     for (num, b) in enumerate(blocks)
         terminator = stmts[last(b.stmts)]
-        if isa(terminator, ReturnNode)
+        if isa(terminator, ReturnNode) || isexpr(terminator, :return)
             # return never has any successors
             continue
         end
@@ -150,17 +150,28 @@ function compute_basic_blocks(stmts::Vector{Any})
                 push!(blocks[block′].preds, num)
                 push!(b.succs, block′)
             end
-        elseif isa(terminator, Expr) && terminator.head == :enter
-            # :enter gets a virtual edge to the exception handler and
-            # the exception handler gets a virtual edge from outside
-            # the function.
-            # See the devdocs on exception handling in SSA form (or
-            # bug Keno to write them, if you're reading this and they
-            # don't exist)
-            block′ = block_for_inst(basic_block_index, terminator.args[1])
-            push!(blocks[block′].preds, num)
-            push!(blocks[block′].preds, 0)
-            push!(b.succs, block′)
+        elseif isa(terminator, Expr)
+            if terminator.head == :enter
+                # :enter gets a virtual edge to the exception handler and
+                # the exception handler gets a virtual edge from outside
+                # the function.
+                # See the devdocs on exception handling in SSA form (or
+                # bug Keno to write them, if you're reading this and they
+                # don't exist)
+                block′ = block_for_inst(basic_block_index, terminator.args[1]::Int)
+                push!(blocks[block′].preds, num)
+                push!(blocks[block′].preds, 0)
+                push!(b.succs, block′)
+            elseif terminator.head == :gotoifnot
+                block′ = block_for_inst(basic_block_index, terminator.args[2]::Int)
+                if block′ == num + 1
+                    # This GotoIfNot acts like a noop - treat it as such.
+                    # We will drop it during SSA renaming
+                else
+                    push!(blocks[block′].preds, num)
+                    push!(b.succs, block′)
+                end
+            end
         end
         # statement fall-through
         if num + 1 <= length(blocks)

base/compiler/ssair/show.jl

@@ -21,13 +21,15 @@ function Base.show(io::IO, cfg::CFG)
 end
 
 function print_stmt(io::IO, idx::Int, @nospecialize(stmt), used::BitSet, maxlength_idx::Int, color::Bool, show_type::Bool)
-    indent = maxlength_idx + 4
     if idx in used
-        pad = " "^(maxlength_idx - length(string(idx)) + 1)
-        print(io, "%", idx, pad, "= ")
+        idx_s = string(idx)
+        pad = " "^(maxlength_idx - length(idx_s) + 1)
+        print(io, "%", idx_s, pad, "= ")
     else
-        print(io, " "^indent)
+        print(io, " "^(maxlength_idx + 4))
     end
+    # TODO: `indent` is supposed to be the full width of the leader for correct alignment
+    indent = 16
     if !color && stmt isa PiNode
         # when the outer context is already colored (yellow, for pending nodes), don't use the usual coloring printer
         print(io, "π (")
@@ -314,6 +316,145 @@ end
 
 Base.show(io::IO, code::IRCode) = show_ir(io, code)
 
+
+lineinfo_disabled(io::IO, linestart::String, lineidx::Int32) = ""
+
+function DILineInfoPrinter(linetable::Vector)
+    context = LineInfoNode[]
+    context_depth = Ref(0)
+    indent(s::String) = s^(max(context_depth[], 1) - 1)
+    function emit_lineinfo_update(io::IO, linestart::String, lineidx::Int32)
+        # internal configuration options:
+        collapse = true
+        indent_all = true
+        # convert lineidx to a vector
+        lineidx == 0 && return indent_all ? indent("│") : "" # just skip over lines with no debug info at all
+        DI = LineInfoNode[]
+        while lineidx != 0
+            entry = linetable[lineidx]::LineInfoNode
+            push!(DI, entry)
+            lineidx = entry.inlined_at
+        end
+        nframes = length(DI)
+        nctx = 0
+        pop_skips = 0
+        # compute the size of the matching prefix in the inlining information stack
+        for i = 1:min(length(context), nframes)
+            CtxLine = context[i]
+            FrameLine = DI[nframes - i + 1]
+            CtxLine === FrameLine || break
+            nctx = i
+        end
+        update_line_only = false
+        if collapse && 0 < nctx
+            # check if we're adding more frames with the same method name,
+            # if so, drop all existing calls to it from the top of the context
+            # AND check if instead the context was previously printed that way
+            # but now has removed the recursive frames
+            let method = context[nctx].method
+                if (nctx < nframes && DI[nframes - nctx].method === method) ||
+                   (nctx < length(context) && context[nctx + 1].method === method)
+                    update_line_only = true
+                    while nctx > 0 && context[nctx].method === method
+                        nctx -= 1
+                    end
+                end
+            end
+        end
+        # examine what frames we're returning from
+        if nctx < length(context)
+            # compute the new inlining depth
+            if collapse
+                npops = 1
+                let Prev = context[nctx + 1].method
+                    for i = (nctx + 2):length(context)
+                        Next = context[i].method
+                        Prev === Next || (npops += 1)
+                        Prev = Next
+                    end
+                end
+            else
+                npops = length(context) - nctx
+            end
+            # look at the first non-matching element to see if we are only changing the line number
+            if !update_line_only && nctx < nframes
+                let CtxLine = context[nctx + 1],
+                    FrameLine = DI[nframes - nctx]
+                    if CtxLine.file == FrameLine.file &&
+                            CtxLine.method == FrameLine.method &&
+                            CtxLine.mod == FrameLine.mod
+                        update_line_only = true
+                    end
+                end
+            end
+            resize!(context, nctx)
+            update_line_only && (npops -= 1)
+            if npops > 0
+                context_depth[] -= npops
+                print(io, linestart, indent("│"), "┘"^npops, "\n")
+            end
+        end
+        # see what change we made to the outermost line number
+        if update_line_only
+            frame = DI[nframes - nctx]
+            nctx += 1
+            push!(context, frame)
+            if frame.line != typemax(frame.line) && frame.line != 0
+                print(io, linestart, indent("│"), " @ ", frame.file, ":", frame.line, " within `", frame.method, "'")
+                if collapse
+                    method = frame.method
+                    while nctx < nframes
+                        frame = DI[nframes - nctx]
+                        frame.method === method || break
+                        nctx += 1
+                        push!(context, frame)
+                        print(io, " @ ", frame.file, ":", frame.line)
+                    end
+                end
+                print(io, "\n")
+            end
+        end
+        # now print the rest of the new frames
+        while nctx < nframes
+            frame = DI[nframes - nctx]
+            print(io, linestart, indent("│"))
+            nctx += 1
+            push!(context, frame)
+            context_depth[] += 1
+            nctx != 1 && print(io, "┌")
+            print(io, " @ ", frame.file)
+            if frame.line != typemax(frame.line) && frame.line != 0
+                print(io, ":", frame.line)
+            end
+            print(io, " within `", frame.method, "'")
+            if collapse
+                method = frame.method
+                while nctx < nframes
+                    frame = DI[nframes - nctx]
+                    frame.method === method || break
+                    nctx += 1
+                    push!(context, frame)
+                    print(io, " @ ", frame.file, ":", frame.line)
+                end
+            end
+            print(io, "\n")
+        end
+        # FOR DEBUGGING `collapse`:
+        #let Prev = context[1].method,
+        #    depth2 = 1
+        #    for i = 2:nctx
+        #        Next = context[i].method
+        #        (collapse && Prev === Next) || (depth2 += 1)
+        #        Prev = Next
+        #    end
+        #    @assert context_depth[] == depth2
+        #end
+        return indent_all ? indent("│") : ""
+    end
+    return emit_lineinfo_update
+end
+
+
 function show_ir(io::IO, code::IRCode, expr_type_printer=default_expr_type_printer; verbose_linetable=false)
     cols = displaysize(io)[2]
     used = BitSet()
@@ -465,7 +606,7 @@ function show_ir(io::IO, code::IRCode, expr_type_printer=default_expr_type_print
     end
 end
 
-function show_ir(io::IO, code::CodeInfo, expr_type_printer=default_expr_type_printer; verbose_linetable=false)
+function show_ir(io::IO, code::CodeInfo, line_info_preprinter=DILineInfoPrinter(code.linetable), line_info_postprinter=default_expr_type_printer)
     cols = displaysize(io)[2]
     used = BitSet()
     stmts = code.code
@@ -483,14 +624,6 @@ function show_ir(io::IO, code::CodeInfo, expr_type_printer=default_expr_type_pri
         maxused = maximum(used)
         maxlength_idx = length(string(maxused))
     end
-    if !verbose_linetable
-        (loc_annotations, loc_methods, loc_lineno) = compute_ir_line_annotations(code)
-        max_loc_width = maximum(length(str) for str in loc_annotations)
-        max_lineno_width = maximum(length(str) for str in loc_lineno)
-        max_method_width = maximum(length(str) for str in loc_methods)
-    end
-    max_depth = maximum(compute_inlining_depth(code.linetable, line) for line in code.codelocs)
-    last_stack = []
     for idx in eachindex(stmts)
         if !isassigned(stmts, idx)
             # This is invalid, but do something useful rather
@@ -499,63 +632,24 @@ function show_ir(io::IO, code::CodeInfo, expr_type_printer=default_expr_type_pri
             continue
         end
         stmt = stmts[idx]
-        # Compute BB guard rail
         bbrange = cfg.blocks[bb_idx].stmts
         bbrange = bbrange.first:bbrange.last
-        bb_idx_str = string(bb_idx)
-        bb_pad = max_bb_idx_size - length(bb_idx_str)
-        bb_type = length(cfg.blocks[bb_idx].preds) <= 1 ? "─" : "┄"
-        bb_start_str = string(bb_idx_str, " ", bb_type, "─"^bb_pad, " ")
-        bb_guard_rail_cont = string("│  ", " "^max_bb_idx_size)
+        # Print line info update
+        linestart = idx == first(bbrange) ? "  " : sprint(io -> printstyled(io, "│ ", color=:light_black), context=io)
+        linestart *= " "^max_bb_idx_size
+        inlining_indent = line_info_preprinter(io, linestart, code.codelocs[idx])
+        # Compute BB guard rail
         if idx == first(bbrange)
-            bb_guard_rail = bb_start_str
-        else
-            bb_guard_rail = bb_guard_rail_cont
-        end
-        # Print linetable information
-        if verbose_linetable
-            stack = compute_loc_stack(code.linetable, code.codelocs[idx])
-            # We need to print any stack frames that did not exist in the last stack
-            ndepth = max(1, length(stack))
-            rail = string(" "^(max_depth+1-ndepth), "│"^ndepth)
-            start_column = cols - max_depth - 10
-            for (i, x) in enumerate(stack)
-                if i > length(last_stack) || last_stack[i] != x
-                    entry = code.linetable[x]
-                    printstyled(io, "\e[$(start_column)G$(rail)\e[1G", color = :light_black)
-                    print(io, bb_guard_rail)
-                    ssa_guard = " "^(maxlength_idx + 4 + (i - 1))
-                    entry_label = "$(ssa_guard)$(entry.method) at $(entry.file):$(entry.line) "
-                    hline = string("─"^(start_column-length(entry_label)-length(bb_guard_rail)+max_depth-i), "┐")
-                    printstyled(io, string(entry_label, hline), "\n"; color=:light_black)
-                    bb_guard_rail = bb_guard_rail_cont
-                end
-            end
-            printstyled(io, "\e[$(start_column)G$(rail)\e[1G", color = :light_black)
-            last_stack = stack
+            bb_idx_str = string(bb_idx)
+            bb_pad = max_bb_idx_size - length(bb_idx_str)
+            bb_type = length(cfg.blocks[bb_idx].preds) <= 1 ? "─" : "┄"
+            printstyled(io, bb_idx_str, " ", bb_type, "─"^bb_pad, color=:light_black)
+        elseif idx == last(bbrange) # print separator
+            printstyled(io, "└", "─"^(1 + max_bb_idx_size), color=:light_black)
         else
-            annotation = loc_annotations[idx]
-            loc_method = loc_methods[idx]
-            lineno = loc_lineno[idx]
-            # Print location information right aligned. If the line below is too long, it'll overwrite this,
-            # but that's what we want.
-            if get(io, :color, false)
-                method_start_column = cols - max_method_width - max_loc_width - 2
-                filler = " "^(max_loc_width-length(annotation))
-                printstyled(io, "\e[$(method_start_column)G$(annotation)$(filler)$(loc_method)\e[1G", color = :light_black)
-            end
-            printstyled(io, lineno, " "^(max_lineno_width-length(lineno)+1); color = :light_black)
-        end
-        idx != last(bbrange) && print(io, bb_guard_rail)
-        if idx == last(bbrange) # print separator
-            if idx == first(bbrange)
-                print(io, bb_start_str)
-            elseif idx == last(bbrange)
-                print(io, "└", "─"^(1 + max_bb_idx_size), " ")
-            else
-                print(io, "│  ", " "^max_bb_idx_size)
-            end
+            printstyled(io, "│ ", " "^max_bb_idx_size, color=:light_black)
         end
+        print(io, inlining_indent, " ")
         if idx == last(bbrange)
             bb_idx += 1
         end
@@ -582,7 +676,7 @@ function show_ir(io::IO, code::CodeInfo, expr_type_printer=default_expr_type_pri
                 printstyled(io, "::#UNDEF", color=:red)
             elseif show_type
                 typ = types[idx]
-                expr_type_printer(io, typ, idx in used)
+                line_info_postprinter(io, typ, idx in used)
             end
         end
         println(io)

doc/src/devdocs/reflection.md

@@ -94,12 +94,13 @@ particular interest for understanding how language constructs map to primitive o
 as assignments, branches, and calls:
 
 ```jldoctest
-julia> Meta.lower(@__MODULE__, :([1+2, sin(0.5)]) )
+julia> Meta.lower(@__MODULE__, :( [1+2, sin(0.5)] ))
 :($(Expr(:thunk, CodeInfo(
- 1 ─ %1 = 1 + 2
- │   %2 = sin(0.5)
- │   %3 = (Base.vect)(%1, %2)
- └──      return %3
+    @ none within `top-level scope'
+1 ─ %1 = 1 + 2
+│   %2 = sin(0.5)
+│   %3 = (Base.vect)(%1, %2)
+└──      return %3
 ))))
 ```
 
@@ -122,11 +123,11 @@ calls and expand argument types automatically:
 ```julia-repl
 julia> @code_llvm +(1,1)
 
-; Function Attrs: sspreq
-define i64 @"julia_+_130862"(i64, i64) #0 {
+;  @ int.jl:53 within `+'
+define i64 @"julia_+_130862"(i64, i64) {
 top:
-    %2 = add i64 %1, %0, !dbg !8
-    ret i64 %2, !dbg !8
+    %2 = add i64 %1, %0
+    ret i64 %2
 }
 ```