inference: fix backedge correctness for applicable calls

Even if the return value of `applicable(f, args...)` is initially
inferred as `Const(true)`, when a new method is added to `f` then it may
cause new method match ambiguities, requiring the call to return return
`false` at the next invocation. To handle such cases, it is necessary to
always add a method table backedge in the inference of `applicable`.

Also just as a minor backedge reduction optimization, this commit avoids
adding backedges when `applicable` is inferred to return `::Bool`.

Author: aviatesk

base/compiler/abstractinterpretation.jl

@@ -267,12 +267,14 @@ any_ambig(info::MethodMatchInfo) = any_ambig(info.results)
 any_ambig(m::MethodMatches) = any_ambig(m.info)
 fully_covering(info::MethodMatchInfo) = info.fullmatch
 fully_covering(m::MethodMatches) = fully_covering(m.info)
-function add_uncovered_edges!(sv::AbsIntState, info::MethodMatchInfo, @nospecialize(atype))
-    fully_covering(info) || add_mt_backedge!(sv, info.mt, atype)
+function add_uncovered_edges!(sv::AbsIntState, info::MethodMatchInfo, @nospecialize(atype), force::Bool=false)
+    if !fully_covering(info) || force
+        add_mt_backedge!(sv, info.mt, atype)
+    end
     nothing
 end
-add_uncovered_edges!(sv::AbsIntState, matches::MethodMatches, @nospecialize(atype)) =
-    add_uncovered_edges!(sv, matches.info, atype)
+add_uncovered_edges!(sv::AbsIntState, matches::MethodMatches, @nospecialize(atype), force::Bool=false) =
+    add_uncovered_edges!(sv, matches.info, atype, force)
 
 struct UnionSplitMethodMatches
     applicable::Vector{Any}
@@ -284,15 +286,15 @@ any_ambig(info::UnionSplitInfo) = any(any_ambig, info.split)
 any_ambig(m::UnionSplitMethodMatches) = any_ambig(m.info)
 fully_covering(info::UnionSplitInfo) = all(fully_covering, info.split)
 fully_covering(m::UnionSplitMethodMatches) = fully_covering(m.info)
-function add_uncovered_edges!(sv::AbsIntState, info::UnionSplitInfo, @nospecialize(atype))
-    all(fully_covering, info.split) && return nothing
+function add_uncovered_edges!(sv::AbsIntState, info::UnionSplitInfo, @nospecialize(atype), force::Bool=false)
+    all(fully_covering, info.split) && !force && return nothing
     # add mt backedges with removing duplications
     for mt in uncovered_method_tables(info)
-        add_mt_backedge!(sv, mt, atype)
+        add_mt_backedge!(sv, mt, atype, force)
     end
 end
-add_uncovered_edges!(sv::AbsIntState, matches::UnionSplitMethodMatches, @nospecialize(atype)) =
-    add_uncovered_edges!(sv, matches.info, atype)
+add_uncovered_edges!(sv::AbsIntState, matches::UnionSplitMethodMatches, @nospecialize(atype), force::Bool=false) =
+    add_uncovered_edges!(sv, matches.info, atype, force)
 function uncovered_method_tables(info::UnionSplitInfo)
     mts = MethodTable[]
     for mminfo in info.split

base/compiler/tfuncs.jl

@@ -3006,14 +3006,16 @@ function abstract_applicable(interp::AbstractInterpreter, argtypes::Vector{Any},
         else
             rt = Const(true) # has applicable matches
         end
-        for i in 1:napplicable
-            match = applicable[i]::MethodMatch
-            edge = specialize_method(match)::MethodInstance
-            add_backedge!(sv, edge)
-        end
-        # also need an edge to the method table in case something gets
-        # added that did not intersect with any existing method
-        add_uncovered_edges!(sv, matches, atype)
+        if rt !== Bool
+            for i in 1:napplicable
+                match = applicable[i]::MethodMatch
+                edge = specialize_method(match)
+                add_backedge!(sv, edge)
+            end
+            # also need an edge to the method table in case something gets
+            # added that did not intersect with any existing method
+            add_uncovered_edges!(sv, matches, atype, #=force=#true)
+        end
     end
     return Future(CallMeta(rt, Union{}, EFFECTS_TOTAL, NoCallInfo()))
 end

test/compiler/inference.jl

@@ -5104,6 +5104,21 @@ fapplicable(::Integer, ::Int32) = 3
 @test only(Base.return_types((Tuple{Vararg{Int}},)) do x; Val(applicable(sin, 1, x...)); end) == Val
 @test only(Base.return_types((Tuple{Vararg{Int}},)) do x; Val(applicable(sin, 1, 2, x...)); end) === Val{false}
 
+function fapplicable2 end
+gapplicable2(args...) = Val(applicable(fapplicable2, args...))
+fapplicable2(x::Int, y) = 1
+@test Base.infer_return_type((Int,Int)) do x, y
+    gapplicable2(x, y)
+end === Val{true}
+fapplicable2(x, y::Int) = 2 # now `fapplicable2(::Int, ::Int)` is ambiguous
+@test Base.infer_return_type((Int,Int)) do x, y
+    gapplicable2(x, y)
+end === Val{false}
+fapplicable2(x::Int, y::Int) = 3 # now `fapplicable2(::Int, ::Int)` is applicable
+@test Base.infer_return_type((Int,Int)) do x, y
+    gapplicable2(x, y)
+end === Val{true}
+
 function fhasmethod end
 ghasmethod() = Val(hasmethod(fhasmethod, Tuple{}))
 @test only(Base.return_types(ghasmethod, ())) === Val{false}