Merge branch 'master' into sort-dispatch

Author: LilithHafner

CONTRIBUTING.md

@@ -58,9 +58,9 @@ A useful bug report filed as a GitHub issue provides information about how to re
 
 ### Writing tests
 
-There are never enough tests. Track [code coverage at Coveralls](https://coveralls.io/r/JuliaLang/julia), and help improve it.
+There are never enough tests. Track [code coverage at Codecov](https://codecov.io/github/JuliaLang/julia), and help improve it.
 
-1. Go visit https://coveralls.io/r/JuliaLang/julia.
+1. Go visit https://codecov.io/github/JuliaLang/julia.
 
 2. Browse through the source files and find some untested functionality (highlighted in red) that you think you might be able to write a test for.
 
@@ -74,7 +74,7 @@ There are never enough tests. Track [code coverage at Coveralls](https://coveral
 * You can see the current buildbot setup at: https://build.julialang.org/builders
 * [Issue 9493](https://github.com/JuliaLang/julia/issues/9493) and [issue 11885](https://github.com/JuliaLang/julia/issues/11885) have more detailed discussion on code coverage.
 
-Coveralls shows functionality that still needs "proof of concept" tests. These are important, as are tests for tricky edge cases, such as converting between integer types when the number to convert is near the maximum of the range of one of the integer types. Even if a function already has some coverage on Coveralls, it may still benefit from tests for edge cases.
+Code coverage shows functionality that still needs "proof of concept" tests. These are important, as are tests for tricky edge cases, such as converting between integer types when the number to convert is near the maximum of the range of one of the integer types. Even if a function already has some coverage on Codecov, it may still benefit from tests for edge cases.
 
 ### Improving documentation
 
@@ -340,9 +340,8 @@ please remove the `backport-X.Y` tag from the originating pull request for the c
 ### Git Recommendations For Pull Requests
 
  - Avoid working from the `master` branch of your fork, creating a new branch will make it easier if Julia's `master` changes and you need to update your pull request.
- - Try to [squash](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) together small commits that make repeated changes to the same section of code so your pull request is easier to review, and Julia's history won't have any broken intermediate commits. A reasonable number of separate well-factored commits is fine, especially for larger changes.
+ - Try to [squash](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) together small commits that make repeated changes to the same section of code so your pull request is easier to review. A reasonable number of separate well-factored commits is fine, especially for larger changes.
  - If any conflicts arise due to changes in Julia's `master`, prefer updating your pull request branch with `git rebase` versus `git merge` or `git pull`, since the latter will introduce merge commits that clutter the git history with noise that makes your changes more difficult to review.
- - If you see any unrelated changes to submodules like `deps/libuv`, `deps/openlibm`, etc., try running `git submodule update` first.
  - Descriptive commit messages are good.
  - Using `git add -p` or `git add -i` can be useful to avoid accidentally committing unrelated changes.
  - When linking to specific lines of code in discussion of an issue or pull request, hit the `y` key while viewing code on GitHub to reload the page with a URL that includes the specific version that you're viewing. That way any lines of code that you refer to will still make sense in the future, even if the content of the file changes.
@@ -364,7 +363,7 @@ please remove the `backport-X.Y` tag from the originating pull request for the c
   - **Community:** <https://julialang.org/community/>
   - **Source code:** <https://github.com/JuliaLang/julia>
   - **Documentation:** <https://docs.julialang.org>
-  - **Code coverage:** <https://coveralls.io/r/JuliaLang/julia>
+  - **Code coverage:** <https://codecov.io/github/JuliaLang/julia>
 
 * Design of Julia
   - [Julia: A Fresh Approach to Numerical Computing](https://julialang.org/assets/research/julia-fresh-approach-BEKS.pdf)

NEWS.md

@@ -272,7 +272,7 @@ struct UnionSplitMethodMatches
     fullmatches::Vector{Bool}
     nonoverlayed::Bool
 end
-any_ambig(m::UnionSplitMethodMatches) = _any(any_ambig, m.info.matches)
+any_ambig(m::UnionSplitMethodMatches) = any(any_ambig, m.info.matches)
 
 function find_matching_methods(argtypes::Vector{Any}, @nospecialize(atype), method_table::MethodTableView,
                                union_split::Int, max_methods::Int)
@@ -304,7 +304,7 @@ function find_matching_methods(argtypes::Vector{Any}, @nospecialize(atype), meth
                 push!(applicable_argtypes, arg_n)
             end
             valid_worlds = intersect(valid_worlds, matches.valid_worlds)
-            thisfullmatch = _any(match->(match::MethodMatch).fully_covers, matches)
+            thisfullmatch = any(match::MethodMatch->match.fully_covers, matches)
             found = false
             for (i, mt′) in enumerate(mts)
                 if mt′ === mt
@@ -338,7 +338,7 @@ function find_matching_methods(argtypes::Vector{Any}, @nospecialize(atype), meth
             return FailedMethodMatch("Too many methods matched")
         end
         (; matches, overlayed) = result
-        fullmatch = _any(match->(match::MethodMatch).fully_covers, matches)
+        fullmatch = any(match::MethodMatch->match.fully_covers, matches)
         return MethodMatches(matches.matches,
                              MethodMatchInfo(matches),
                              matches.valid_worlds,
@@ -654,7 +654,7 @@ function edge_matches_sv(frame::InferenceState, method::Method, @nospecialize(si
 
         # check in the cycle list first
         # all items in here are mutual parents of all others
-        if !_any(p::InferenceState->matches_sv(p, sv), frame.callers_in_cycle)
+        if !any(p::InferenceState->matches_sv(p, sv), frame.callers_in_cycle)
             let parent = frame.parent
                 parent !== nothing || return false
                 parent = parent::InferenceState
@@ -847,7 +847,7 @@ function concrete_eval_call(interp::AbstractInterpreter,
     end
 end
 
-has_conditional(argtypes::Vector{Any}) = _any(@nospecialize(x)->isa(x, Conditional), argtypes)
+has_conditional(argtypes::Vector{Any}) = any(@nospecialize(x)->isa(x, Conditional), argtypes)
 has_conditional((; argtypes)::ArgInfo) = has_conditional(argtypes)
 
 function const_prop_enabled(interp::AbstractInterpreter, sv::InferenceState, match::MethodMatch)
@@ -874,6 +874,69 @@ struct ConstCallResults
         new(rt, const_result, effects, edge)
 end
 
+struct ConditionalArgtypes <: ForwardableArgtypes
+    arginfo::ArgInfo
+    sv::InferenceState
+end
+
+"""
+    matching_cache_argtypes(linfo::MethodInstance, argtypes::ConditionalArgtypes)
+
+The implementation is able to forward `Conditional` of `argtypes`,
+as well as the other general extended lattice inforamtion.
+"""
+function matching_cache_argtypes(linfo::MethodInstance, argtypes::ConditionalArgtypes)
+    (; arginfo, sv) = argtypes
+    (; fargs, argtypes) = arginfo
+    given_argtypes = Vector{Any}(undef, length(argtypes))
+    def = linfo.def::Method
+    nargs = Int(def.nargs)
+    cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo)
+    local condargs = nothing
+    for i in 1:length(argtypes)
+        argtype = argtypes[i]
+        # forward `Conditional` if it conveys a constraint on any other argument
+        if isa(argtype, Conditional) && fargs !== nothing
+            cnd = argtype
+            slotid = find_constrained_arg(cnd, fargs, sv)
+            if slotid !== nothing
+                # using union-split signature, we may be able to narrow down `Conditional`
+                sigt = widenconst(slotid > nargs ? argtypes[slotid] : cache_argtypes[slotid])
+                thentype = tmeet(cnd.thentype, sigt)
+                elsetype = tmeet(cnd.elsetype, sigt)
+                if thentype === Bottom && elsetype === Bottom
+                    # we accidentally proved this method match is impossible
+                    # TODO bail out here immediately rather than just propagating Bottom ?
+                    given_argtypes[i] = Bottom
+                else
+                    if condargs === nothing
+                        condargs = Tuple{Int,Int}[]
+                    end
+                    push!(condargs, (slotid, i))
+                    given_argtypes[i] = Conditional(slotid, thentype, elsetype)
+                end
+                continue
+            end
+        end
+        given_argtypes[i] = widenconditional(argtype)
+    end
+    if condargs !== nothing
+        given_argtypes = let condargs=condargs
+            va_process_argtypes(given_argtypes, linfo) do isva_given_argtypes::Vector{Any}, last::Int
+                # invalidate `Conditional` imposed on varargs
+                for (slotid, i) in condargs
+                    if slotid ≥ last && (1 ≤ i ≤ length(isva_given_argtypes)) # `Conditional` is already widened to vararg-tuple otherwise
+                        isva_given_argtypes[i] = widenconditional(isva_given_argtypes[i])
+                    end
+                end
+            end
+        end
+    else
+        given_argtypes = va_process_argtypes(given_argtypes, linfo)
+    end
+    return pick_const_args!(cache_argtypes, overridden_by_const, given_argtypes)
+end
+
 function abstract_call_method_with_const_args(interp::AbstractInterpreter,
     result::MethodCallResult, @nospecialize(f), arginfo::ArgInfo, si::StmtInfo, match::MethodMatch,
     sv::InferenceState, invokecall::Union{Nothing,InvokeCall}=nothing)
@@ -920,7 +983,7 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter,
             add_remark!(interp, sv, "[constprop] Edge cycle encountered")
             return nothing
         end
-        inf_result = InferenceResult(mi, (arginfo, sv))
+        inf_result = InferenceResult(mi, ConditionalArgtypes(arginfo, sv))
         if !any(inf_result.overridden_by_const)
             add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
             return nothing
@@ -1260,7 +1323,7 @@ function precise_container_type(interp::AbstractInterpreter, @nospecialize(itft)
     end
     if isa(tti, Union)
         utis = uniontypes(tti)
-        if _any(@nospecialize(t) -> !isa(t, DataType) || !(t <: Tuple) || !isknownlength(t), utis)
+        if any(@nospecialize(t) -> !isa(t, DataType) || !(t <: Tuple) || !isknownlength(t), utis)
             return Any[Vararg{Any}], nothing
         end
         ltp = length((utis[1]::DataType).parameters)

base/compiler/abstractinterpretation.jl

@@ -1,5 +1,73 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+"""
+    matching_cache_argtypes(linfo::MethodInstance) ->
+        (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
+
+Returns argument types `cache_argtypes::Vector{Any}` for `linfo` that are in the native
+Julia type domain. `overridden_by_const::BitVector` is all `false` meaning that
+there is no additional extended lattice information there.
+
+    matching_cache_argtypes(linfo::MethodInstance, argtypes::ForwardableArgtypes) ->
+        (cache_argtypes::Vector{Any}, overridden_by_const::BitVector)
+
+Returns cache-correct extended lattice argument types `cache_argtypes::Vector{Any}`
+for `linfo` given some `argtypes` accompanied by `overridden_by_const::BitVector`
+that marks which argument contains additional extended lattice information.
+
+In theory, there could be a `cache` containing a matching `InferenceResult`
+for the provided `linfo` and `given_argtypes`. The purpose of this function is
+to return a valid value for `cache_lookup(𝕃, linfo, argtypes, cache).argtypes`,
+so that we can construct cache-correct `InferenceResult`s in the first place.
+"""
+function matching_cache_argtypes end
+
+function matching_cache_argtypes(linfo::MethodInstance)
+    mthd = isa(linfo.def, Method) ? linfo.def::Method : nothing
+    cache_argtypes = most_general_argtypes(mthd, linfo.specTypes)
+    return cache_argtypes, falses(length(cache_argtypes))
+end
+
+struct SimpleArgtypes
+    argtypes::Vector{Any}
+end
+
+"""
+    matching_cache_argtypes(linfo::MethodInstance, argtypes::SimpleArgtypes)
+
+The implementation for `argtypes` with general extended lattice information.
+This is supposed to be used for debugging and testing or external `AbstractInterpreter`
+usages and in general `matching_cache_argtypes(::MethodInstance, ::ConditionalArgtypes)`
+is more preferred it can forward `Conditional` information.
+"""
+function matching_cache_argtypes(linfo::MethodInstance, simple_argtypes::SimpleArgtypes)
+    (; argtypes) = simple_argtypes
+    given_argtypes = Vector{Any}(undef, length(argtypes))
+    for i = 1:length(argtypes)
+        given_argtypes[i] = widenconditional(argtypes[i])
+    end
+    given_argtypes = va_process_argtypes(given_argtypes, linfo)
+    return pick_const_args(linfo, given_argtypes)
+end
+
+function pick_const_args(linfo::MethodInstance, given_argtypes::Vector{Any})
+    cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo)
+    return pick_const_args!(cache_argtypes, overridden_by_const, given_argtypes)
+end
+
+function pick_const_args!(cache_argtypes::Vector{Any}, overridden_by_const::BitVector, given_argtypes::Vector{Any})
+    for i = 1:length(given_argtypes)
+        given_argtype = given_argtypes[i]
+        cache_argtype = cache_argtypes[i]
+        if !is_argtype_match(fallback_lattice, given_argtype, cache_argtype, false)
+            # prefer the argtype we were given over the one computed from `linfo`
+            cache_argtypes[i] = given_argtype
+            overridden_by_const[i] = true
+        end
+    end
+    return cache_argtypes, overridden_by_const
+end
+
 function is_argtype_match(lattice::AbstractLattice,
                           @nospecialize(given_argtype),
                           @nospecialize(cache_argtype),
@@ -17,10 +85,12 @@ function is_forwardable_argtype(@nospecialize x)
            isa(x, PartialOpaque)
 end
 
-function va_process_argtypes(given_argtypes::Vector{Any}, mi::MethodInstance,
-                             condargs::Union{Vector{Tuple{Int,Int}}, Nothing}=nothing)
-    isva = mi.def.isva
-    nargs = Int(mi.def.nargs)
+va_process_argtypes(given_argtypes::Vector{Any}, linfo::MethodInstance) =
+    va_process_argtypes(Returns(nothing), given_argtypes, linfo)
+function va_process_argtypes(@nospecialize(va_handler!), given_argtypes::Vector{Any}, linfo::MethodInstance)
+    def = linfo.def::Method
+    isva = def.isva
+    nargs = Int(def.nargs)
     if isva || isvarargtype(given_argtypes[end])
         isva_given_argtypes = Vector{Any}(undef, nargs)
         for i = 1:(nargs - isva)
@@ -33,74 +103,14 @@ function va_process_argtypes(given_argtypes::Vector{Any}, mi::MethodInstance,
                 last = nargs
             end
             isva_given_argtypes[nargs] = tuple_tfunc(given_argtypes[last:end])
-            # invalidate `Conditional` imposed on varargs
-            if condargs !== nothing
-                for (slotid, i) in condargs
-                    if slotid ≥ last && (1 ≤ i ≤ length(isva_given_argtypes)) # `Conditional` is already widened to vararg-tuple otherwise
-                        isva_given_argtypes[i] = widenconditional(isva_given_argtypes[i])
-                    end
-                end
-            end
+            va_handler!(isva_given_argtypes, last)
         end
         return isva_given_argtypes
     end
+    @assert length(given_argtypes) == nargs "invalid `given_argtypes` for `linfo`"
     return given_argtypes
 end
 
-# In theory, there could be a `cache` containing a matching `InferenceResult`
-# for the provided `linfo` and `given_argtypes`. The purpose of this function is
-# to return a valid value for `cache_lookup(linfo, argtypes, cache).argtypes`,
-# so that we can construct cache-correct `InferenceResult`s in the first place.
-function matching_cache_argtypes(
-    linfo::MethodInstance, (arginfo, sv)#=::Tuple{ArgInfo,InferenceState}=#)
-    (; fargs, argtypes) = arginfo
-    def = linfo.def
-    @assert isa(def, Method) # ensure the next line works
-    nargs::Int = def.nargs
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo, nothing)
-    given_argtypes = Vector{Any}(undef, length(argtypes))
-    local condargs = nothing
-    for i in 1:length(argtypes)
-        argtype = argtypes[i]
-        # forward `Conditional` if it conveys a constraint on any other argument
-        if isa(argtype, Conditional) && fargs !== nothing
-            cnd = argtype
-            slotid = find_constrained_arg(cnd, fargs, sv)
-            if slotid !== nothing
-                # using union-split signature, we may be able to narrow down `Conditional`
-                sigt = widenconst(slotid > nargs ? argtypes[slotid] : cache_argtypes[slotid])
-                thentype = tmeet(cnd.thentype, sigt)
-                elsetype = tmeet(cnd.elsetype, sigt)
-                if thentype === Bottom && elsetype === Bottom
-                    # we accidentally proved this method match is impossible
-                    # TODO bail out here immediately rather than just propagating Bottom ?
-                    given_argtypes[i] = Bottom
-                else
-                    if condargs === nothing
-                        condargs = Tuple{Int,Int}[]
-                    end
-                    push!(condargs, (slotid, i))
-                    given_argtypes[i] = Conditional(slotid, thentype, elsetype)
-                end
-                continue
-            end
-        end
-        given_argtypes[i] = widenconditional(argtype)
-    end
-    given_argtypes = va_process_argtypes(given_argtypes, linfo, condargs)
-    @assert length(given_argtypes) == nargs
-    for i in 1:nargs
-        given_argtype = given_argtypes[i]
-        cache_argtype = cache_argtypes[i]
-        if !is_argtype_match(fallback_lattice, given_argtype, cache_argtype, false)
-            # prefer the argtype we were given over the one computed from `linfo`
-            cache_argtypes[i] = given_argtype
-            overridden_by_const[i] = true
-        end
-    end
-    return cache_argtypes, overridden_by_const
-end
-
 function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(specTypes),
     withfirst::Bool = true)
     toplevel = method === nothing
@@ -202,12 +212,6 @@ function elim_free_typevars(@nospecialize t)
     end
 end
 
-function matching_cache_argtypes(linfo::MethodInstance, ::Nothing)
-    mthd = isa(linfo.def, Method) ? linfo.def::Method : nothing
-    cache_argtypes = most_general_argtypes(mthd, linfo.specTypes)
-    return cache_argtypes, falses(length(cache_argtypes))
-end
-
 function cache_lookup(lattice::AbstractLattice, linfo::MethodInstance, given_argtypes::Vector{Any}, cache::Vector{InferenceResult})
     method = linfo.def::Method
     nargs::Int = method.nargs

base/compiler/inferenceresult.jl

@@ -228,12 +228,6 @@ end
 is_effect_overridden(method::Method, effect::Symbol) = is_effect_overridden(decode_effects_override(method.purity), effect)
 is_effect_overridden(override::EffectsOverride, effect::Symbol) = getfield(override, effect)
 
-function InferenceResult(
-    linfo::MethodInstance,
-    arginfo::Union{Nothing,Tuple{ArgInfo,InferenceState}} = nothing)
-    return _InferenceResult(linfo, arginfo)
-end
-
 add_remark!(::AbstractInterpreter, sv::Union{InferenceState, IRCode}, remark) = return
 
 function bail_out_toplevel_call(::AbstractInterpreter, @nospecialize(callsig), sv::Union{InferenceState, IRCode})

base/compiler/inferencestate.jl

@@ -11,7 +11,7 @@ the original `ci::CodeInfo` are modified.
 function inflate_ir!(ci::CodeInfo, linfo::MethodInstance)
     sptypes = sptypes_from_meth_instance(linfo)
     if ci.inferred
-        argtypes, _ = matching_cache_argtypes(linfo, nothing)
+        argtypes, _ = matching_cache_argtypes(linfo)
     else
         argtypes = Any[ Any for i = 1:length(ci.slotflags) ]
     end