Partially revert 44512 to handle duplicated spec_types inlining bug

Author: Ian Atol

base/compiler/ssair/inlining.jl

@@ -892,12 +892,7 @@ function validate_sparams(sparams::SimpleVector)
 end
 
 function analyze_method!(match::MethodMatch, argtypes::Vector{Any},
-<<<<<<< HEAD
-                         flag::UInt8, state::InliningState,
-                         do_resolve::Bool = true)
-=======
-                         flag::UInt8, state::InliningState, check_sparams::Bool = false)
->>>>>>> 0d6db0ef08 (Fixups and use concrete spvals in ssa_substitute)
+                         flag::UInt8, state::InliningState, do_resolve::Bool = true, check_sparams::Bool = false)
     method = match.method
     spec_types = match.spec_types
 
@@ -1254,7 +1249,8 @@ function compute_inlining_cases(
     cases = InliningCase[]
     local any_fully_covered = false
     local handled_all_cases = true
-    local only_method = nothing # tri-valued: nothing if unknown, false if proven untrue, otherwise the method itself
+    local revisit_idx = nothing
+    local only_method = nothing
     local meth::MethodLookupResult
     for i in 1:length(infos)
         meth = infos[i].results
@@ -1277,19 +1273,53 @@ function compute_inlining_cases(
                 only_method = false
             end
         end
-
-        check_sparams = isa(only_method, Bool)
-        for match in meth
-<<<<<<< HEAD
-            handled_all_cases &= handle_match!(match, argtypes, flag, state, cases, true, do_resolve)
-=======
-            handled_all_cases &= handle_match!(match, argtypes, flag, state, cases, true, check_sparams)
->>>>>>> 0d6db0ef08 (Fixups and use concrete spvals in ssa_substitute)
+        for (j, match) in enumerate(meth)
+            if !isdispatchtuple(match.spec_types)
+                if !match.fully_covers
+                    handled_all_cases = false
+                    continue
+                end
+                if revisit_idx === nothing
+                    revisit_idx = (i, j)
+                else
+                    handled_all_cases = false
+                    revisit_idx = nothing
+                end
+            else
+                handled_all_cases &= handle_match!(match, argtypes, flag, state, cases, true, do_resolve, check_sparams)
+            end
             any_fully_covered |= match.fully_covers
         end
     end
 
-    if !handled_all_cases
+    atype = argtypes_to_type(argtypes)
+    if handled_all_cases && revisit_idx !== nothing
+        # If there's only one case that's not a dispatchtuple, we can
+        # still unionsplit by visiting all the other cases first.
+        # This is useful for code like:
+        #   foo(x::Int) = 1
+        #   foo(@nospecialize(x::Any)) = 2
+        # where we where only a small number of specific dispatchable
+        # cases are split off from an ::Any typed fallback.
+        (i, j) = revisit_idx
+        match = infos[i].results[j]
+        handled_all_cases &= handle_match!(match, argtypes, flag, state, cases, true, true)
+    elseif length(cases) == 0 && only_method isa Method
+        # if the signature is fully covered and there is only one applicable method,
+        # we can try to inline it even if the signature is not a dispatch tuple.
+        # -- But don't try it if we already tried to handle the match in the revisit_idx
+        # case, because that'll (necessarily) be the same method.
+        if length(infos) > 1
+            (metharg, methsp) = ccall(:jl_type_intersection_with_env, Any, (Any, Any),
+                atype, only_method.sig)::SimpleVector
+            match = MethodMatch(metharg, methsp::SimpleVector, only_method, true)
+        else
+            @assert length(meth) == 1
+            match = meth[1]
+        end
+        handle_match!(match, argtypes, flag, state, cases, true, false) || return nothing
+        any_fully_covered = handled_all_cases = match.fully_covers
+    elseif !handled_all_cases
         # if we've not seen all candidates, union split is valid only for dispatch tuples
         filter!(case::InliningCase->isdispatchtuple(case.sig), cases)
     end
@@ -1369,30 +1399,19 @@ end
 
 function handle_match!(
     match::MethodMatch, argtypes::Vector{Any}, flag::UInt8, state::InliningState,
-<<<<<<< HEAD
-    cases::Vector{InliningCase}, allow_abstract::Bool = false,
-    do_resolve::Bool = true)
-    spec_types = match.spec_types
-    allow_abstract || isdispatchtuple(spec_types) || return false
-    # we may see duplicated dispatch signatures here when a signature gets widened
-    # during abstract interpretation: for the purpose of inlining, we can just skip
-    # processing this dispatch candidate
-    _any(case->case.sig === spec_types, cases) && return true
-    item = analyze_method!(match, argtypes, flag, state, do_resolve)
-=======
-    cases::Vector{InliningCase}, allow_abstract::Bool = false, check_sparams::Bool = false)
+    cases::Vector{InliningCase}, allow_abstract::Bool = false, 
+    do_resolve::Bool = true, check_sparams::Bool = false)
     spec_types = match.spec_types
     allow_abstract || isdispatchtuple(spec_types) || return false
     if check_sparams
         # we may see duplicated dispatch signatures here when a signature gets widened
         # during abstract interpretation: for the purpose of inlining, we can just skip
         # processing this dispatch candidate
         _any(case->case.sig === spec_types, cases) && return true
-        item = analyze_method!(match, argtypes, flag, state, true)
+        item = analyze_method!(match, argtypes, flag, state, do_resolve, true)
     else
-        item = analyze_method!(match, argtypes, flag, state)
+        item = analyze_method!(match, argtypes, flag, state, do_resolve)
     end
->>>>>>> 0d6db0ef08 (Fixups and use concrete spvals in ssa_substitute)
     item === nothing && return false
     push!(cases, InliningCase(spec_types, item))
     return true

base/compiler/ssair/ir.jl

@@ -1505,6 +1505,8 @@ function fixup_phinode_values!(compact::IncrementalCompact, old_values::Vector{A
     return (values, fixup)
 end
 
+56
+
 function fixup_node(compact::IncrementalCompact, @nospecialize(stmt), reify_new_nodes::Bool)
     if isa(stmt, PhiNode)
         (node, needs_fixup) = fixup_phinode_values!(compact, stmt.values, reify_new_nodes)