Add test for TYPEDSIGNATURENORETURN abbreviation

The abbreviation should behave in the same way as TYPEDSIGNATURE
but omit the return type.

Author: ReubenJ

test/tests.jl

@@ -9,12 +9,12 @@ function with_test_repo(f)
     repo = LibGit2.init(joinpath(@__DIR__, "TestModule"))
     LibGit2.add!(repo, "M.jl")
     sig = LibGit2.Signature("zeptodoctor", "[email protected]", round(time()), 0)
-    LibGit2.commit(repo, "M.jl", committer = sig, author = sig)
+    LibGit2.commit(repo, "M.jl", committer=sig, author=sig)
     LibGit2.GitRemote(repo, "origin", "https://github.com/JuliaDocs/NonExistent.jl.git")
     try
         f()
     finally
-        rm(joinpath(@__DIR__, "TestModule", ".git"); force = true, recursive = true)
+        rm(joinpath(@__DIR__, "TestModule", ".git"); force=true, recursive=true)
     end
 end
 
@@ -59,7 +59,7 @@ end
         @test kwargs == [:y]
         # Base.kwarg_decl will return a Tuple{} for some reason when called on a method
         # that does not have any arguments
-        m = which(M.j_1, (Any,Any)) # fetch the no-keyword method
+        m = which(M.j_1, (Any, Any)) # fetch the no-keyword method
         if VERSION < v"1.4.0-DEV.215"
             @test Base.kwarg_decl(m, typeof(get_mt(M.j_1).kwsorter)) == Tuple{}()
         else
@@ -147,7 +147,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :g),
-                :typesig => Union{Tuple{}, Tuple{Any}},
+                :typesig => Union{Tuple{},Tuple{Any}},
                 :module => M,
             )
             DSE.format(SIGNATURES, buf, doc)
@@ -166,7 +166,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :g),
-                :typesig => Union{Tuple{}, Tuple{Any}, Tuple{Any, Any}, Tuple{Any, Any, Any}},
+                :typesig => Union{Tuple{},Tuple{Any},Tuple{Any,Any},Tuple{Any,Any,Any}},
                 :module => M,
             )
             DSE.format(SIGNATURES, buf, doc)
@@ -199,7 +199,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :h_4),
-                :typesig => Union{Tuple{Any, Int, Any}},
+                :typesig => Union{Tuple{Any,Int,Any}},
                 :module => M,
             )
             DSE.format(SIGNATURES, buf, doc)
@@ -240,7 +240,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :h),
-                :typesig => Tuple{Int, Int, Int},
+                :typesig => Tuple{Int,Int,Int},
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -293,7 +293,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_1),
-                :typesig => Union{Tuple{String}, Tuple{String, T}, Tuple{String, T, T}, Tuple{T}} where T <: Number,
+                :typesig => Union{Tuple{String},Tuple{String,T},Tuple{String,T,T},Tuple{T}} where T<:Number,
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -306,7 +306,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_2),
-                :typesig => (Union{Tuple{String, U, T}, Tuple{T}, Tuple{U}} where T <: Number) where U <: Complex,
+                :typesig => (Union{Tuple{String,U,T},Tuple{T},Tuple{U}} where T<:Number) where U<:Complex,
                 :module => M,
             )
 
@@ -318,7 +318,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_3),
-                :typesig => (Union{Tuple{Any, T, U}, Tuple{U}, Tuple{T}} where U <: Any) where T <: Any,
+                :typesig => (Union{Tuple{Any,T,U},Tuple{U},Tuple{T}} where U<:Any) where T<:Any,
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -329,7 +329,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_4),
-                :typesig => Union{Tuple{String}, Tuple{String, Int}},
+                :typesig => Union{Tuple{String},Tuple{String,Int}},
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -352,7 +352,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_5),
-                :typesig => Union{Tuple{Type{T}, String}, Tuple{Type{T}, String, Union{Nothing, Function}}, Tuple{T}} where T <: Number,
+                :typesig => Union{Tuple{Type{T},String},Tuple{Type{T},String,Union{Nothing,Function}},Tuple{T}} where T<:Number,
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -371,7 +371,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_6),
-                :typesig => Union{Tuple{Vector{T}}, Tuple{T}} where T <: Number,
+                :typesig => Union{Tuple{Vector{T}},Tuple{T}} where T<:Number,
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -389,7 +389,7 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_7),
-                :typesig => Union{Tuple{Union{Nothing, T}}, Tuple{T}, Tuple{Union{Nothing, T}, T}} where T<:Integer,
+                :typesig => Union{Tuple{Union{Nothing,T}},Tuple{T},Tuple{Union{Nothing,T},T}} where T<:Integer,
                 :module => M,
             )
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -430,7 +430,7 @@ end
 
                 doc.data = Dict(
                     :binding => Docs.Binding(M, :k_11),
-                    :typesig => Union{Tuple{Int, Vararg{Any}}},
+                    :typesig => Union{Tuple{Int,Vararg{Any}}},
                     :module => M,
                 )
                 DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -441,7 +441,7 @@ end
 
                 doc.data = Dict(
                     :binding => Docs.Binding(M, :k_12),
-                    :typesig => Union{Tuple{Int, Vararg{Real}}},
+                    :typesig => Union{Tuple{Int,Vararg{Real}}},
                     :module => M,
                 )
                 DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
@@ -455,6 +455,26 @@ end
 
         end
 
