fixup! Add support for default values to TYPEDSIGNATURES

Author: JamesWrigley

src/parsing.jl

@@ -79,27 +79,28 @@ function parse_arglist!(exprs, args, kwargs, is_kwarg_list=false)
 end
 
 # Find a :call expression within an Expr. This will take care of ignoring other
-# tokens like `where` clauses.
-function find_call_expr(expr::Expr)
-    if Meta.isexpr(expr, :macrocall) && expr.args[1] === Symbol("@generated")
-        # If this is a generated function, find the first := expr to find
-        # the :call expr.
-        assignment_idx = findfirst(x -> x isa Expr && Meta.isexpr(x, :(=)), expr.args)
+# tokens like `where` clauses. It will return `nothing` if a :call expression
+# wasn't found.
+function find_call_expr(obj)
+    if Meta.isexpr(obj, :call)
+        # Base case: we've found the :call expression
+        return obj
+    elseif obj isa Symbol || (obj isa Expr && isempty(obj.args))
+        # Base case: this is the end of a branch in the expression tree
+        return nothing
+    end
 
-        expr.args[assignment_idx].args[1]
-    elseif Meta.isexpr(expr, :(=))
-        find_call_expr(expr.args[1])
-    elseif Meta.isexpr(expr, :where)
-        # Function with one or more `where` clauses
-        find_call_expr(expr.args[1])
-    elseif Meta.isexpr(expr, :function)
-        find_call_expr(expr.args[1])
-    elseif Meta.isexpr(expr, :call)
-        expr
-    else
-        Meta.dump(expr)
-        error("Can't parse current expr (printed above)")
+    # Recursive case: recurse over all the Expr arguments
+    for arg in obj.args
+        if arg isa Expr
+            result = find_call_expr(arg)
+            if !isnothing(result)
+                return result
+            end
+        end
     end
+
+    return nothing
 end
 
 # Parse an expression to find a :call expr, and return as much information as

test/TestModule/M.jl

@@ -49,6 +49,11 @@ struct K
     K(; a = 1) = new()
 end
 
+macro m1(expr) expr end
+macro m2(expr) expr end
+
+@m1 @m2 l(x::Int, y=1) = x + y
+
 abstract type AbstractType1 <: Integer end
 abstract type AbstractType2{S, T <: Integer} <: Integer end
 

test/tests.jl

@@ -471,7 +471,15 @@ end
 
             end
 
-
+            doc.data = Dict(
+                :binding => Docs.Binding(M, :l),
+                :typesig => Union{Tuple{Int}, Tuple{Int, Any}},
+                :module => M,
+            )
+            DSE.format(TypedSignatures(get_expr(M.l, Int, Int)), buf, doc)
+            str = String(take!(buf))
+            @test occursin("\nl(x::Int64) -> Int64\n", str)
+            @test occursin("\nl(x::Int64, y=1) -> Any\n", str)
         end
 
         @testset "function names" begin