Fix test failures for Julia 1.8

Author: kdheepak

src/abbreviations.jl

@@ -384,10 +384,20 @@ function format(::TypedMethodSignatures, buf, doc)
             # The following will find the tuple that matches the number of arguments in the function
             # ideally we would check that the method signature matches the Tuple{...} signature
             # but that is not straightforward because of how expressive Julia can be
+            function f(t)
+                if t isa DataType
+                    return t <: Tuple && length(t.types) == N
+                elseif t isa UnionAll
+                    return f(t.body)
+                else
+                    return false
+                end
+            end
+
             if Sys.iswindows()
-                t = tuples[findlast(t -> t isa DataType && t <: Tuple && length(t.types) == N, tuples)]
+                t = tuples[findlast(f, tuples)]
             else
-                t = tuples[findfirst(t -> t isa DataType && t <: Tuple && length(t.types) == N, tuples)]
+                t = tuples[findfirst(f, tuples)]
             end
             printmethod(buf, binding, func, method, t)
             println(buf)

src/utilities.jl

@@ -246,7 +246,7 @@ julia> DocStringExtensions.find_tuples(s)
 """
 function find_tuples(typesig)
     if typesig isa UnionAll
-        return find_tuples(typesig.body)
+        return [UnionAll(typesig.var, x) for x in find_tuples(typesig.body)]
     elseif typesig isa Union
         return [typesig.a, find_tuples(typesig.b)...]
     else
@@ -278,11 +278,32 @@ function printmethod(buffer::IOBuffer, binding::Docs.Binding, func, method::Meth
     local args = arguments(method)
     local where_syntax = []
 
+    # find inner tuple type
+    function f(t)
+        # t is always either a UnionAll which represents a generic type or a Tuple where each parameter is the argument
+        if t isa DataType && t <: Tuple
+            return t
+        elseif t isa UnionAll
+            return f(t.body)
+        end
+    end
+
     for (i, sym) in enumerate(args)
-        t = typesig.types[i]
+        if typesig isa UnionAll
+            # e.g. Tuple{Vector{T}} where T<:Number
+            # or   Tuple{String, T, T} where T<:Number
+            # or   Tuple{Type{T}, String, Union{Nothing, Function}} where T<:Number
+            t = [x for x in f(typesig).types]
+            v = [x for x in t if x isa TypeVar]
+            # TODO: this prints `Union{Nothing, T<:Integer}` instead of `Union{Nothing, T} where T<:Number`
+            # To do this correctly, we need to extract the information out of types like this: `Type{TypeVar(:T, Number)}`
+            t = [x isa TypeVar ? UnionAll(popfirst!(v), x) : x for x in t][i]
+        else
+            # e.g. Tuple{Vector{Int}}
+            t = typesig.types[i]
+        end
         if isvarargtype(t)
             elt = vararg_eltype(t)
-
             if elt === Any
                 print(buffer, "$sym...")
             else

test/tests.jl

@@ -235,8 +235,8 @@ end
             str = String(take!(buf))
             @test occursin("\n```julia\n", str)
             @test occursin("\nk_1(x::String) -> String\n", str)
-            @test occursin("\nk_1(x::String, y::T<:Number) -> String\n", str)
-            @test occursin("\nk_1(x::String, y::T<:Number, z::T<:Number) -> String\n", str)
+            @test occursin("\nk_1(x::String, y::Number) -> String\n", str)
+            @test occursin("\nk_1(x::String, y::Number, z::Number) -> String\n", str)
             @test occursin("\n```\n", str)
 
             doc.data = Dict(
@@ -248,7 +248,7 @@ end
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
             str = String(take!(buf))
             @test occursin("\n```julia\n", str)
-            @test occursin("k_2(x::String, y::U<:Complex, z::T<:Number) -> String", str)
+            @test occursin("k_2(x::String, y::Complex, z::Number) -> String", str)
             @test occursin("\n```\n", str)
 
             doc.data = Dict(
@@ -259,7 +259,7 @@ end
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
             str = String(take!(buf))
             @test occursin("\n```julia\n", str)
-            @test occursin("\nk_3(x, y::T, z::U) -> Any\n", str)
+            @test occursin("\nk_3(x, y, z) -> Any\n", str)
             @test occursin("\n```\n", str)
 
             doc.data = Dict(
@@ -315,7 +315,12 @@ end
             str = String(take!(buf))
             str = f(str)
             @test occursin("\n```julia\n", str)
-            @test occursin(f("\nk_6(x::Array{T<:Number,1}) -> Array{T<:Number,1}\n"), str)
+            if VERSION >= v"1.6.0"
+                @test occursin(f("\nk_6(x::Array{T<:Number, 1}) -> Vector{T} where T<:Number\n"), str)
+            else
+                # TODO: remove this test when julia 1.0.0 support is dropped.
+                @test occursin(f("\nk_6(x::Array{T<:Number,1}) -> Array{T,1} where T<:Number\n"), str)
+            end
             @test occursin("\n```\n", str)
 
             doc.data = Dict(
@@ -326,8 +331,13 @@ end
             DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
             str = String(take!(buf))
             @test occursin("\n```julia\n", str)
-            @test occursin("\nk_7(x::Union{Nothing, T<:Integer}) -> Union{Nothing, Integer}\n", str)
-            @test occursin("\nk_7(x::Union{Nothing, T<:Integer}, y::T<:Integer) -> Union{Nothing, T<:Integer}\n", str)
+            # TODO: print `Union{Nothing, T<:Integer}` instead of `Union{Nothing, T} where T<:Number`
+            if VERSION > v"1.7" || VERSION < v"1.1"
+                @test occursin("\nk_7(x::Union{Nothing, T<:Integer}) -> Union{Nothing, T} where T<:Integer\n", str)
+            else
+                @test occursin("\nk_7(x::Union{Nothing, T<:Integer}) -> Union{Nothing, Integer}\n", str)
+            end
+            @test occursin("\nk_7(x::Union{Nothing, T<:Integer}, y::Integer) -> Union{Nothing, T} where T<:Integer\n", str)
             @test occursin("\n```\n", str)
 
             doc.data = Dict(