Various bug fixes/inference improvements

Found with JET.jl.

Author: JamesWrigley

deps/kspec.jl

@@ -3,7 +3,7 @@ import JSON
 #######################################################################
 # Install Jupyter kernel-spec files.
 
-copy_config(src, dest) = cp(src, joinpath(dest, basename(src)), force=true)
+copy_config(src::AbstractString, dest::AbstractString) = cp(src, joinpath(dest, basename(src)), force=true)
 
 # return the user kernelspec directory, according to
 #     https://jupyter-client.readthedocs.io/en/latest/kernels.html#kernelspecs

src/IJulia.jl

@@ -78,7 +78,7 @@ mutable struct Comm{target}
     primary::Bool
     on_msg::Function
     on_close::Function
-    function (::Type{Comm{target}})(id, primary, on_msg, on_close; kernel=_default_kernel) where {target}
+    function (::Type{Comm{target}})(id, primary, on_msg, on_close, kernel) where {target}
         comm = new{target}(id, primary, on_msg, on_close)
         kernel.comms[id] = comm
         return comm
@@ -241,6 +241,10 @@ This consists of log messages printed to the terminal window where
 or received by the kernel.   Used for debugging IJulia.
 """
 function set_verbose(v::Bool=true, kernel=_default_kernel)
+    if isnothing(kernel)
+        error("Kernel has not been initialized, cannot set its verbosity.")
+    end
+
     kernel.verbose = v
 end
 
@@ -252,7 +256,13 @@ whether you are in an IJulia notebook, therefore, you can check
 """
 inited::Bool = false
 
-set_current_module(m::Module; kernel=_default_kernel) = kernel.current_module = m
+function set_current_module(m::Module; kernel=_default_kernel)
+    if isnothing(kernel)
+        error("Kernel has not been initialized, cannot set the current module.")
+    end
+
+    kernel.current_module = m
+end
 
 _shutting_down::Threads.Atomic{Bool} = Threads.Atomic{Bool}(false)
 
@@ -384,6 +394,15 @@ history
 # executing an input cell, e.g. to "close" the current plot in Pylab.
 # Modules should only use these if isdefined(Main, IJulia) is true.
 
+function _pop_hook!(f, hooks)
+    hook_idx = findlast(isequal(f), hooks)
+    if isnothing(hook_idx)
+        error("Could not find hook: $(f)")
+    else
+        splice!(hooks, hook_idx)
+    end
+end
+
 """
     push_postexecute_hook(f::Function)
 
@@ -397,8 +416,7 @@ push_postexecute_hook(f::Function; kernel=_default_kernel) = push!(kernel.postex
 Remove a function `f()` from the list of functions to
 execute after executing any notebook cell.
 """
-pop_postexecute_hook(f::Function; kernel=_default_kernel) =
-    splice!(kernel.postexecute_hooks, findlast(isequal(f), kernel.postexecute_hooks))
+pop_postexecute_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.postexecute_hooks)
 
 """
     push_preexecute_hook(f::Function)
@@ -413,8 +431,7 @@ push_preexecute_hook(f::Function; kernel=_default_kernel) = push!(kernel.preexec
 Remove a function `f()` from the list of functions to
 execute before executing any notebook cell.
 """
-pop_preexecute_hook(f::Function; kernel=_default_kernel) =
-    splice!(kernel.preexecute_hooks, findlast(isequal(f), kernel.preexecute_hooks))
+pop_preexecute_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.preexecute_hooks)
 
 # similar, but called after an error (e.g. to reset plotting state)
 """
@@ -430,8 +447,7 @@ push_posterror_hook(f::Function; kernel=_default_kernel) = push!(kernel.posterro
 Remove a function `f()` from the list of functions to
 execute after an error occurs when a notebook cell is evaluated.
 """
-pop_posterror_hook(f::Function; kernel=_default_kernel) =
-    splice!(kernel.posterror_hooks, findlast(isequal(f), kernel.posterror_hooks))
+pop_posterror_hook(f::Function; kernel=_default_kernel) = _pop_hook!(f, kernel.posterror_hooks)
 
 #######################################################################
 

src/comm_manager.jl

@@ -16,7 +16,7 @@ function Comm(target,
               kernel=IJulia._default_kernel,
               data=Dict(),
               metadata=Dict())
