Make tests pass

Author: Keno

src/ASTInterpreter2.jl

@@ -28,10 +28,11 @@ struct JuliaStackFrame
     # for which a reference was last encountered.
     last_reference::Dict{Symbol, Int}
     wrapper::Bool
+    generator::Bool
 end
-function JuliaStackFrame(frame::JuliaStackFrame, pc::JuliaProgramCounter; wrapper = false)
+function JuliaStackFrame(frame::JuliaStackFrame, pc::JuliaProgramCounter; wrapper = frame.wrapper, generator=frame.generator)
     JuliaStackFrame(frame.meth, frame.code, frame.locals,
-                    frame.ssavalues, frame.sparams, pc, frame.last_reference, wrapper)
+                    frame.ssavalues, frame.sparams, pc, frame.last_reference, wrapper, generator)
 end
 
 is_loc_meta(expr, kind) = isexpr(expr, :meta) && length(expr.args) >= 1 && expr.args[1] === kind
@@ -59,7 +60,7 @@ function determine_line_and_file(frame, highlight::Int=0)
                 npops = 1
                 while npops >= 1
                     i -= 1
-                    expr = exprtree.args[i]
+                    expr = frame.code.code[i]
                     is_loc_meta(expr, :pop_loc) && (npops += 1)
                     is_loc_meta(expr, :push_loc) && (npops -= 1)
                 end
@@ -232,7 +233,7 @@ end
 function JuliaStackFrame(meth::Method)
     JuliaStackFrame(meth, Vector{Nullable{Any}}(),
         Vector{Any}(), Vector{Any}(), Vector{Any}(),
-        Dict{Symbol, Int}(), false)
+        Dict{Symbol, Int}(), false, false)
 end
 
 function DebuggerFramework.debug(meth::Method, args...)
@@ -298,7 +299,7 @@ function determine_method_for_expr(expr; enter_generated = false)
             # If we're stepping into a staged function, we need to use
             # the specialization, rather than stepping thorugh the
             # unspecialized method.
-            code = Core.Inference.specialize_method(method, argtypes, lenv, false)
+            code = Core.Inference.get_staged(Core.Inference.code_for_method(method, argtypes, lenv, typemax(UInt), false))
         else
             if method.isstaged
                 args = map(_Typeof, args)
@@ -317,7 +318,7 @@ function get_source(meth)
     end
 end
 
-function prepare_locals(meth, code, argvals = ())
+function prepare_locals(meth, code, argvals = (), generator = false)
     code = deepcopy(code)
     linearize!(code)
     # Construct the environment from the arguments
@@ -337,15 +338,15 @@ function prepare_locals(meth, code, argvals = ())
     for i = (meth.nargs+1):length(code.slotnames)
         locals[i] = Nullable{Any}()
     end
-    JuliaStackFrame(meth, code, locals, ssavalues, sparams, JuliaProgramCounter(2), Dict{Symbol,Int}(), false)
+    JuliaStackFrame(meth, code, locals, ssavalues, sparams, JuliaProgramCounter(2), Dict{Symbol,Int}(), false, generator)
 end
 
 
 function enter_call_expr(expr; enter_generated = false)
     r = determine_method_for_expr(expr; enter_generated = enter_generated)
     if r !== nothing
         code, method, args, lenv = r
-        frame = prepare_locals(method, code, args)
+        frame = prepare_locals(method, code, args, enter_generated)
         # Add static parameters to environment
         for i = 1:length(lenv)
             frame.sparams[i] = lenv[i]

src/commands.jl

@@ -5,19 +5,29 @@ function perform_return!(state)
         returning_expr = pc_expr(returning_frame)
         @assert isexpr(returning_expr, :return)
         val = lookup_var_if_var(returning_frame, returning_expr.args[1])
