Merge pull request #125 from kdheepak/kd/fix-test-failure

Fix test failures for Julia 1.8

Author: MichaelHatherly

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,49 @@ 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
+            t
+        elseif t isa UnionAll
+            f(t.body)
+        else
+            error("Expected `typeof($t)` to be `Tuple` or `UnionAll` but found `$typeof(t)`")
+        end
+    end
+
+    function get_typesig(t::Union, org::Union)
+        if t.a isa TypeVar
+            UnionAll(t.a, get_typesig(t.b, org))
+        elseif t.b isa TypeVar
+            UnionAll(t.b, t)
+        else
+            t
+        end
+    end
+
+    function get_typesig(typ::TypeVar, org)
+        UnionAll(typ, org)
+    end
+
+    function get_typesig(typ, org)
+        typ
+    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]
+            t = [get_typesig(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
@@ -308,7 +346,7 @@ function printmethod(buffer::IOBuffer, binding::Docs.Binding, func, method::Meth
     if length(rt) >= 1 && rt[1] !== Nothing && rt[1] !== Union{}
         print(buffer, " -> $(rt[1])")
     end
-    return buffer
+    buffer
 end
 
 printmethod(b, f, m) = String(take!(printmethod(IOBuffer(), b, f, m)))

test/TestModule/M.jl

@@ -23,6 +23,7 @@ i_4(x; y::T = zero(T), z::U = zero(U)) where {T, U} = x + y + z
 j_1(x, y) = x * y # two arguments, no keyword arguments
 j_1(x; y = x) = x * y # one argument, one keyword argument
 
+k_0(x::T) where T = x
 k_1(x::String, y::T = 0, z::T = zero(T)) where T <: Number = x
 k_2(x::String, y::U, z::T) where T <: Number where U <: Complex = x
 k_3(x, y::T, z::U) where {T, U} = x + y + z
@@ -32,7 +33,6 @@ k_6(x::Vector{T}) where T <: Number = x
 k_7(x::Union{T,Nothing}, y::T = zero(T)) where {T <: Integer} = x
 k_8(x) = x
 k_9(x::T where T<:Any) = x
-k_10(x::T) where T = x
 k_11(x::Int, xs...) = x
 k_12(x::Int, xs::Real...) = x
 

test/tests.jl

@@ -196,6 +196,7 @@ end
             end
             @test occursin("\n```\n", str)
 
+
             doc.data = Dict(
                 :binding => Docs.Binding(M, :h),
                 :typesig => Tuple{Int, Int, Int},
@@ -226,6 +227,17 @@ end
             end
             @test occursin("\n```\n", str)
 
+            doc.data = Dict(
+                :binding => Docs.Binding(M, :k_0),
+                :typesig => Tuple{T} where T,
+                :module => M,
+            )
+            DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
+            str = String(take!(buf))
+            @test occursin("\n```julia\n", str)
+            @test occursin("\nk_0(x) -> Any\n", str)
+            @test occursin("\n```\n", str)
+
             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,
@@ -235,8 +247,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 +260,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 +271,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(
@@ -285,7 +297,6 @@ end
             end
             @test occursin("\n```\n", str)
 
-
             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,
@@ -315,19 +326,28 @@ 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(
                 :binding => Docs.Binding(M, :k_7),
-                :typesig => Union{Tuple{Union{T, Nothing}}, Tuple{Union{T, Nothing}, T}, Tuple{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)
             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)
+            if VERSION > v"1.7" || VERSION < v"1.1"
+                @test occursin("\nk_7(x::Union{Nothing, T} where T<:Integer) -> Union{Nothing, T} where T<:Integer\n", str)
+            else
+                @test occursin("\nk_7(x::Union{Nothing, T} where T<:Integer) -> Union{Nothing, Integer}\n", str)
+            end
+            @test occursin("\nk_7(x::Union{Nothing, T} where T<:Integer, y::Integer) -> Union{Nothing, T} where T<:Integer\n", str)
             @test occursin("\n```\n", str)
 
             doc.data = Dict(
@@ -378,16 +398,7 @@ end
 
             end
 
-            doc.data = Dict(
-                :binding => Docs.Binding(M, :k_10),
-                :typesig => Union{Tuple{T}, Tuple{T}} where T,
-                :module => M,
-            )
-            DSE.format(DSE.TYPEDSIGNATURES, buf, doc)
-            str = String(take!(buf))
-            @test_broken occursin("\n```julia\n", str)
-            @test_broken occursin("\nk_10(x::T) -> Any\n", str)
-            @test_broken occursin("\n```\n", str)
+
         end
 
         @testset "function names" begin