Tweaks to reduce latency (#590)

Investigation via `SnoopCompile.@snoopi_deep` identified several
opportunities to reduce latency:
- JuliaLang/julia#38906
- JuliaDebug/JuliaInterpreter.jl#461
- JuliaDebug/LoweredCodeUtils.jl#58

Together with the changes here, the aggregate effect is to reduce
the time for the first revision from 3.1s
to about 1.5s. That's much more reasonable.

src/lowered.jl

@@ -55,7 +55,7 @@ function matches_eval(stmt::Expr)
  (isa(f, GlobalRef) && f.name === :eval) || is_quotenode_egal(f, Core.eval)
 end
 
-function categorize_stmt(stmt)
+function categorize_stmt(@nospecialize(stmt))
  ismeth, haseval, isinclude, isnamespace, istoplevel = false, false, false, false, false
  if isa(stmt, Expr)
  haseval = matches_eval(stmt)
@@ -77,7 +77,7 @@ to `Revise.is_method_or_eval`.
 Since the contents of such expression are difficult to analyze, it is generally
 safest to execute all such evals.
 """
-function minimal_evaluation!(predicate, methodinfo, src::Core.CodeInfo, mode::Symbol)
+function minimal_evaluation!(@nospecialize(predicate), methodinfo, src::Core.CodeInfo, mode::Symbol)
  edges = CodeEdges(src)
  # LoweredCodeUtils.print_with_code(stdout, src, edges)
  isrequired = fill(false, length(src.code))
@@ -112,11 +112,11 @@ function minimal_evaluation!(predicate, methodinfo, src::Core.CodeInfo, mode::Sy
  add_dependencies!(methodinfo, edges, src, isrequired)
  return isrequired, evalassign
 end
-minimal_evaluation!(predicate, methodinfo, frame::JuliaInterpreter.Frame, mode::Symbol) =
+minimal_evaluation!(@nospecialize(predicate), methodinfo, frame::JuliaInterpreter.Frame, mode::Symbol) =
  minimal_evaluation!(predicate, methodinfo, frame.framecode.src, mode)
 
 function minimal_evaluation!(methodinfo, frame, mode::Symbol)
- minimal_evaluation!(methodinfo, frame, mode) do stmt
+ minimal_evaluation!(methodinfo, frame, mode) do @nospecialize(stmt)
  ismeth, haseval, isinclude, isnamespace, istoplevel = categorize_stmt(stmt)
  isreq = ismeth | isinclude | istoplevel
  return mode === :sigs ? (isreq, haseval) : (isreq | isnamespace, haseval)
@@ -184,7 +184,7 @@ function methods_by_execution!(@nospecialize(recurse), methodinfo, docexprs, mod
  end
  if lwr.head !== :thunk
  mode === :sigs && return nothing, nothing
- return Core.eval(mod, lwr)
+ return Core.eval(mod, lwr), nothing
  end
  frame = JuliaInterpreter.Frame(mod, lwr.args[1])
  mode === :eval || LoweredCodeUtils.rename_framemethods!(recurse, frame)

src/packagedef.jl

@@ -232,6 +232,12 @@ const silencefile = Ref(joinpath(depsdir, "silence.txt")) # Ref so that tests d
 ## now this is the right strategy.) From the standpoint of CodeTracking, we should
 ## link the signature to the actual method-defining expression (either :(f() = 1) or :(g() = 2)).
 
+if isdefined(Core, :MethodMatch)
+ get_method_from_match(mm::Core.MethodMatch) = mm.method
+else
+ get_method_from_match(mm::Core.SimpleVector) = mm[3]::Method
+end
+
 function delete_missing!(exs_sigs_old::ExprsSigs, exs_sigs_new)
  with_logger(_debug_logger) do
  for (ex, sigs) in exs_sigs_old
@@ -242,7 +248,7 @@ function delete_missing!(exs_sigs_old::ExprsSigs, exs_sigs_new)
  ret = Base._methods_by_ftype(sig, -1, typemax(UInt))
  success = false
  if !isempty(ret)
- m = ret[end][3]::Method # the last method returned is the least-specific that matches, and thus most likely to be type-equal
+ m = get_method_from_match(ret[end]) # the last method returned is the least-specific that matches, and thus most likely to be type-equal
  methsig = m.sig
  if sig <: methsig && methsig <: sig
  locdefs = get(CodeTracking.method_info, sig, nothing)
@@ -408,10 +414,12 @@ function add_signature!(methodinfo::CodeTrackingMethodInfo, @nospecialize(sig),
  locdefs = get(CodeTracking.method_info, sig, nothing)
  locdefs === nothing && (locdefs = CodeTracking.method_info[sig] = Tuple{LineNumberNode,Expr}[])
  newdef = unwrap(methodinfo.exprstack[end])
- if !any(locdef->locdef[1] == ln && isequal(RelocatableExpr(locdef[2]), RelocatableExpr(newdef)), locdefs)
- push!(locdefs, (fixpath(ln), newdef))
+ if newdef !== nothing
+ if !any(locdef->locdef[1] == ln && isequal(RelocatableExpr(locdef[2]), RelocatableExpr(newdef)), locdefs)
+ push!(locdefs, (fixpath(ln), newdef))
+ end
+ push!(methodinfo.allsigs, sig)
  end
- push!(methodinfo.allsigs, sig)
  return methodinfo
 end
 push_expr!(methodinfo::CodeTrackingMethodInfo, mod::Module, ex::Expr) = (push!(methodinfo.exprstack, ex); methodinfo)
@@ -452,7 +460,7 @@ end
 function eval_with_signatures(mod, ex::Expr; mode=:eval, kwargs...)
  methodinfo = CodeTrackingMethodInfo(ex)
  docexprs = DocExprs()
- _, frame = methods_by_execution!(finish_and_return!, methodinfo, docexprs, mod, ex; mode=mode, kwargs...)
+ frame = methods_by_execution!(finish_and_return!, methodinfo, docexprs, mod, ex; mode=mode, kwargs...)[2]
  return methodinfo.allsigs, methodinfo.deps, methodinfo.includes, frame
 end
 

src/precompile.jl

@@ -29,6 +29,7 @@ function _precompile_()
 
  MI = CodeTrackingMethodInfo
  @assert precompile(Tuple{typeof(minimal_evaluation!), MI, Core.CodeInfo, Symbol})
+ @assert precompile(Tuple{typeof(minimal_evaluation!), Any, MI, Core.CodeInfo, Symbol})
  @assert precompile(Tuple{typeof(methods_by_execution!), Any, MI, DocExprs, Module, Expr})
  @assert precompile(Tuple{typeof(methods_by_execution!), Any, MI, DocExprs, JuliaInterpreter.Frame, Vector{Bool}})
  @assert precompile(Tuple{typeof(Core.kwfunc(methods_by_execution!)),

src/relocatable_exprs.jl

@@ -98,8 +98,8 @@ function Base.isequal(itera::LineSkippingIterator, iterb::LineSkippingIterator)
  while true
  reta === nothing && retb === nothing && return true
  (reta === nothing || retb === nothing) && return false
- vala, ia = reta
- valb, ib = retb
+ vala, ia = reta::Tuple{Any,Int}
+ valb, ib = retb::Tuple{Any,Int}
  if isa(vala, Expr) && isa(valb, Expr)
  vala, valb = vala::Expr, valb::Expr
  vala.head == valb.head || return false