-        do_assignment!(calling_frame, pc_expr(calling_frame).args[1], val)
-        state.stack[2] = JuliaStackFrame(calling_frame, maybe_next_call!(calling_frame,
-            calling_frame.pc + 1))
+        if returning_frame.generator
+            # Don't do anything here, just return us to where we were
+        else
+            if isexpr(pc_expr(calling_frame), :(=))
+                do_assignment!(calling_frame, pc_expr(calling_frame).args[1], val)
+            end
+            state.stack[2] = JuliaStackFrame(calling_frame, maybe_next_call!(calling_frame,
+                calling_frame.pc + 1))
+        end
     end
     shift!(state.stack)
+    if !isempty(state.stack) && state.stack[1].wrapper
+        state.stack[1] = JuliaStackFrame(state.stack[1], finish!(state.stack[1]))
+        perform_return!(state)
+    end
 end
 
 function DebuggerFramework.execute_command(state, frame::JuliaStackFrame, ::Union{Val{:ns},Val{:nc},Val{:n},Val{:se}}, command)
     if (pc = command == "ns" ? next_statement!(frame) :
            command == "nc" ? next_call!(frame) :
-           command == "n" ? next_line!(frame; state = state) :
+           command == "n" ? next_line!(frame, state.stack) :
             !step_expr(frame)) != nothing #= command == "se" =#
-        state.stack[1] = JuliaStackFrame(frame, pc)
+        state.stack[1] = JuliaStackFrame(state.stack[1], pc)
         return true
     end
     perform_return!(state)
