Fix SIGNATURES for methods with UnionAll arguments (#38)

* Fix #32.

* Add tests.

* Fix templates for `where` expression header, add test.

* Cleanup.

Author: tkoolen

src/templates.jl

@@ -127,7 +127,7 @@ function expression_type(ex::Expr)
         :TYPES
     elseif Meta.isexpr(ex, :macro)
         :MACROS
-    elseif Meta.isexpr(ex, [:function, :(=)]) && Meta.isexpr(ex.args[1], :call)
+    elseif Meta.isexpr(ex, [:function, :(=)]) && Meta.isexpr(ex.args[1], :call) || (Meta.isexpr(ex.args[1], :where) && Meta.isexpr(ex.args[1].args[1], :call))
         :METHODS
     elseif Meta.isexpr(ex, :function)
         :FUNCTIONS

src/utilities.jl

@@ -21,7 +21,7 @@ groups = methodgroups(f, Union{Tuple{Any}, Tuple{Any, Integer}}, Main; exact = f
 """
 function methodgroups(func, typesig, modname; exact = true)
     # Group methods by file and line number.
-    local methods = Set{Method}(getmethods(func, typesig))
+    local methods = getmethods(func, typesig)
     local groups = groupby(Tuple{Symbol, Int}, Vector{Method}, methods) do m
         (m.file, m.line), m
     end
@@ -32,7 +32,7 @@ function methodgroups(func, typesig, modname; exact = true)
     for (key, group) in groups
         filter!(group) do m
             local ismod = m.module == modname
-            exact ? (ismod && Base.tuple_type_tail(m.sig) in typesigs) : ismod
+            exact ? (ismod && Base.rewrap_unionall(Base.tuple_type_tail(m.sig), m.sig) in typesigs) : ismod
         end
         isempty(group) || push!(results, group)
     end
@@ -80,8 +80,10 @@ function getmethods!(results, f, sig)
         append!(results, methods(f))
     elseif isa(sig, Union)
         for each in uniontypes(sig)
-            append!(results, getmethods(f, each))
+            getmethods!(results, f, each)
         end
+    elseif isa(sig, UnionAll)
+        getmethods!(results, f, Base.unwrap_unionall(sig))
     else
         append!(results, methods(f, sig))
     end
@@ -95,7 +97,7 @@ Collect and return all methods of function `f` matching signature `sig`.
 This is similar to `methods(f, sig)`, but handles type signatures found in `DocStr` objects
 more consistently that `methods`.
 """
-getmethods(f, sig) = getmethods!(Method[], f, sig)
+getmethods(f, sig) = unique(getmethods!(Method[], f, sig))
 
 
 """
@@ -118,7 +120,17 @@ $(:SIGNATURES)
 
 Returns a `Vector` of the `Tuple` types contained in `sig`.
 """
-alltypesigs(sig) = sig == Union{} ? Any[] : isa(sig, Union) ? uniontypes(sig) : Any[sig]
+function alltypesigs(sig)::Vector{Any}
+    if sig == Union{}
+        Any[]
+    elseif isa(sig, Union)
+        uniontypes(sig)
+    elseif isa(sig, UnionAll)
+        Base.rewrap_unionall.(uniontypes(Base.unwrap_unionall(sig)), sig)
+    else
+        Any[sig]
+    end
+end
 
 """
 $(:SIGNATURES)

test/templates.jl

@@ -38,6 +38,9 @@ mutable struct T end
 "method `f`"
 f(x) = x
 
+"method `g`"
+g(::Type{T}) where {T} = T # Issue 32
+
 "macro `@m`"
 macro m(x) end
 

test/tests.jl

@@ -17,6 +17,7 @@ const A{T} = Union{Vector{T}, Matrix{T}}
 
 h_1(x::A) = x
 h_2(x::A{Int}) = x
+h_3(x::A{T}) where {T} = x
 
 mutable struct T
     a
@@ -186,6 +187,7 @@ end
             @test contains(fmt(:(TemplateTests.K)), "(DEFAULT)")
             @test contains(fmt(:(TemplateTests.T)), "(TYPES)")
             @test contains(fmt(:(TemplateTests.f)), "(METHODS, MACROS)")
+            @test contains(fmt(:(TemplateTests.g)), "(METHODS, MACROS)")
             @test contains(fmt(:(TemplateTests.@m)), "(METHODS, MACROS)")
 
             @test contains(fmt(:(TemplateTests.InnerModule.K)), "(DEFAULT)")
@@ -297,6 +299,9 @@ end
             @test length(DSE.getmethods(M.f, Union{})) == 1
             @test length(DSE.getmethods(M.f, Tuple{})) == 0
             @test length(DSE.getmethods(M.f, Union{Tuple{}, Tuple{Any}})) == 1
+            @test length(DSE.getmethods(M.h_3, Tuple{M.A{Int}})) == 1
+            @test length(DSE.getmethods(M.h_3, Tuple{Vector{Int}})) == 1
+            @test length(DSE.getmethods(M.h_3, Tuple{Array{Int, 3}})) == 0
         end
         @testset "methodgroups" begin
             @test length(DSE.methodgroups(M.f, Tuple{Any}, M)) == 1
@@ -305,11 +310,13 @@ end
             @test length(DSE.methodgroups(M.h_1, Tuple{M.A}, M)[1]) == 1
             @test length(DSE.methodgroups(M.h_2, Tuple{M.A{Int}}, M)) == 1
             @test length(DSE.methodgroups(M.h_2, Tuple{M.A{Int}}, M)[1]) == 1
+            @test length(DSE.methodgroups(M.h_3, Tuple{M.A}, M)[1]) == 1
         end
         @testset "alltypesigs" begin
             @test DSE.alltypesigs(Union{}) == Any[]
             @test DSE.alltypesigs(Union{Tuple{}}) == Any[Tuple{}]
             @test DSE.alltypesigs(Tuple{}) == Any[Tuple{}]
+            @test DSE.alltypesigs(Type{T} where {T}) == Any[Type{T} where T]
         end
         @testset "groupby" begin
             let groups = DSE.groupby(Int, Vector{Int}, collect(1:10)) do each