remove old compats (#598)

This should be good to go as far as 1.6 CI passes.

Author: aviatesk

src/commands.jl

@@ -119,7 +119,7 @@ maybe_next_until!(@nospecialize(predicate), frame::Frame, istoplevel::Bool=false
     pc = next_call!(frame, istoplevel=false)
 
 Execute the current statement. Continue stepping through `frame` until the next
-`:return` or `:call` expression.
+`ReturnNode` or `:call` expression.
 """
 next_call!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=false) =
     next_until!(frame -> is_call_or_return(pc_expr(frame)), recurse, frame, istoplevel)
@@ -129,8 +129,8 @@ next_call!(frame::Frame, istoplevel::Bool=false) = next_call!(finish_and_return!
     pc = maybe_next_call!(recurse, frame, istoplevel=false)
     pc = maybe_next_call!(frame, istoplevel=false)
 
-Return the current program counter of `frame` if it is a `:return` or `:call` expression.
-Otherwise, step through the statements of `frame` until the next `:return` or `:call` expression.
+Return the current program counter of `frame` if it is a `ReturnNode` or `:call` expression.
+Otherwise, step through the statements of `frame` until the next `ReturnNode` or `:call` expression.
 """
 maybe_next_call!(@nospecialize(recurse), frame::Frame, istoplevel::Bool=false) =
     maybe_next_until!(frame -> is_call_or_return(pc_expr(frame)), recurse, frame, istoplevel)

src/interpret.jl

@@ -471,14 +471,6 @@ function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplev
                 end
                 isa(rhs, BreakpointRef) && return rhs
                 do_assignment!(frame, lhs, rhs)
-            elseif node.head === :gotoifnot
-                arg = @lookup(frame, node.args[1])
-                if !isa(arg, Bool)
-                    throw(TypeError(nameof(frame), "if", Bool, arg))
-                end
-                if !arg
-                    return (frame.pc = node.args[2]::Int)
-                end
             elseif node.head === :enter
                 rhs = node.args[1]::Int
                 push!(data.exception_frames, rhs)
@@ -499,8 +491,6 @@ function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplev
             elseif node.head === :pop_exception
                 # TODO: This needs to handle the exception stack properly
                 # (https://github.com/JuliaDebug/JuliaInterpreter.jl/issues/591)
-            elseif node.head === :return
-                return nothing
             elseif istoplevel
                 if node.head === :method && length(node.args) > 1
                     evaluate_methoddef(frame, node)
@@ -558,16 +548,15 @@ function step_expr!(@nospecialize(recurse), frame, @nospecialize(node), istoplev
             end
         elseif isa(node, GotoNode)
             return (frame.pc = node.label)
-        elseif is_GotoIfNot(node)
-            node = node::Core.GotoIfNot
+        elseif isa(node, GotoIfNot)
             arg = @lookup(frame, node.cond)
             if !isa(arg, Bool)
                 throw(TypeError(nameof(frame), "if", Bool, arg))
             end
             if !arg
                 return (frame.pc = node.dest)
             end
-        elseif is_ReturnNode(node)
+        elseif isa(node, ReturnNode)
             return nothing
         elseif isa(node, NewvarNode)
             # FIXME: undefine the slot?
@@ -647,11 +636,7 @@ function handle_err(@nospecialize(recurse), frame, err)
     return (frame.pc = data.exception_frames[end])
 end
 
-if isdefined(Core, :ReturnNode)
-    lookup_return(frame, node::Core.ReturnNode) = @lookup(frame, node.val)
-else
-    lookup_return(frame, node::Expr) = @lookup(frame, node.args[1])
-end
+lookup_return(frame, node::ReturnNode) = @lookup(frame, node.val)
 
 """
     ret = get_return(frame)

src/optimize.jl

@@ -56,20 +56,20 @@ function renumber_ssa!(stmts::Vector{Any}, ssalookup)
             stmts[i] = SSAValue(stmt.id)
         elseif isa(stmt, Expr)
             stmt = replace_ssa(stmt, ssalookup)
-            if (stmt.head === :gotoifnot || stmt.head === :enter) && isa(stmt.args[end], Int)
-                stmt.args[end] = jumplookup(ssalookup, stmt.args[end])
+            if stmt.head === :enter
+                stmt.args[end] = jumplookup(ssalookup, stmt.args[1]::Int)
             end
             stmts[i] = stmt
-        elseif is_GotoIfNot(stmt)
-            cond = (stmt::Core.GotoIfNot).cond
+        elseif isa(stmt, GotoIfNot)
+            cond = stmt.cond
             if isa(cond, SSAValue)
                 cond = SSAValue(ssalookup[cond.id])
             end
-            stmts[i] = Core.GotoIfNot(cond, jumplookup(ssalookup, stmt.dest))
-        elseif is_ReturnNode(stmt)
-            val = (stmt::Core.ReturnNode).val
+            stmts[i] = GotoIfNot(cond, jumplookup(ssalookup, stmt.dest))
+        elseif isa(stmt, ReturnNode)
+            val = stmt.val
             if isa(val, SSAValue)
-                stmts[i] = Core.ReturnNode(SSAValue(ssalookup[val.id]))
+                stmts[i] = ReturnNode(SSAValue(ssalookup[val.id]))
             end
         end
     end
@@ -394,19 +394,17 @@ function replace_coretypes_list!(list::AbstractVector; rev::Bool=false)
         rstmt = rep(stmt, rev)
         if rstmt !== stmt
             list[i] = rstmt
-        elseif is_GotoIfNot(stmt)
-            stmt = stmt::Core.GotoIfNot
+        elseif isa(stmt, GotoIfNot)
             cond = stmt.cond
             rcond = rep(cond, rev)
             if rcond !== cond
-                list[i] = Core.GotoIfNot(rcond, stmt.dest)
+                list[i] = GotoIfNot(rcond, stmt.dest)
             end
-        elseif is_ReturnNode(stmt)
-            stmt = stmt::Core.ReturnNode
+        elseif isa(stmt, ReturnNode)
             val = stmt.val
             rval = rep(val, rev)
             if rval !== val
-                list[i] = Core.ReturnNode(rval)
+                list[i] = ReturnNode(rval)
             end
         elseif isa(stmt, Expr)
             replace_coretypes!(stmt; rev=rev)

src/packagedef.jl

@@ -1,6 +1,6 @@
 using Base.Meta
 import Base: +, -, convert, isless, get_world_counter
-using Core: CodeInfo, SimpleVector, LineInfoNode, GotoNode,
+using Core: CodeInfo, SimpleVector, LineInfoNode, GotoNode, GotoIfNot, ReturnNode,
             GeneratedFunctionStub, MethodInstance, NewvarNode, TypeName
 
 using UUIDs

src/utils.jl

@@ -132,25 +132,7 @@ end
 
 isidentical(x) = Base.Fix2(===, x)   # recommended over isequal(::Symbol) since it cannot be invalidated
 
-# is_goto_node(@nospecialize(node)) = isa(node, GotoNode) || isexpr(node, :gotoifnot)
-
-if isdefined(Core, :GotoIfNot)
-    is_GotoIfNot(@nospecialize(node)) = isa(node, Core.GotoIfNot)
-    is_gotoifnot(@nospecialize(node)) = is_GotoIfNot(node)
-else
-    is_GotoIfNot(@nospecialize(node)) = false
-    is_gotoifnot(@nospecialize(node)) = isexpr(node, :gotoifnot)
-end
-
-if isdefined(Core, :ReturnNode)
-    is_ReturnNode(@nospecialize(node)) = isa(node, Core.ReturnNode)
-    is_return(@nospecialize(node)) = is_ReturnNode(node)
-    get_return_node(@nospecialize(node)) = (node::Core.ReturnNode).val
-else
-    is_ReturnNode(@nospecialize(node)) = false
-    is_return(@nospecialize(node)) = isexpr(node, :return)
-    get_return_node(@nospecialize(node)) = node.args[1]
-end
+is_return(@nospecialize(node)) = node isa ReturnNode
 
 is_loc_meta(@nospecialize(expr), @nospecialize(kind)) = isexpr(expr, :meta) && length(expr.args) >= 1 && expr.args[1] === kind
 
@@ -184,7 +166,7 @@ function is_call(@nospecialize(node))
         (isexpr(node, :(=)) && (isexpr(node.args[2], :call)))
 end
 
-is_call_or_return(@nospecialize(node)) = is_call(node) || is_return(node)
+is_call_or_return(@nospecialize(node)) = is_call(node) || node isa ReturnNode
 
 is_dummy(bpref::BreakpointRef) = bpref.stmtidx == 0 && bpref.err === nothing
 

test/core.jl

@@ -25,8 +25,8 @@ using Test
     end
 
     thunk = Meta.lower(Main, :(return 1+2))
-    stmt = thunk.args[1].code[end]   # the return
-    @test JuliaInterpreter.get_return_node(stmt) isa Core.SSAValue
+    stmt = thunk.args[1].code[end]::Core.ReturnNode   # the return
+    @test stmt.val isa Core.SSAValue
 
     @test string(JuliaInterpreter.parametric_type_to_expr(Base.Iterators.Stateful{String})) ∈
         ("Base.Iterators.Stateful{String, VS}", "(Base.Iterators).Stateful{String, VS}", "Base.Iterators.Stateful{String, VS, N}")

test/limits.jl

@@ -38,7 +38,7 @@ end
     @test Aborted(frame, i).at.line == 6
     # Check conditional
     frame = Frame(modexs[4]...)
-    i = findfirst(stmt->JuliaInterpreter.is_gotoifnot(stmt), frame.framecode.src.code) + 1
+    i = findfirst(stmt->isa(stmt, Core.GotoIfNot), frame.framecode.src.code) + 1
     @test Aborted(frame, i).at.line == 9
     # Check macro
     frame = Frame(modexs[5]...)