Make print better for parameteric types

Author: kdheepak

src/utilities.jl

@@ -288,16 +288,31 @@ function printmethod(buffer::IOBuffer, binding::Docs.Binding, func, method::Meth
         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)
+        return typ
+    end
+
     for (i, sym) in enumerate(args)
         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]
+            t = [get_typesig(x, x) for x in t][i]
         else
             # e.g. Tuple{Vector{Int}}
             t = typesig.types[i]

test/tests.jl

@@ -325,19 +325,18 @@ end
 
             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)
-            # 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)
+                @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<:Integer}) -> Union{Nothing, Integer}\n", str)
+                @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<:Integer}, y::Integer) -> Union{Nothing, T} where T<:Integer\n", str)
+            @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(
@@ -390,13 +389,13 @@ end
 
             doc.data = Dict(
                 :binding => Docs.Binding(M, :k_10),
-                :typesig => Union{Tuple{T}, Tuple{T}} where T,
+                :typesig => 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("\nk_10(x) -> Any\n", str)
             @test_broken occursin("\n```\n", str)
         end