-    comm = Comm{Symbol(target)}(id, primary, on_msg, on_close; kernel)
+    comm = Comm{Symbol(target)}(id, primary, on_msg, on_close, kernel)
     if primary
         # Request a secondary object be created at the front end
         send_ipython(kernel.publish[], kernel,

src/display.jl

@@ -47,7 +47,7 @@ const ijulia_jsonmime_types = Vector{Union{MIME, Vector{MIME}}}([
 Register a new MIME type.
 """
 register_mime(x::Union{MIME, Vector{MIME}}) = push!(ijulia_mime_types, x)
-register_mime(x::AbstractVector{<:MIME}) = push!(ijulia_mime_types, Vector{Mime}(x))
+register_mime(x::AbstractVector{<:MIME}) = push!(ijulia_mime_types, Vector{MIME}(x))
 
 """
     register_jsonmime(x::Union{MIME, Vector{MIME}})
@@ -56,7 +56,7 @@ register_mime(x::AbstractVector{<:MIME}) = push!(ijulia_mime_types, Vector{Mime}
 Register a new JSON MIME type.
 """
 register_jsonmime(x::Union{MIME, Vector{MIME}}) = push!(ijulia_jsonmime_types, x)
-register_jsonmime(x::AbstractVector{<:MIME}) = push!(ijulia_jsonmime_types, Vector{Mime}(x))
+register_jsonmime(x::AbstractVector{<:MIME}) = push!(ijulia_jsonmime_types, Vector{MIME}(x))
 
 # return a String=>Any dictionary to attach as metadata
 # in Jupyter display_data and pyout messages
@@ -178,8 +178,11 @@ function error_content(e, bt=catch_backtrace();
     if !isempty(msg)
         pushfirst!(tb, msg)
     end
-    Dict("ename" => ename, "evalue" => evalue,
-                 "traceback" => tb)
+
+    # Specify the value type as Any because types other than String may be in
+    # the returned JSON.
+    Dict{String, Any}("ename" => ename, "evalue" => evalue,
+                      "traceback" => tb)
 end
 
 #######################################################################

src/handlers.jl

@@ -87,7 +87,7 @@ function complete_type(T::DataType)
 end
 
 #Get typeMap for Jupyter completions
-function complete_types(comps)
+function complete_types(comps, kernel=_default_kernel)
     typeMap = []
     for c in comps
         ctype = ""
@@ -102,7 +102,7 @@ function complete_types(comps)
             expr = Meta.parse(c, raise=false)
             if typeof(expr) == Symbol
                 try
-                    ctype = complete_type(Core.eval(current_module[], :(typeof($expr))))
+                    ctype = complete_type(Core.eval(kernel.current_module, :(typeof($expr))))
                 catch
                 end
             elseif !isa(expr, Expr)
@@ -156,7 +156,7 @@ function complete_request(socket, kernel, msg)
         cursor_start = ind2chr(msg, code, prevind(code, first(positions)))
         cursor_end = ind2chr(msg, code, last(positions))
         if should_complete
-            metadata["_jupyter_types_experimental"] = complete_types(comps)
+            metadata["_jupyter_types_experimental"] = complete_types(comps, kernel)
         else
             # should_complete is false for cases where we only want to show
             # a list of possible completions but not complete, e.g. foo(\t
@@ -212,10 +212,10 @@ request](https://jupyter-client.readthedocs.io/en/latest/messaging.html#connect)
 function connect_request(socket, kernel, msg)
     send_ipython(kernel.requests[], kernel,
                  msg_reply(msg, "connect_reply",
-                           Dict("shell_port" => profile["shell_port"],
-                                "iopub_port" => profile["iopub_port"],
-                                "stdin_port" => profile["stdin_port"],
-                                "hb_port" => profile["hb_port"])))
+                           Dict("shell_port" => kernel.profile["shell_port"],
+                                "iopub_port" => kernel.profile["iopub_port"],
+                                "stdin_port" => kernel.profile["stdin_port"],
+                                "hb_port" => kernel.profile["hb_port"])))
 end
 
 """

src/inline.jl

@@ -103,7 +103,7 @@ function display(d::InlineDisplay, M::MIME, x)
     end
     flush_all() # so that previous stream output appears in order
     send_ipython(kernel.publish[], kernel,
-                 msg_pub(execute_msg, "display_data",
+                 msg_pub(kernel.execute_msg, "display_data",
                          Dict("metadata" => metadata(x), # optional
                               "transient" => transient(x), # optional
                               "data" => d)))

src/jupyter.jl

@@ -151,10 +151,14 @@ end
 Launches [qtconsole](https://qtconsole.readthedocs.io) for the current
 kernel. IJulia must be initialized already.
 """
-function qtconsole()
+function qtconsole(kernel=_default_kernel)
+    if isnothing(kernel)
+        error("IJulia has not been started, cannot run qtconsole")
+    end
+
     qtconsole = find_jupyter_subcommand("qtconsole")
     if inited
-        run(`$qtconsole --existing $connection_file`; wait=false)
+        run(`$qtconsole --existing $(kernel.connection_file)`; wait=false)
     else
         error("IJulia is not running. qtconsole must be called from an IJulia session.")
     end

src/kernel.jl

@@ -24,5 +24,5 @@ function run_kernel()
         end
     end
 
-    wait(IJulia._default_kernel)
+    wait(IJulia._default_kernel::Kernel)
 end

src/stdio.jl

@@ -80,7 +80,7 @@ function watch_stream(rd::IO, name::AbstractString, kernel)
                 if kernel.stdio_bytes[] >= kernel.max_output_per_request[]
                     read(rd, nb) # read from libuv/os buffer and discard
                     if kernel.stdio_bytes[] - nb < kernel.max_output_per_request[]
-                        send_ipython(kernel.publish[], kernel, msg_pub(execute_msg, "stream",
+                        send_ipython(kernel.publish[], kernel, msg_pub(kernel.execute_msg, "stream",
                                      Dict("name" => "stderr", "text" => "Excessive output truncated after $(kernel.stdio_bytes[]) bytes.")))
                     end
                 else