irinterp: Consider cfg information from discovered errors

[Keno]

If we infer a call to Union{}, we can terminate further abstract interpretation. However, this of course also means that we can make use of that information to refine the types of any phis that may have originated from the basic block containing the call that was refined to Union{}.

[aviatesk]

I wrote these test cases

Base.@assume_effects :foldable Base.@constprop :aggressive function kill_error_edge(b1, b2, xs, x)
    y = b1 ? "julia" : xs[]
    if b2
        a = length(y)
    else
        a = sin(y)
    end
    a + x
end

Base.@assume_effects :foldable Base.@constprop :aggressive function kill_error_edge(b1, b2, xs, ys, x)
    y = b1 ? xs[] : ys[]
    if b2
        a = length(y)
    else
        a = sin(y)
    end
    a + x
end

let src = code_typed1((Bool,Base.RefValue{Any},Int,)) do b2, xs, x
        kill_error_edge(true, b2, xs, x)
    end
    @test count(@nospecialize(x)->isa(x, Core.PhiNode), src.code) == 0
end

let src = code_typed1((Bool,Base.RefValue{String}, Base.RefValue{Any},Int,)) do b2, xs, ys, x
        kill_error_edge(true, b2, xs, ys, x)
    end
    @test count(@nospecialize(x)->isa(x, Core.PhiNode), src.code) == 0
end

and I confirmed that the first case is optimized as expected, while the second case is not optimized away:

julia> code_typed((Bool,Base.RefValue{Any},Int,)) do b2, xs, x
           kill_error_edge(true, b2, xs, x)
       end
1-element Vector{Any}:
 CodeInfo(
1 ─      nothing::Nothing
└──      goto #3
2 ─      nothing::Nothing
3 ┄      goto #5 if not b2
4 ─      goto #6
5 ─      Main.sin("julia")::Union{}
6 ┄ %7 = (5 + x)::Int64
└──      goto #7
7 ─      return %7
) => Int64

julia> code_typed((Bool,Base.RefValue{String}, Base.RefValue{Any},Int,)) do b2, xs, ys, x
           kill_error_edge(true, b2, xs, ys, x)
       end
1-element Vector{Any}:
 CodeInfo(
1 ─       nothing::Nothing
│   %2  = Base.getfield(xs, :x)::String
└──       goto #3
2 ─       nothing::Nothing
3 ┄       goto #5 if not b2
4 ─ %6  = Main.length(%2)::Int64
└──       goto #6
5 ─ %8  = Main.sin(%2)::Union{}
6 ┄ %9  = φ (#4 => %6, #5 => %8)::Int64
│   %10 = (%9 + x)::Int64
└──       goto #7
7 ─       return %10
) => Int64

[aviatesk]

I found applying this diff allows the second case to be optimized as well, but I am not sure this is the right fix:

diff --git a/base/compiler/ssair/irinterp.jl b/base/compiler/ssair/irinterp.jl
index 7ca3f5352e..7e08c1acf1 100644
--- a/base/compiler/ssair/irinterp.jl
+++ b/base/compiler/ssair/irinterp.jl
@@ -259,12 +259,16 @@ function _ir_abstract_constant_propagation(interp::AbstractInterpreter, irsv::IR
                     push!(ssa_refined, idx)
                 end
             end
+            if did_reprocess
+                inst = ir.stmts[idx][:inst]
+                typ = ir.stmts[idx][:type]
+            end
             if idx == lstmt
                 # N.B.: Inst could have been updated by reprocess_instruction!
-                if did_reprocess
-                    inst = ir.stmts[idx][:inst]
-                end
                 process_terminator!(ir, inst, idx, bb, all_rets, bb_ip) && @goto residual_scan
+                if typ === Bottom && !(isa(inst, GotoIfNot) || isa(inst, GotoNode))
+                    kill_edge!(ir, bb, bb+1, update_phi!(irsv))
+                end
             elseif typ === Bottom && !isa(inst, PhiNode)
                 kill_terminator_edges!(irsv, lstmt, bb)
                 break

[Keno]

Thanks for the test cases. I've incorporated a version of your suggested fix.