Fixes 165, Fixes 177.

Author: willow-ahrens

src/utils.jl

@@ -1,5 +1,5 @@
 export @esc, isexpr, isline, iscall, rmlines, unblock, block, inexpr, namify, isdef,
-  longdef, shortdef, @expand, makeif, prettify, combinedef, splitdef, splitarg
+  longdef, shortdef, @expand, makeif, prettify, combinedef, splitdef, splitarg, combinearg
 
 """
     assoc!(d, k, v)
@@ -406,7 +406,10 @@ end
 `combinearg` is the inverse of [`splitarg`](@ref).
 """
 function combinearg(arg_name, arg_type, is_splat, default)
-    a = arg_name===nothing ? :(::$arg_type) : :($arg_name::$arg_type)
+    @assert arg_name !== nothing || arg_type !== nothing
+    a = arg_name===nothing ? :(::$arg_type) :
+        arg_type===nothing ? arg_name :
+            :($arg_name::$arg_type)
     a2 = is_splat ? Expr(:..., a) : a
     return default === nothing ? a2 : Expr(:kw, a2, default)
 end
@@ -415,34 +418,34 @@ end
     splitarg(arg)
 
 Match function arguments (whether from a definition or a function call) such as
-`x::Int=2` and return `(arg_name, arg_type, is_splat, default)`. `arg_name` and
-`default` are `nothing` when they are absent. For example:
+`x::Int=2` and return `(arg_name, arg_type, is_splat, default)`. `arg_name`,
+`arg_type`, and `default` are `nothing` when they are absent. For example:
 
 ```julia
 julia> map(splitarg, (:(f(a=2, x::Int=nothing, y, args...))).args[2:end])
 4-element Array{Tuple{Symbol,Symbol,Bool,Any},1}:
- (:a, :Any, false, 2)
+ (:a, nothing, false, 2)
  (:x, :Int, false, :nothing)
  (:y, :Any, false, nothing)
- (:args, :Any, true, nothing)
+ (:args, nothing, true, nothing)
 ```
 
 See also: [`combinearg`](@ref)
 """
 function splitarg(arg_expr)
-    splitvar(arg) =
-        (@match arg begin
-            ::T_ => (nothing, T)
-            name_::T_ => (name, T)
-            x_ => (x, :Any)
-        end)::NTuple{2,Any} # the pattern `x_` matches any expression
-    (is_splat = @capture(arg_expr, arg_expr2_...)) || (arg_expr2 = arg_expr)
-    if @capture(arg_expr2, arg_ = default_)
-        @assert default !== nothing "splitarg cannot handle `nothing` as a default. Use a quoted `nothing` if possible. (MacroTools#35)"
-        return (splitvar(arg)..., is_splat, default)
+    if @capture(arg_expr, arg_expr2_ = default_)
+      @assert default !== nothing "splitarg cannot handle `nothing` as a default. Use a quoted `nothing` if possible. (MacroTools#35)"
     else
-        return (splitvar(arg_expr2)..., is_splat, nothing)
+       arg_expr2 = arg_expr
     end
+    is_splat = @capture(arg_expr2, arg_expr3_...)
+    is_splat || (arg_expr3 = arg_expr2)
+    (arg_name, arg_type) = (@match arg_expr3 begin
+        ::T_ => (nothing, T)
+        name_::T_ => (name, T)
+        x_ => (x, nothing)
+    end)::NTuple{2,Any} # the pattern `x_` matches any expression
+    return (arg_name, arg_type, is_splat, default)
 end
 
 

test/split.jl

@@ -6,6 +6,8 @@ end
 
 macro splitcombine(fundef) # should be a no-op
     dict = splitdef(fundef)
+    dict[:args] = map(arg->combinearg(splitarg(arg)...), dict[:args])
+    dict[:kwargs] = map(arg->combinearg(splitarg(arg)...), dict[:kwargs])
     esc(MacroTools.combinedef(dict))
 end
 
@@ -24,10 +26,17 @@ let
     @test longdef(:(f(x)::Int = 10)).head == :function
     @test longdef(:(f(x::T) where U where T = 2)).head == :function
     @test shortdef(:(function f(x)::Int 10 end)).head != :function
-    @test map(splitarg, (:(f(a=2, x::Int=nothing, y, args...))).args[2:end]) ==
-        [(:a, :Any, false, 2), (:x, :Int, false, :nothing),
-         (:y, :Any, false, nothing), (:args, :Any, true, nothing)]
+    @test map(splitarg, (:(f(a=2, x::Int=nothing, y::Any, args...))).args[2:end]) ==
+        [(:a, nothing, false, 2), (:x, :Int, false, :nothing),
+         (:y, :Any, false, nothing), (:args, nothing, true, nothing)]
     @test splitarg(:(::Int)) == (nothing, :Int, false, nothing)
+    kwargs = splitdef(:(f(; a::Int = 1, b...) = 1))[:kwargs]
+    @test map(splitarg, kwargs) ==
+        [(:a, :Int, false, 1), (:b, nothing, true, nothing)]
+    args = splitdef(:(f(a::Int = 1) = 1))[:args]
+    @test map(splitarg, args) == [(:a, :Int, false, 1)]
+    args = splitdef(:(f(a::Int ... = 1) = 1))[:args]
+    @test map(splitarg, args) == [(:a, :Int, true, 1)]
 
     @splitcombine foo(x) = x+2
     @test foo(10) == 12
@@ -47,6 +56,12 @@ let
     @splitcombine fmacro1() = @onearg 1
     @test fmacro1() == 2
 
+    @splitcombine bar(; a::Int = 1, b...) = 2
+    @test bar(a=3, x = 1, y = 2) == 2
+    @splitcombine qux(a::Int... = 0) = sum(a)
+    @test qux(1, 2, 3) == 6
+    @test qux() == 0
+
     struct Foo{A, B}
         a::A
         b::B