precompute all possible ml-matches lookup results

Store full method interference relationship graph in interferences field
of Method to avoid expensive morespecific calls during dispatch. This
provides significant performance improvements:
  - Replace method comparisons with precomputed interference lookup.
  - Optimize ml_matches minmax computation using interference lookups.
  - Optimize sort_mlmatches for large return sets by iterating over
    interferences instead of all matching methods.
  - Add method_morespecific_via_interferences in both C and Julia.

This representation may exclude some edges that are implied by
transitivity since sort_mlmatches will ensure the correct result by
following strong edges. Ambiguous edges are guaranteed to be checkable
without recursion.

Also fix a variety of bugs along the way:
 - Builtins signature would cause them to try to discard all other
   methods during `sort_mlmatches`.
 - Some ambiguities were over-estimated, which now are improved upon.
 - Setting lim==-1 now gives the same limited list of methods as lim>0,
   since that is actually faster now than attempting to give the
   unsorted list. This provides a better fix to #53814 than #57837 and
   fixes #58766.
 - Reverts recent METHOD_SIG_LATEST_HAS_NOTMORESPECIFIC attempt (though
   not the whole commit), since I found a significant problem with any
   usage of that bit during testing: it only tracks methods that
   intersect with a target, but new methods do not necessarily intersect
   with any existing target.

This provides a decent performance improvement to `methods` calls, which
implies a decent speed up to package loading also (e.g. ModelingToolkit
loads in about 4 seconds instead of 5 seconds).

Author: vtjnash

base/Base.jl

@@ -267,7 +267,9 @@ include("uuid.jl")
 include("pkgid.jl")
 include("toml_parser.jl")
 include("linking.jl")
+module StaticData
 include("staticdata.jl")
+end
 include("loading.jl")
 
 # BinaryPlatforms, used by Artifacts.  Needs `Sort`.

base/errorshow.jl

@@ -465,14 +465,15 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
     line_score = Int[]
     # These functions are special cased to only show if first argument is matched.
     special = f === convert || f === getindex || f === setindex!
+    f isa Core.Builtin && return # `methods` isn't very useful for a builtin
     funcs = Tuple{Any,Vector{Any}}[(f, arg_types_param)]
 
     # An incorrect call method produces a MethodError for convert.
     # It also happens that users type convert when they mean call. So
     # pool MethodErrors for these two functions.
     if f === convert && !isempty(arg_types_param)
         at1 = arg_types_param[1]
-        if isType(at1) && !has_free_typevars(at1)
+        if isType(at1) && !has_free_typevars(at1) && at1.parameters[1] isa Type
             push!(funcs, (at1.parameters[1], arg_types_param[2:end]))
         end
     end
@@ -494,8 +495,8 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
             end
             sig0 = sig0::DataType
             s1 = sig0.parameters[1]
-            if sig0 === Tuple || !isa(func, rewrap_unionall(s1, method.sig))
-                # function itself doesn't match or is a builtin
+            if !isa(func, rewrap_unionall(s1, method.sig))
+                # function itself doesn't match
                 continue
             else
                 print(iob, "  ")
@@ -640,6 +641,7 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs=[])
             println(io) # extra newline for spacing to stacktrace
         end
     end
+    nothing
 end
 
 # In case the line numbers in the source code have changed since the code was compiled,

base/methodshow.jl

@@ -78,7 +78,7 @@ end
 
 # NOTE: second argument is deprecated and is no longer used
 function kwarg_decl(m::Method, kwtype = nothing)
-    if m.sig !== Tuple # OpaqueClosure or Builtin
+    if !(m.sig === Tuple || m.sig <: Tuple{Core.Builtin, Vararg}) # OpaqueClosure or Builtin
         kwtype = typeof(Core.kwcall)
         sig = rewrap_unionall(Tuple{kwtype, NamedTuple, (unwrap_unionall(m.sig)::DataType).parameters...}, m.sig)
         kwli = ccall(:jl_methtable_lookup, Any, (Any, UInt), sig, get_world_counter())
@@ -218,8 +218,7 @@ function show_method(io::IO, m::Method;
                      modulecolor = :light_black, digit_align_width = 1,
                      print_signature_only::Bool = get(io, :print_method_signature_only, false)::Bool)
     tv, decls, file, line = arg_decl_parts(m)
-    sig = unwrap_unionall(m.sig)
-    if sig === Tuple
+    if m.sig <: Tuple{Core.Builtin, Vararg}
         # Builtin
         print(io, m.name, "(...)")
         file = "none"
@@ -424,8 +423,7 @@ end
 function show(io::IO, ::MIME"text/html", m::Method)
     tv, decls, file, line = arg_decl_parts(m, true)
     sig = unwrap_unionall(m.sig)
-    if sig === Tuple
-        # Builtin
+    if sig <: Tuple{Core.Builtin, Vararg}
         print(io, m.name, "(...) in ", parentmodule(m))
         return
     end

base/runtime_internals.jl

@@ -1478,15 +1478,7 @@ end
 function matches_to_methods(ms::Array{Any,1}, tn::Core.TypeName, mod)
     # Lack of specialization => a comprehension triggers too many invalidations via _collect, so collect the methods manually
     ms = Method[(ms[i]::Core.MethodMatch).method for i in 1:length(ms)]
-    # Remove shadowed methods with identical type signatures
-    prev = nothing
-    filter!(ms) do m
-        l = prev
-        repeated = (l isa Method && m.sig == l.sig)
-        prev = m
-        return !repeated
-    end
-    # Remove methods not part of module (after removing shadowed methods)
+    # Remove methods not part of module
     mod === nothing || filter!(ms) do m
         return parentmodule(m) ∈ mod
     end