Presence of a docstring somehow messes up type parameter of function argument resolution

[quinnj]

julia> module DataStreams

       code(::Nothing) = missing

       struct Query{code, T, E, L, O}
           columns::T
       end

       "Compute the Data.Schema of the resultset of executing Data.Query `q` against its source"
       function schema(source::S, q::Query{code, columns, e, limit, offset}, wk=true) where {code, S, columns, e, limit, offset}
           @show q
           @show typeof(code)
           return
       end

       function schema2(source::S, q::Query{code, columns, e, limit, offset}, wk=true) where {code, S, columns, e, limit, offset}
           @show q
           @show typeof(code)
           return
       end

       end # module DataStreams
WARNING: replacing module DataStreams.
Main.DataStreams

julia> q = Main.DataStreams.Query{0x01,Nothing,(),nothing,nothing}(nothing)
Main.DataStreams.Query{0x01,Nothing,(),nothing,nothing}(nothing)

julia> Main.DataStreams.schema(1, q)
q = Main.DataStreams.Query{0x01,Nothing,(),nothing,nothing}(nothing)
typeof(code) = typeof(Main.DataStreams.code)

julia> Main.DataStreams.schema2(1, q)
q = Main.DataStreams.Query{0x01,Nothing,(),nothing,nothing}(nothing)
typeof(code) = UInt8

[JeffBezanson]

Off topic, but can anybody explain this:

julia> module Foo 
       code(x) = 10x
       @show macroexpand(quote
       """ some docs """
       function f(::Array{code}) where code
       code(2)
       end end)
       end
... = quote
    #= REPL[26]:4 =#
    begin
        function f(::Array{code}) where code
            #= REPL[26]:6 =#
            code(2)
        end
        (Base.Docs.doc!)(Main.Foo, (Base.Docs.Binding)(Main.Foo, :f), (Base.Docs.docstr)((Core.svec)(" some docs "), (Dict)(:path => "REPL[26]", :linenumber => 4, :module => Main.Foo)), Union{Tuple{Array{code}}, Tuple{code}} where code <: Any)
    end
end

What is the significance of the type Union{Tuple{Array{code}}, Tuple{code}} where code <: Any? Why is that passed to doc!? I think it's supposed to be the method signature, but I don't understand where that Union type comes from.

[KristofferC]

I think it comes from

julia/base/docs/Docs.jl

Lines 85 to 116 in f104ea4

	function signature!(tv, expr::Expr)
	is_macrocall = isexpr(expr, :macrocall)
	if is_macrocall || isexpr(expr, :call)
	sig = :(Union{Tuple{}})
	first_arg = is_macrocall ? 3 : 2 # skip function arguments
	for arg in expr.args[first_arg:end]
	isexpr(arg, :parameters) && continue
	if isexpr(arg, :kw) # optional arg
	push!(sig.args, :(Tuple{$(sig.args[end].args[2:end]...)}))
	end
	push!(sig.args[end].args, argtype(arg))
	end
	if isexpr(expr.args[1], :curly) && isempty(tv)
	append!(tv, tvar.(expr.args[1].args[2:end]))
	end
	for i = length(tv):-1:1
	push!(sig.args, :(Tuple{$(tv[i].args[1])}))
	end
	for i = length(tv):-1:1
	sig = Expr(:where, sig, tv[i])
	end
	return sig
	elseif isexpr(expr, :where)
	append!(tv, tvar.(expr.args[2:end]))
	return signature!(tv, expr.args[1])
	else
	return signature!(tv, expr.args[1])
	end
	end
	signature!(tv, @nospecialize(other)) = :(Union{})
	signature(expr::Expr) = signature!([], expr)
	signature(@nospecialize other) = signature!([], other)

[JeffBezanson]

Yes it does, but I can't figure out why that code does that.