+        @testset "method signatures with types (no return type)" begin
+            doc.data = Dict(
+                :binding => Docs.Binding(M, :h_1),
+                :typesig => Tuple{M.A},
+                :module => M,
+            )
+            DSE.format(DSE.TYPEDSIGNATURESNORETURN, buf, doc)
+            str = String(take!(buf))
+            @test occursin("\n```julia\n", str)
+            f = str -> replace(str, " " => "")
+            str = f(str)
+            if Sys.iswindows() && VERSION < v"1.8"
+                @test occursin(f("h_1(x::Union{Array{T,4}, Array{T,3}} where T)"), str)
+            else
+                @test occursin(f("h_1(x::Union{Array{T,3}, Array{T,4}} where T)"), str)
+            end
+            @test !occursin("->", str)
+            @test occursin("\n```\n", str)
+        end
+
         @testset "function names" begin
             doc.data = Dict(
                 :binding => Docs.Binding(M, :f),
@@ -559,22 +579,27 @@ end
             @test DSE.keywords(M.f, first(methods(M.f))) == Symbol[]
             let f = (() -> ()),
                 m = first(methods(f))
+
                 @test DSE.keywords(f, m) == Symbol[]
             end
             let f = ((a) -> ()),
                 m = first(methods(f))
+
                 @test DSE.keywords(f, m) == Symbol[]
             end
-            let f = ((; a = 1) -> ()),
+            let f = ((; a=1) -> ()),
                 m = first(methods(f))
+
                 @test DSE.keywords(f, m) == [:a]
             end
-            let f = ((; a = 1, b = 2) -> ()),
+            let f = ((; a=1, b=2) -> ()),
                 m = first(methods(f))
+
                 @test DSE.keywords(f, m) == [:a, :b]
             end
             let f = ((; a...) -> ()),
                 m = first(methods(f))
+
                 @test DSE.keywords(f, m) == [Symbol("a...")]
             end
             # Tests for #42
@@ -601,10 +626,10 @@ end
             let m = first(methods((a) -> ()))
                 @test DSE.arguments(m) == [:a]
             end
-            let m = first(methods((; a = 1) -> ()))
+            let m = first(methods((; a=1) -> ()))
                 @test DSE.arguments(m) == Symbol[]
             end
-            let m = first(methods((x; a = 1, b = 2) -> ()))
+            let m = first(methods((x; a=1, b=2) -> ()))
                 @test DSE.arguments(m) == Symbol[:x]
             end
             let m = first(methods((; a...) -> ()))
@@ -615,46 +640,53 @@ end
             let b = Docs.Binding(M, :T),
                 f = M.T,
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "T(a, b, c)"
             end
             let b = Docs.Binding(M, :K),
                 f = M.K,
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "K(; a)"
             end
             let b = Docs.Binding(M, :f),
                 f = M.f,
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "f(x)"
             end
             let b = Docs.Binding(Main, :f),
                 f = () -> (),
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "f()"
             end
             let b = Docs.Binding(Main, :f),
                 f = (a) -> (),
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "f(a)"
             end
             let b = Docs.Binding(Main, :f),
-                f = (; a = 1) -> (),
+                f = (; a=1) -> (),
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "f(; a)"
             end
             let b = Docs.Binding(Main, :f),
-                f = (; a = 1, b = 2) -> (),
+                f = (; a=1, b=2) -> (),
                 m = first(methods(f))
                 # Keywords are not ordered, so check for both combinations.
                 @test DSE.printmethod(b, f, m) in ("f(; a, b)", "f(; b, a)")
             end
             let b = Docs.Binding(Main, :f),
                 f = (; a...) -> (),
                 m = first(methods(f))
+
                 @test DSE.printmethod(b, f, m) == "f(; a...)"
             end
             let b = Docs.Binding(Main, :f),
-                f = (; a = 1, b = 2, c...) -> (),
+                f = (; a=1, b=2, c...) -> (),
                 m = first(methods(f))
                 # Keywords are not ordered, so check for both combinations.
                 @test DSE.printmethod(b, f, m) in ("f(; a, b, c...)", "f(; b, a, c...)")
@@ -663,10 +695,10 @@ end
         @testset "getmethods" begin
             @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.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{Array{Int, 3}})) == 1
-            @test length(DSE.getmethods(M.h_3, Tuple{Array{Int, 1}})) == 0
+            @test length(DSE.getmethods(M.h_3, Tuple{Array{Int,3}})) == 1
+            @test length(DSE.getmethods(M.h_3, Tuple{Array{Int,1}})) == 0
         end
         @testset "methodgroups" begin
             @test length(DSE.methodgroups(M.f, Tuple{Any}, M)) == 1
@@ -687,10 +719,10 @@ end
             let groups = DSE.groupby(Int, Vector{Int}, collect(1:10)) do each
                     mod(each, 3), each
                 end
-                @test groups == Pair{Int, Vector{Int}}[
-                    0 => [3, 6, 9],
-                    1 => [1, 4, 7, 10],
-                    2 => [2, 5, 8],
+                @test groups == Pair{Int,Vector{Int}}[
+                    0=>[3, 6, 9],
+                    1=>[1, 4, 7, 10],
+                    2=>[2, 5, 8],
                 ]
             end
         end
@@ -711,6 +743,7 @@ end
         @testset "comparemethods" begin
             let f = first(methods(M.f)),
                 g = first(methods(M.g))
+
                 @test !DSE.comparemethods(f, f)
                 @test DSE.comparemethods(f, g)
                 @test !DSE.comparemethods(g, f)