Reduce latency (#101)

The following benchmark:
```julia
julia> using Example

julia> id = Base.module_keys[Example]
Example [7876af07-990d-54b4-ab0e-23690620f79a]

julia> @time begin
       @eval module SomeMod
             using Requires
             __init__() = @require Example="7876af07-990d-54b4-ab0e-23690620f79a" f(x) = x^2
             end
       end
  0.335103 seconds (512.40 k allocations: 30.980 MiB, 8.35% gc time)
Main.SomeMod
```

has substantial latency. This PR cuts it to about 60ms, more than a five-fold improvment.

It also makes the precompiles less fragile.

Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>

Author: timholy

src/Requires.jl

@@ -1,8 +1,12 @@
 module Requires
 
+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@compiler_options"))
+    @eval Base.Experimental.@compiler_options compile=min optimize=0 infer=false
+end
+
 using UUIDs
 
-function _include_path(relpath)
+function _include_path(relpath::String)
     # Reproduces include()'s runtime relative path logic
     # See Base._include_dependency()
     prev = Base.source_path(nothing)
@@ -23,7 +27,7 @@ string literal, not an expression.
 
 `@require` blocks insert this automatically when you use `include`.
 """
-macro include(relpath)
+macro include(relpath::String)
     compiletime_path = joinpath(dirname(String(__source__.file)), relpath)
     s = String(read(compiletime_path))
     quote
@@ -48,14 +52,20 @@ function __init__()
 end
 
 if isprecompiling()
-    @assert precompile(loadpkg, (Base.PkgId,))
-    @assert precompile(withpath, (Any, String))
-    @assert precompile(err, (Any, Module, String))
-    @assert precompile(parsepkg, (Expr,))
-    @assert precompile(listenpkg, (Any, Base.PkgId))
-    @assert precompile(callbacks, (Base.PkgId,))
-    @assert precompile(withnotifications, (Vararg{Any},))
-    @assert precompile(withnotifications, (Any, Vararg{Any},))
+    precompile(loadpkg, (Base.PkgId,)) || @warn "Requires failed to precompile `loadpkg`"
+    precompile(withpath, (Any, String)) || @warn "Requires failed to precompile `withpath`"
+    precompile(err, (Any, Module, String)) || @warn "Requires failed to precompile `err`"
+    precompile(parsepkg, (Expr,)) || @warn "Requires failed to precompile `parsepkg`"
+    precompile(listenpkg, (Any, Base.PkgId)) || @warn "Requires failed to precompile `listenpkg`"
+    precompile(callbacks, (Base.PkgId,)) || @warn "Requires failed to precompile `callbacks`"
+    precompile(withnotifications, (String, Module, String, String, Expr)) || @warn "Requires failed to precompile `withnotifications`"
+    precompile(replace_include, (Expr, LineNumberNode)) || @warn "Requires failed to precompile `replace_include`"
+    precompile(getfield(Requires, Symbol("@require")), (LineNumberNode, Module, Expr, Any)) || @warn "Requires failed to precompile `@require`"
+
+    precompile(_include_path, (String,)) || @warn "Requires failed to precompile `_include_path`"
+    precompile(getfield(Requires, Symbol("@include")), (LineNumberNode, Module, String)) || @warn "Requires failed to precompile `@include`"
+
+    precompile(__init__, ()) || @warn "Requires failed to precompile `__init__`"
 end
 
 end # module

src/require.jl

@@ -1,29 +1,34 @@
 using Base: PkgId, loaded_modules, package_callbacks
 using Base.Meta: isexpr
+if isdefined(Base, :mapany)
+  const mapany = Base.mapany
+else
+  mapany(f, A::AbstractVector) = map!(f, Vector{Any}(undef, length(A)), A)
+end
 
 export @require
 
 isprecompiling() = ccall(:jl_generating_output, Cint, ()) == 1
 
-loaded(pkg) = haskey(Base.loaded_modules, pkg)
+loaded(pkg::PkgId) = haskey(Base.loaded_modules, pkg)
 
 const notified_pkgs = [Base.PkgId(UUID(0x295af30fe4ad537b898300126c2a3abe), "Revise")]
 
 const _callbacks = Dict{PkgId, Vector{Function}}()
-callbacks(pkg) = get!(Vector{Function}, _callbacks, pkg)
+callbacks(pkg::PkgId) = get!(Vector{Function}, _callbacks, pkg)
 
-listenpkg(@nospecialize(f), pkg) =
+listenpkg(@nospecialize(f), pkg::PkgId) =
   loaded(pkg) ? f() : push!(callbacks(pkg), f)
 
-function loadpkg(pkg::Base.PkgId)
+function loadpkg(pkg::PkgId)
   if haskey(_callbacks, pkg)
     fs = _callbacks[pkg]
     delete!(_callbacks, pkg)
     foreach(Base.invokelatest, fs)
   end
 end
 
-function withpath(@nospecialize(f), path)
+function withpath(@nospecialize(f), path::String)
   tls = task_local_storage()
   hassource = haskey(tls, :SOURCE_PATH)
   hassource && (path′ = tls[:SOURCE_PATH])
@@ -37,19 +42,19 @@ function withpath(@nospecialize(f), path)
   end
 end
 
-function err(@nospecialize(f), listener, mod)
+function err(@nospecialize(f), listener::Module, modname::String)
   try
     f()
   catch exc
-    @warn "Error requiring `$mod` from `$listener`" exception=(exc,catch_backtrace())
+    @warn "Error requiring `$modname` from `$listener`" exception=(exc,catch_backtrace())
   end
 end
 
-function parsepkg(ex)
+function parsepkg(ex::Expr)
   isexpr(ex, :(=)) || @goto fail
   mod, id = ex.args
   (mod isa Symbol && id isa String) || @goto fail
-  return id, String(mod)
+  return id::String, String(mod::Symbol)
   @label fail
   error("Requires syntax is: `@require Pkg=\"uuid\"`")
 end
@@ -67,29 +72,29 @@ function withnotifications(@nospecialize(args...))
   return nothing
 end
 
-function replace_include(ex, source)
-  if isexpr(ex, :call) && ex.args[1] == :include && ex.args[2] isa String
-    return Expr(:macrocall, :($Requires.$(Symbol("@include"))), source, ex.args[2])
-  elseif ex isa Expr
-    Expr(ex.head, replace_include.(ex.args, (source,))...)
-  else
-    return ex
+function replace_include(ex::Expr, source::LineNumberNode)
+  if ex.head == :call && ex.args[1] === :include && ex.args[2] isa String
+    return Expr(:macrocall, :($Requires.$(Symbol("@include"))), source, ex.args[2]::String)
   end
+  return Expr(ex.head, (mapany(ex.args) do arg
+    isa(arg, Expr) ? replace_include(arg, source) : arg
+  end)...)
 end
 
-macro require(pkg, expr)
+macro require(pkg::Union{Symbol,Expr}, expr)
   pkg isa Symbol &&
     return Expr(:macrocall, Symbol("@warn"), __source__,
                 "Requires now needs a UUID; please see the readme for changes in 0.7.")
-  id, modname = parsepkg(pkg)
-  pkg = :(Base.PkgId(Base.UUID($id), $modname))
-  expr = replace_include(expr, __source__)
+  idstr, modname = parsepkg(pkg)
+  pkg = :(Base.PkgId(Base.UUID($idstr), $modname))
+  expr = isa(expr, Expr) ? replace_include(expr, __source__) : expr
   expr = macroexpand(__module__, expr)
+  srcfile = string(__source__.file)
   quote
     if !isprecompiling()
       listenpkg($pkg) do
-        $withnotifications($(string(__source__.file)), $__module__, $id, $modname, $(esc(Expr(:quote, expr))))
-        withpath($(string(__source__.file))) do
+        $withnotifications($srcfile, $__module__, $idstr, $modname, $(esc(Expr(:quote, expr))))
+        withpath($srcfile) do
           err($__module__, $modname) do
             $(esc(:(eval($(Expr(:quote, Expr(:block,
                                             :(const $(Symbol(modname)) = Base.require($pkg)),