inlining: Also apply statement effects when declining to inline

When inlining, we already determine what the effects for all
the different cases are, so that we can apply appropriate statement
flags on each of the edges. However, if for some reason we decided
to decline to inline, we weren't making use of this information.
Fix that.

Author: Keno

base/compiler/ssair/inlining.jl

@@ -1288,6 +1288,22 @@ function handle_any_const_result!(cases::Vector{InliningCase}, @nospecialize(res
     end
 end
 
+function info_effects(@nospecialize(result), match::MethodMatch, state::InliningState)
+    if isa(result, Union{ConcreteResult, SemiConcreteResult})
+        return result.effects
+    elseif isa(result, ConstPropResult)
+        return result.result.ipo_effects
+    else
+        mi = specialize_method(match; preexisting=true)
+        code = get(state.mi_cache, mi, nothing)
+        if code isa CodeInstance
+            return decode_effects(code.ipo_purity_bits)
+        else
+            return Effects()
+        end
+    end
+end
+
 function compute_inlining_cases(info::Union{ConstCallInfo, Vector{MethodMatchInfo}},
     flag::UInt8, sig::Signature, state::InliningState)
     argtypes = sig.argtypes
@@ -1306,6 +1322,7 @@ function compute_inlining_cases(info::Union{ConstCallInfo, Vector{MethodMatchInf
     local meth::MethodLookupResult
     local all_result_count = 0
 
+    joint_effects = EFFECTS_TOTAL
     for i in 1:length(infos)
         meth = infos[i].results
         if meth.ambig
@@ -1331,6 +1348,7 @@ function compute_inlining_cases(info::Union{ConstCallInfo, Vector{MethodMatchInf
             all_result_count += 1
             result = results === nothing ? nothing : results[all_result_count]
             any_fully_covered |= match.fully_covers
+            joint_effects = merge_effects(joint_effects, info_effects(result, match, state))
             if !validate_sparams(match.sparams)
                 if !match.fully_covers
                     handled_all_cases = false
@@ -1348,6 +1366,10 @@ function compute_inlining_cases(info::Union{ConstCallInfo, Vector{MethodMatchInf
         end
     end
 
+    if !any_fully_covered
+        joint_effects = Effects()
+    end
+
     if handled_all_cases && revisit_idx !== nothing
         # we handled everything except one match with unmatched sparams,
         # so try to handle it by bypassing validate_sparams
@@ -1377,17 +1399,17 @@ function compute_inlining_cases(info::Union{ConstCallInfo, Vector{MethodMatchInf
         filter!(case::InliningCase->isdispatchtuple(case.sig), cases)
     end
 
-    return cases, handled_all_cases & any_fully_covered
+    return cases, handled_all_cases & any_fully_covered, joint_effects
 end
 
 function handle_call!(
     ir::IRCode, idx::Int, stmt::Expr, infos::Vector{MethodMatchInfo}, flag::UInt8,
     sig::Signature, state::InliningState, todo::Vector{Pair{Int, Any}})
     cases = compute_inlining_cases(infos, flag, sig, state)
     cases === nothing && return nothing
-    cases, all_covered = cases
+    cases, all_covered, joint_effects = cases
     handle_cases!(ir, idx, stmt, argtypes_to_type(sig.argtypes), cases,
-        all_covered, todo, state.params)
+        all_covered, todo, state.params, joint_effects)
 end
 
 function handle_const_call!(
@@ -1397,7 +1419,7 @@ function handle_const_call!(
     cases === nothing && return nothing
     cases, all_covered = cases
     handle_cases!(ir, idx, stmt, argtypes_to_type(sig.argtypes), cases,
-        all_covered, todo, state.params)
+        all_covered, todo, state.params, joint_effects)
 end
 
 function handle_match!(
@@ -1452,7 +1474,7 @@ end
 
 function handle_cases!(ir::IRCode, idx::Int, stmt::Expr, @nospecialize(atype),
     cases::Vector{InliningCase}, fully_covered::Bool, todo::Vector{Pair{Int, Any}},
-    params::OptimizationParams)
+    params::OptimizationParams, joint_effects::Effects)
     # If we only have one case and that case is fully covered, we may either
     # be able to do the inlining now (for constant cases), or push it directly
     # onto the todo list
@@ -1464,6 +1486,8 @@ function handle_cases!(ir::IRCode, idx::Int, stmt::Expr, @nospecialize(atype),
             isa(case.sig, DataType) || return nothing
         end
         push!(todo, idx=>UnionSplit(fully_covered, atype, cases))
+    else
+        ir[SSAValue(idx)][:flag] |= flags_for_effects(joint_effects)
     end
     return nothing
 end

test/compiler/inline.jl

@@ -1522,3 +1522,13 @@ let src = code_typed1(fvarargN_inline, (Tuple{Vararg{Int}},))
                  count(iscall((src, Core._svec_ref)), src.code) == 0 &&
                  count(iscall((src, Core.nfields)), src.code) == 1
 end
+
+# Test effect annotation of declined inline unionsplit
+f_union_unmatched(x::Union{Nothing, Type{T}}) where {T} = nothing
+function g_union_unmatched(x)
+    if isa(x, Union{Nothing, Type})
+        foo(x)
+    end
+    return nothing
+end
+@test fully_eliminated(g_union_unmatched, Tuple{Any})