Displays long chains of gotos not displayed by code-typed

I think this might be something to do with the function doing a lot of inlining.
Consider code-typed:

julia> @code_typed (x->[x])(1)
CodeInfo(
1 ─ %1 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Vector{Int64}, svec(Any, Int64), 0, :(:ccall), Vector{Int64}, 1, 1))::Vector{Int64}
└──      goto #3 if not true
2 ─      Base.arrayset(false, %1, x, 1)::Vector{Int64}
3 ┄      goto #4
4 ─      return %1
) => Vector{Int64}

vs descend

julia> @descend (x->[x])(1)
(::var"#23#24")(x) @ Main REPL[42]:1
  ∘ ── %0 = invoke #23(::Int64)::Vector{Int64}                                                 
1 1 ── %1 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Vector{Int64}, svec(Any, Int64), 0, :(:ccall), Vector{Int64}, 1, 1))::Vector{Int64}
  2 ──      goto #3                                                                    ││╻╷╷╷╷   LinearIndices
  3 ──      goto #4                                                                    │││┃│││    axes
  4 ──      goto #5                                                                    ││││┃│      map
  5 ──      goto #6                                                                    │││││   
  6 ──      goto #7                                                                    ││││    
  7 ──      goto #8                                                                    │││     
  8 ──      nothing::Nothing                                                           │       
  9 ──      goto #10                                                                   │││╻╷╷╷╷   axes1
  10 ─      goto #11                                                                   ││││┃││     axes
  11 ─      goto #12                                                                   │││││┃       oneto
  12 ─      goto #13                                                                   │││││   
  13 ─      goto #14                                                                   ││││    
  14 ─      goto #15                                                                   │││     
  15 ─      nothing::Nothing                                                           │       
  16 ─      nothing::Nothing                                                           │       
  17 ─      Base.arrayset(false, %1, x, 1)::Vector{Int64}                              ││╻       setindex!
  18 ─      goto #19                                                                   ││      
  19 ─      return %1                                                                  │       
Select a call to descend into or ↩ to ascend. [q]uit. [b]ookmark.
Toggles: [o]ptimize, [w]arn, [h]ide type-stable statements, [d]ebuginfo, [r]emarks, [e]ffects, [i]nlining costs, [t]ype annotations, [s]yntax highlight for Source/LLVM/Native.
Show: [S]ource code, [A]ST, [T]yped code, [L]LVM IR, [N]ative code
Actions: [E]dit source code, [R]evise and redisplay
Advanced: dump [P]arams cache.

I assume this is to do with the info shown on the right (you will need to scroll across to see on github).
I think we should be willing to do some kind of goto compression (to match code_typed) at least by default

Reproduce the discrepancy with @code_typed (x-> [x])(1) and @descend (x-> [x])(1), then trace how each view renders the control-flow blocks and the right-hand inlining information. Determine where long chains of gotos are displayed, and consider the issue resolved when the default descend display compresses such chains comparably to code_typed without hiding meaningful structure.