@@ -33,16 +43,25 @@ function DebuggerFramework.execute_command(state, frame::JuliaStackFrame, cmd::U
             if is_call(expr)
                 isexpr(expr, :(=)) && (expr = expr.args[2])
                 expr = Expr(:call, map(x->lookup_var_if_var(frame, x), expr.args)...)
+                ok = true
                 if !isa(expr.args[1], Union{Core.Builtin, Core.IntrinsicFunction})
                     new_frame = enter_call_expr(expr;
                         enter_generated = command == "sg")
                     if (cmd == Val{:s}() || cmd == Val{:sg}())
                         new_frame = JuliaStackFrame(new_frame, maybe_next_call!(new_frame))
                     end
-                    state.stack[1] = JuliaStackFrame(frame, pc)                
-                    unshift!(state.stack, new_frame)
-                    return true
+                    # Don't step into Core.Inference
+                    if new_frame.meth.module == Core.Inference
+                        ok = false
+                    else
+                        state.stack[1] = JuliaStackFrame(frame, pc)
+                        unshift!(state.stack, new_frame)
+                        return true
+                    end
                 else
+                    ok = false
+                end
+                if !ok
                     # It's confusing if we step into the next call, so just go there
                     # and then return
                     state.stack[1] = JuliaStackFrame(frame, next_call!(frame, pc))

src/interpret.jl

@@ -17,22 +17,45 @@ function finish!(frame)
     end
 end
 
+instantiate_type_in_env(arg, spsig, spvals) =
+    ccall(:jl_instantiate_type_in_env, Any, (Any, Any, Ptr{Any}), arg, spsig, spvals)
+
 function evaluate_call(frame, call_expr)
-    # Don't go through eval since this may have unqouted, symbols and
-    # exprs
-    f = to_function(lookup_var(frame, call_expr.args[1]))
-    args = Array{Any}(length(call_expr.args)-1)
+    args = Array{Any}(length(call_expr.args))
     for i = 1:length(args)
-        arg = call_expr.args[i+1]
-        args[i] = isa(arg, Union{SSAValue, GlobalRef, Slot}) ? lookup_var(frame, arg) :
-            arg
+        arg = call_expr.args[i]
+        if isa(arg, QuoteNode)
+            args[i] = arg.value
+        elseif isa(arg, Union{SSAValue, GlobalRef, Slot})
+            args[i] = lookup_var(frame, arg)
+        elseif isexpr(arg, :&)
+            args[i] = Expr(:&, lookup_var(frame, arg.args[1]))
+        else
+            args[i] = arg
+        end
     end
-    if isa(f, CodeInfo)
-        ret = finish!(enter_call_expr(frame, call_expr))
+    # Don't go through eval since this may have unqouted, symbols and
+    # exprs
+    if isexpr(call_expr, :foreigncall)
+        args = map(args) do arg
+            isa(arg, Symbol) ? QuoteNode(arg) : arg
+        end
+        if !isempty(frame.sparams)
+            args[2] = instantiate_type_in_env(args[2], frame.meth.sig, frame.sparams)
+            args[3] = Core.svec(map(args[3]) do arg
+                instantiate_type_in_env(arg, frame.meth.sig, frame.sparams)
+            end...)
+        end
+        ret = eval(frame.meth.module, Expr(:foreigncall, args...))
     else
-        # Don't go through eval since this may have unqouted, symbols and
-        # exprs
-        ret = f(args...)
+        f = to_function(args[1])
+        if isa(f, CodeInfo)
+            ret = finish!(enter_call_expr(frame, call_expr))
+        else
+            # Don't go through eval since this may have unqouted, symbols and
+            # exprs
+            ret = f(args[2:end]...)
+        end
     end
     return ret
 end
@@ -56,8 +79,13 @@ function _step_expr(frame, pc)
         if isa(node, Expr)
             if node.head == :(=)
                 lhs = node.args[1]
-                rhs = isexpr(node.args[2], :call) ? evaluate_call(frame, node.args[2]) :
-                    lookup_var(frame, node.args[2])
+                if isexpr(node.args[2], :new)
+                    new_expr = Expr(:new, map(x->lookup_var_if_var(frame, x), node.args[2].args)...)
+                    rhs = eval(frame.meth.module, new_expr)
+                else
+                    rhs = (isexpr(node.args[2], :call) || isexpr(node.args[2], :foreigncall)) ? evaluate_call(frame, node.args[2]) :
+                        lookup_var_if_var(frame, node.args[2])
+                end
                 do_assignment!(frame, lhs, rhs)
                 # Special case hack for readability.
                 # ret = rhs
@@ -66,19 +94,19 @@ function _step_expr(frame, pc)
                 ret = node
             elseif node.head == :gotoifnot
                 ret = node
-                arg = lookup_var(frame, node.args[1])
+                arg = node.args[1]
+                arg = isa(arg, Bool) ? arg : lookup_var(frame, arg)
                 if !isa(arg, Bool)
                     throw(TypeError(frame.meth.name, "if", Bool, node.args[1]))
                 end
                 if !arg
                     return JuliaProgramCounter(node.args[2])
                 end
-            elseif node.head == :call
+            elseif node.head == :call || node.head == :foreigncall
                 evaluate_call(frame, node)
             elseif node.head == :static_typeof
                 ret = Any
-            elseif node.head == :type_goto
-                ret = nothing
+            elseif node.head == :type_goto || node.head == :inbounds
             elseif node.head == :enter
                 push!(interp.exception_frames, node.args[1])
                 ret = node
@@ -95,7 +123,7 @@ function _step_expr(frame, pc)
                 ret = eval(node)
             end
         elseif isa(node, GotoNode)
-            return JuliaProgramCounter(node.args[1])
+            return JuliaProgramCounter(node.label)
         elseif isa(node, QuoteNode)
             ret = node.value
         else
@@ -154,20 +182,9 @@ isgotonode(node) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
 Determine whether we are calling a function for which the current function
 is a wrapper (either because of optional arguments or becaue of keyword arguments).
 """
-function iswrappercall(interp, expr)
-    !isexpr(expr, :call) && return false
-    r = determine_method_for_expr(interp, expr; enter_generated = false)
-    if r !== nothing
-        linfo, method, args, _ = r
-        ours, theirs = interp.linfo.def, method
-        # Check if this a method of the same function that shares a definition line/file.
-        # If so, we're likely in an automatically generated wrapper.
-        if ours.sig.parameters[1] == theirs.sig.parameters[1] &&
-            ours.line == theirs.line && ours.file == theirs.file
-            return true
-        end
-    end
-    return false
+function iswrappercall(expr)
+    isexpr(expr, :(=)) && (expr = expr.args[2])
+    isexpr(expr, :call) && any(x->x==SlotNumber(1), expr.args)
 end
 
 pc_expr(frame, pc) = frame.code.code[pc.next_stmt]
@@ -181,7 +198,7 @@ function maybe_next_call!(frame, pc)
 end
 maybe_next_call!(frame) = maybe_next_call!(frame, frame.pc)
 
-function next_line!(frame; state = nothing)
+function next_line!(frame, stack = nothing)
     didchangeline = false
     fls = determine_line_and_file(frame, frame.pc.next_stmt)
     line = fls[1][2]
@@ -198,9 +215,13 @@ function next_line!(frame; state = nothing)
             pc == nothing && return nothing
             fls = determine_line_and_file(frame, pc.next_stmt)
             didchangeline = line != fls[1][2]
-        elseif iswrappercall(frame, pc_expr(frame, pc))
-            interp.did_wrappercall = true
-            frame = enter_call_expr(frame, pc_expr(frame, pc))
+        elseif stack !== nothing && iswrappercall(pc_expr(frame, pc))
+            stack[1] = JuliaStackFrame(frame, pc; wrapper = true)
+            call_expr = pc_expr(frame, pc)
+            isexpr(call_expr, :(=)) && (call_expr = call_expr.args[2])
+            frame = enter_call_expr(Expr(:call, map(x->lookup_var_if_var(frame, x), call_expr.args)...))
+            unshift!(stack, frame)
+            pc = frame.pc
         elseif isa(pc_expr(frame, pc), LineNumberNode)
             line != pc_expr(frame, pc).line && break
             pc = _step_expr(frame, pc)

test/evaling.jl

@@ -5,19 +5,19 @@ function evalfoo1(x,y)
     x+y
 end
 frame = ASTInterpreter2.enter_call_expr(:($(evalfoo1)(1,2)))
-ok, res = DebuggerFramework.eval_code(nothing, frame, "x")
+res = DebuggerFramework.eval_code(nothing, frame, "x")
 @assert res == 1
 
-ok, res = DebuggerFramework.eval_code(state, "y")
+res = DebuggerFramework.eval_code(nothing, frame, "y")
 @assert res == 2
 
 # Evaling with sparams
 function evalsparams{T}(x::T)
     x
 end
 frame = ASTInterpreter2.enter_call_expr(:($(evalsparams)(1)))
-ok, res = DebuggerFramework.eval_code(nothing, frame, "x")
+res = DebuggerFramework.eval_code(nothing, frame, "x")
 @assert res == 1
 
-ok, res = DebuggerFramework.eval_code(nothing, frame, "T")
+res = DebuggerFramework.eval_code(nothing, frame, "T")
 @assert res == Int

test/interpret.jl

@@ -0,0 +1,60 @@
+using ASTInterpreter2
+using ASTInterpreter2: enter_call_expr
+using Base.Test
+
+function CallTest()
+    UnitRange{Int64}(2,2)
+end
+
+step_through(enter_call_expr(:($(CallTest)())))
+
+# Properly handle :meta annotations
+function MetaTest()
+    @Base._pure_meta
+    0
+end
+
+step_through(enter_call_expr(:($(MetaTest)())))
+
+# Test Vararg handling
+function VATest(x...)
+    x
+end
+callVA() = VATest()
+
+step_through(enter_call_expr(:($(VATest)())))
+
+# Test Loops
+function LoopTest()
+    x = Int[]
+    for i = 1:2
+        push!(x, i)
+    end
+    x
+end
+
+step_through(enter_call_expr(:($(LoopTest)())))
+
+# Test continue
+function ContinueTest()
+    x = Int[]
+    for i = 1:3
+        if true
+            push!(x, i)
+            continue
+        end
+        error("Fell through")
+    end
+    x
+end
+
+step_through(enter_call_expr(:($(ContinueTest)())))
+
+#foo() = 1+1
+function foo(n)
+    x = n+1
+    ((BigInt[1 1; 1 0])^x)[2,1]
+end
+
+
+step_through(enter_call_expr(:($(foo)(20))))

test/runtests.jl

@@ -1,4 +1,6 @@
 using ASTInterpreter2
 using Base.Test
 
-include("evaling.jl")
+include("evaling.jl")
+include("stepping.jl")
+include("interpret.jl")