Tweaks for macros

Author: mlechu

src/compat.jl

@@ -17,7 +17,7 @@ the last seen LineNumberNode in the pre-order expr traversal).
 Last-resort option so that, for example, we can lower the output of old
 Expr-producing macros.  Always prefer re-parsing source text over using this.
 
-Does not support lowered exprs.
+Supports parsed and/or macro-expanded exprs, but not lowered exprs
 """
 function expr_to_syntaxtree(@nospecialize(e), lnn::Union{LineNumberNode, Nothing}=nothing)
     graph = SyntaxGraph()
@@ -154,11 +154,11 @@ function _insert_convert_expr(@nospecialize(e), graph::SyntaxGraph, src::SourceA
         return (st_id, src)
     elseif e isa LineNumberNode
         return (nothing, e)
-    elseif e isa QuoteNode
-        st_id = _insert_tree_node(graph, K"quote", src)
-        quote_child, _ = _insert_convert_expr(e.value, graph, src)
-        setchildren!(graph, st_id, NodeId[quote_child])
-        return (st_id, src)
+    # elseif e isa QuoteNode
+    #     st_id = _insert_tree_node(graph, K"quote", src)
+    #     quote_child, _ = _insert_convert_expr(e.value, graph, src)
+    #     setchildren!(graph, st_id, NodeId[quote_child])
+    #     return (st_id, src)
     elseif e isa String
         st_id = _insert_tree_node(graph, K"string", src)
         id_inner = _insert_tree_node(graph, K"String", src)
@@ -211,9 +211,11 @@ function _insert_convert_expr(@nospecialize(e), graph::SyntaxGraph, src::SourceA
             end
         end
     elseif e.head === :macrocall
-        @assert nargs >= 1
+        @assert nargs >= 2
         a1 = e.args[1]
-        child_exprs = collect_expr_parameters(e, 2)
+        child_exprs = collect_expr_parameters(e, 3)
+        # macrocall has a linenode "argument" here. should we set src?
+        deleteat!(child_exprs, 2)
         if a1 isa Symbol
             child_exprs[1] = Expr(:MacroName, a1)
         elseif a1 isa Expr && a1.head === :(.) && a1.args[2] isa QuoteNode
@@ -227,12 +229,20 @@ function _insert_convert_expr(@nospecialize(e), graph::SyntaxGraph, src::SourceA
             elseif a1.name === Symbol("@int128_str")
             elseif a1.name === Symbol("@big_str")
             end
+        elseif a1 isa Function
         else
-            dump(e)
-            error("Unknown macrocall form $e")
+            error("Unknown macrocall form $(sprint(dump, e))")
         end
 
         # TODO node->expr handles do blocks here?
+    elseif e.head === :escape || e.head === Symbol("hygienic-scope")
+        @assert nargs >= 1
+        # Existing behaviour appears to just ignore any extra args
+        return _insert_convert_expr(e.args[1], graph, src)
+    elseif e.head === :meta
+        @assert nargs <= 2
+        @assert e.args[1] isa Symbol
+        child_exprs[1] = Expr(:sym_not_identifier, e.args[1])
     elseif e.head === Symbol("'")
         @assert nargs === 1
         st_k = K"call"
@@ -359,13 +369,18 @@ function _insert_convert_expr(@nospecialize(e), graph::SyntaxGraph, src::SourceA
         st_id = _insert_tree_node(graph, K"Placeholder", src, st_flags)
         setattr!(graph, st_id, name_val="")
         return (st_id, src)
+    elseif e.head === :sym_not_identifier
+        estr = String(e.args[1])
+        st_k = K"Symbol"
+        st_id = _insert_tree_node(graph, st_k, src)
+        setattr!(graph, st_id, name_val=estr)
+        return (st_id, src)
     elseif e.head === :do_lambda
         st_k = K"do"
     end
 
     if st_k === K"None"
-        dump(e)
-        error("no kind for $(e.head)")
+        error("no kind for expr head `$(e.head)`\n$(sprint(dump, e))")
     end
 
     st_flags |= JS.NON_TERMINAL_FLAG

src/macro_expansion.jl

@@ -110,7 +110,11 @@ function Base.showerror(io::IO, exc::MacroExpansionError)
                 pos == :begin   ? (fb:fb-1) :
                 pos == :end     ? (lb+1:lb) :
                 error("Unknown position $pos")
-    highlight(io, src.file, byterange, note=exc.msg)
+    if isnothing(src.file)
+        print(io, "(no source available) $src")
+    else
+        highlight(io, src.file, byterange, note=exc.msg)
+    end
 end
 
 function eval_macro_name(ctx, ex)
@@ -127,21 +131,40 @@ function eval_macro_name(ctx, ex)
     eval(mod, expr_form)
 end
 
+function is_expr_macro(mac)
+    # If `mac` is @-prefixed and has no method taking MacroContext, assume it's
+    # an old-style macro.  Prefer new macros where possible.
+    return string(Base.nameof(mac))[1] === '@' &&
+        !any(m -> length(m.sig.types) >= 2 && m.sig.types[2] == MacroContext,
+            Base.methods(mac))
+end
+
 function expand_macro(ctx, ex)
     @assert kind(ex) == K"macrocall"
 
     macname = ex[1]
     macfunc = eval_macro_name(ctx, macname)
-    # Macro call arguments may be either
-    # * Unprocessed by the macro expansion pass
-    # * Previously processed, but spliced into a further macro call emitted by
-    #   a macro expansion.
-    # In either case, we need to set any unset scope layers before passing the
-    # arguments to the macro call.
+    use_compat = is_expr_macro(macfunc)
+    macro_args = Any[]
     mctx = MacroContext(ctx.graph, ex, ctx.current_layer)
-    macro_args = Any[mctx]
-    for i in 2:numchildren(ex)
-        push!(macro_args, set_scope_layer(ctx, ex[i], ctx.current_layer.id, false))
+    if use_compat
+        lnn = source_location(LineNumberNode, JS.sourcefile(ex), JuliaSyntax.first_byte(ex))
+        push!(macro_args, lnn)
+        push!(macro_args, ctx.current_layer.mod)
+        for i in 2:numchildren(ex)
+            push!(macro_args, Base.Expr(set_scope_layer(ctx, ex[i], ctx.current_layer.id, false)))
+        end
+    elseif !use_compat
+        # Macro call arguments may be either
+        # * Unprocessed by the macro expansion pass
+        # * Previously processed, but spliced into a further macro call emitted by
+        #   a macro expansion.
+        # In either case, we need to set any unset scope layers before passing the
+        # arguments to the macro call.
+        push!(macro_args, mctx)
+        for i in 2:numchildren(ex)
+            push!(macro_args, set_scope_layer(ctx, ex[i], ctx.current_layer.id, false))
+        end
     end
     macro_invocation_world = Base.get_world_counter()
     expanded = try
@@ -157,6 +180,10 @@ function expand_macro(ctx, ex)
         end
     end
 
+    if expanded isa Expr
+        expanded = expr_to_syntaxtree(expanded, lnn)
+    end
+
     if expanded isa SyntaxTree
         if !is_compatible_graph(ctx, expanded)
             # If the macro has produced syntax outside the macro context, copy it over.