Switch to using ExprTools

Author: omus

Project.toml

@@ -3,10 +3,12 @@ uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 version = "0.5.5"
 
 [deps]
+ExprTools = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [compat]
+ExprTools = "0.1"
 julia = "1"
 
 [extras]

src/MacroTools.jl

@@ -1,6 +1,8 @@
 module MacroTools
 
 using Markdown, Random
+using ExprTools: splitdef, combinedef
+
 export @match, @capture
 
 include("match/match.jl")

src/utils.jl

@@ -259,127 +259,6 @@ function gatherwheres(ex)
   end
 end
 
-"""    splitdef(fdef)
-
-Match any function definition
-
-```julia
-function name{params}(args; kwargs)::rtype where {whereparams}
-   body
-end
-```
-
-and return `Dict(:name=>..., :args=>..., etc.)`. The definition can be rebuilt by
-calling `MacroTools.combinedef(dict)`, or explicitly with
-
-```
-rtype = get(dict, :rtype, :Any)
-all_params = [get(dict, :params, [])..., get(dict, :whereparams, [])...]
-:(function \$(dict[:name]){\$(all_params...)}(\$(dict[:args]...);
-                                            \$(dict[:kwargs]...))::\$rtype
-      \$(dict[:body])
-  end)
-```
-"""
-function splitdef(fdef)
-  error_msg = "Not a function definition: $(repr(fdef))"
-  @assert(@capture(longdef1(fdef),
-                   function (fcall_ | fcall_) body_ end),
-          "Not a function definition: $fdef")
-  fcall_nowhere, whereparams = gatherwheres(fcall)
-  func = args = kwargs = rtype = nothing
-  if @capture(fcall_nowhere, ((func_(args__; kwargs__)) |
-                              (func_(args__; kwargs__)::rtype_) |
-                              (func_(args__)) |
-                              (func_(args__)::rtype_)))
-  elseif isexpr(fcall_nowhere, :tuple)
-    if length(fcall_nowhere.args) > 1 && isexpr(fcall_nowhere.args[1], :parameters)
-      args = fcall_nowhere.args[2:end]
-      kwargs = fcall_nowhere.args[1].args
-    else
-      args = fcall_nowhere.args
-    end
-  elseif isexpr(fcall_nowhere, :(::))
-    args = Any[fcall_nowhere]
-  else
-    throw(ArgumentError(error_msg))
-  end
-  if func !== nothing
-    @assert(@capture(func, (fname_{params__} | fname_)), error_msg)
-    di = Dict(:name=>fname, :args=>args,
-              :kwargs=>(kwargs===nothing ? [] : kwargs), :body=>body)
-  else
-    params = nothing
-    di = Dict(:args=>args, :kwargs=>(kwargs===nothing ? [] : kwargs), :body=>body)
-  end
-  if rtype !== nothing; di[:rtype] = rtype end
-  if whereparams !== nothing; di[:whereparams] = whereparams end
-  if params !== nothing; di[:params] = params end
-  di
-end
-
-"""
-    combinedef(dict::Dict)
-
-`combinedef` is the inverse of `splitdef`. It takes a splitdef-like Dict
-and returns a function definition. """
-function combinedef(dict::Dict)
-  rtype = get(dict, :rtype, nothing)
-  params = get(dict, :params, [])
-  wparams = get(dict, :whereparams, [])
-  body = block(dict[:body])
-  if haskey(dict, :name)
-    name = dict[:name]
-    name_param = isempty(params) ? name : :($name{$(params...)})
-    # We need the `if` to handle parametric inner/outer constructors like
-    # SomeType{X}(x::X) where X = SomeType{X}(x, x+2)
-    if isempty(wparams)
-      if rtype==nothing
-        @q(function $name_param($(dict[:args]...);
-                                $(dict[:kwargs]...))
-          $(body.args...)
-          end)
-      else
-        @q(function $name_param($(dict[:args]...);
-                                $(dict[:kwargs]...))::$rtype
-          $(body.args...)
-          end)
-      end
-    else
-      if rtype==nothing
-        @q(function $name_param($(dict[:args]...);
-                                $(dict[:kwargs]...)) where {$(wparams...)}
-          $(body.args...)
-          end)
-      else
-        @q(function $name_param($(dict[:args]...);
-                                $(dict[:kwargs]...))::$rtype where {$(wparams...)}
-          $(body.args...)
-          end)
-      end
-    end
-  else
-    if isempty(dict[:kwargs])
-      arg = :($(dict[:args]...),)
-    else
-      arg = Expr(:tuple, Expr(:parameters, dict[:kwargs]...), dict[:args]...)
-    end
-    if isempty(wparams)
-      if rtype==nothing
-        @q($arg -> $body)
-      else
-        @q(($arg::$rtype) -> $body)
-      end
-    else
-      if rtype==nothing
-        @q(($arg where {$(wparams...)}) -> $body)
-      else
-        @q(($arg::$rtype where {$(wparams...)}) -> $body)
-      end
-    end
-  end
-end
-
 """
     combinearg(arg_name, arg_type, is_splat, default)
 

test/split.jl

@@ -1,7 +1,6 @@
 using MacroTools: splitstructdef, combinestructdef
 
-macro nothing_macro()
-end
+macro nothing_macro() end
 @test @expand(@nothing_macro) === nothing
 
 macro splitcombine(fundef) # should be a no-op