Tools for automatic test case reduction (#61)

Adds a few tools for verbose debug lowering and automatic test case
reduction.

Author: c42f

test/demo.jl

@@ -3,7 +3,7 @@
 using JuliaSyntax
 using JuliaLowering
 
-using JuliaLowering: SyntaxGraph, SyntaxTree, ensure_attributes!, ensure_attributes, newnode!, setchildren!, is_leaf, children, child, setattr!, sourceref, makenode, sourcetext, showprov, lookup_binding
+using JuliaLowering: SyntaxGraph, SyntaxTree, ensure_attributes!, ensure_attributes, newnode!, setchildren!, is_leaf, @ast, numchildren, children, child, setattr!, sourceref, makenode, sourcetext, showprov, lookup_binding
 
 using JuliaSyntaxFormatter
 
@@ -32,6 +32,37 @@ function formatsrc(ex; kws...)
     Text(JuliaSyntaxFormatter.formatsrc(ex; kws...))
 end
 
+function debug_lower(mod, ex; expr_compat_mode=false, verbose=false, do_eval=false)
+    ctx1, ex_macroexpand = JuliaLowering.expand_forms_1(mod, ex, expr_compat_mode)
+
+    verbose && @info "Macro expanded" formatsrc(ex_macroexpand, color_by=:scope_layer)
+
+    ctx2, ex_desugar = JuliaLowering.expand_forms_2(ctx1, ex_macroexpand)
+    verbose && @info "Desugared" formatsrc(ex_desugar, color_by=:scope_layer)
+
+    ctx3, ex_scoped = JuliaLowering.resolve_scopes(ctx2, ex_desugar)
+    verbose && @info "Resolved scopes" formatsrc(ex_scoped, color_by=e->var_kind(ctx2,e))
+
+    ctx4, ex_converted = JuliaLowering.convert_closures(ctx3, ex_scoped)
+    verbose && @info "Closure converted" formatsrc(ex_converted, color_by=:var_id)
+
+    ctx5, ex_compiled = JuliaLowering.linearize_ir(ctx4, ex_converted)
+    verbose && @info "Linear IR" formatsrc(ex_compiled, color_by=:var_id) Text(sprint(JuliaLowering.print_ir, ex_compiled))
+
+    ex_expr = JuliaLowering.to_lowered_expr(mod, ex_compiled)
+    verbose && @info "CodeInfo" ex_expr
+
+    if do_eval
+        eval_result = Base.eval(mod, ex_expr)
+        verbose && @info "Eval" eval_result
+    else
+        eval_result = nothing
+    end
+
+    (ctx1, ex_macroexpand, ctx2, ex_desugar, ctx3, ex_scoped, ctx4, ex_converted, ctx5, ex_compiled, ex_expr, eval_result)
+end
+
+
 # Currently broken - need to push info back onto src
 # function annotate_scopes(mod, ex)
 #     ex = ensure_attributes(ex, var_id=Int)
@@ -853,31 +884,28 @@ end
 """
 
 ex = parsestmt(SyntaxTree, src, filename="foo.jl")
-ex = ensure_attributes(ex, var_id=Int)
+#ex = ensure_attributes(ex, var_id=Int)
 #ex = softscope_test(ex)
 @info "Input code" formatsrc(ex)
 
-in_mod = M
-# in_mod=Main
-ctx1, ex_macroexpand = JuliaLowering.expand_forms_1(in_mod, ex, false)
-@info "Macro expanded" formatsrc(ex_macroexpand, color_by=:scope_layer)
-#@info "Macro expanded" formatsrc(ex_macroexpand, color_by=e->JuliaLowering.flattened_provenance(e)[1:end-1])
-
-ctx2, ex_desugar = JuliaLowering.expand_forms_2(ctx1, ex_macroexpand)
-@info "Desugared" formatsrc(ex_desugar, color_by=:scope_layer)
-
-ctx3, ex_scoped = JuliaLowering.resolve_scopes(ctx2, ex_desugar)
-@info "Resolved scopes" formatsrc(ex_scoped, color_by=e->var_kind(ctx2,e))
-
-ctx4, ex_converted = JuliaLowering.convert_closures(ctx3, ex_scoped)
-@info "Closure converted" formatsrc(ex_converted, color_by=:var_id)
-
-ctx5, ex_compiled = JuliaLowering.linearize_ir(ctx4, ex_converted)
-@info "Linear IR" formatsrc(ex_compiled, color_by=:var_id) Text(sprint(JuliaLowering.print_ir, ex_compiled))
-
-ex_expr = JuliaLowering.to_lowered_expr(in_mod, ex_compiled)
-@info "CodeInfo" ex_expr
+(ctx1, ex_macroexpand,
+ ctx2, ex_desugar,
+ ctx3, ex_scoped,
+ ctx4, ex_converted,
+ ctx5, ex_compiled,
+ ex_expr, eval_result) = debug_lower(M, ex; verbose=true)
+
+# Automatic test reduction
+# bad = reduce_any_failing_toplevel(JuliaLowering, joinpath(@__DIR__, "../src/desugaring.jl"))
+# if !isnothing(bad)
+#     @error "Reduced expression as code" formatsrc(bad)
+#     write("bad.jl", JuliaSyntaxFormatter.formatsrc(bad))
+# end
 
-eval_result = Base.eval(in_mod, ex_expr)
-@info "Eval" eval_result
+# Old lowering
+# text = read(joinpath(@__DIR__, "../src/desugaring.jl"), String)
+# ex = parseall(SyntaxTree, text, filename="desugaring.jl")
+# for e in Meta.parseall(text).args
+#     Meta.lower(JuliaLowering, e)
+# end
 

test/utils.jl

@@ -18,7 +18,7 @@ using JuliaLowering:
     makenode, makeleaf, setattr!, sethead!,
     is_leaf, numchildren, children,
     @ast, flattened_provenance, showprov, LoweringError, MacroExpansionError,
-    syntax_graph, Bindings, ScopeLayer
+    syntax_graph, Bindings, ScopeLayer, mapchildren
 
 function _ast_test_graph()
     graph = SyntaxGraph()
@@ -285,3 +285,102 @@ function docstrings_equal(d1, d2; debug=true)
 end
 docstrings_equal(d1::Docs.DocStr, d2) = docstrings_equal(Docs.parsedoc(d1), d2)
 
+#-------------------------------------------------------------------------------
+# Tools for test case reduction
+
+function block_reduction_1(is_lowering_error::Function, orig_ex::ST, ex::ST,
+                           curr_path = Int[]) where {ST <: SyntaxTree}
+    if !is_leaf(ex)
+        if kind(ex) == K"block"
+            for i in 1:numchildren(ex)
+                trial_ex = delete_block_child(orig_ex, orig_ex, curr_path, i)
+                if is_lowering_error(trial_ex)
+                    # @info "Reduced expression" curr_path i
+                    return trial_ex
+                end
+            end
+        end
+        for (i,e) in enumerate(children(ex))
+            push!(curr_path, i)
+            res = block_reduction_1(is_lowering_error, orig_ex, e, curr_path)
+            if !isnothing(res)
+                return res
+            end
+            pop!(curr_path)
+        end
+    end
+    return nothing
+end
+
+# Find children of all `K"block"`s in an expression and try deleting them while
+# preserving the invariant `is_lowering_error(reduced) == true`.
+function block_reduction(is_lowering_error, ex)
+    reduced = ex
+    was_reduced = false
+    while true
+        r = block_reduction_1(is_lowering_error, reduced, reduced)
+        if isnothing(r)
+            return (reduced, was_reduced)
+        end
+        reduced = r
+        was_reduced = true
+    end
+end
+
+function delete_block_child(ctx, ex, block_path, child_idx, depth=1)
+    if depth > length(block_path)
+        cs = copy(children(ex))
+        deleteat!(cs, child_idx)
+        @ast ctx ex [ex cs...]
+    else
+        j = block_path[depth]
+        mapchildren(ctx, ex, j:j) do e
+            delete_block_child(ctx, e, block_path, child_idx, depth+1)
+        end
+    end
+end
+
+function throws_lowering_exc(mod, ex)
+    try
+        debug_lower(mod, ex)
+        return false
+    catch exc
+        if exc isa LoweringError
+            return true
+        else
+            rethrow()
+        end
+    end
+end
+
+# Parse a file and lower the top level expression one child at a time, finding
+# any top level statement that fails lowering and producing a partially reduced
+# test case.
+function reduce_any_failing_toplevel(mod, filename; do_eval=false)
+    text = read(filename, String)
+    ex0 = parseall(SyntaxTree, text; filename)
+    for ex in children(ex0)
+        try
+            ex_compiled = JuliaLowering.lower(mod, ex)
+            ex_expr = JuliaLowering.to_lowered_expr(mod, ex_compiled)
+            if do_eval
+                Base.eval(mod, ex_expr)
+            end
+        catch exc
+            @error "Failure lowering code" ex
+            if !(exc isa LoweringError)
+                rethrow()
+            end
+            (reduced,was_reduced) = block_reduction(e->throws_lowering_exc(mod,e), ex)
+            if !was_reduced
+                @info "No reduction possible" 
+                return ex
+            else
+                @info "Reduced code" reduced
+                return reduced
+            end
+        end
+    end
+    nothing
+end
+