audit usages of Compiled

Author: aviatesk

src/commands.jl

@@ -6,7 +6,7 @@ Run `frame` until execution terminates. `pc` is either `nothing` (if execution t
 when it hits a `return` statement) or a reference to a breakpoint.
 In the latter case, `leaf(frame)` returns the frame in which it hit the breakpoint.
 
-`interp` controls call evaluation; `interp = Compiled()` evaluates :call expressions
+`interp` controls call evaluation; `interp = NonRecursiveInterpreter()` evaluates :call expressions
 by normal dispatch, whereas the default `interp = RecursiveInterpreter()` uses recursive interpretation.
 """
 function finish!(interp::Interpreter, frame::Frame, istoplevel::Bool=false)
@@ -252,7 +252,7 @@ function maybe_step_through_wrapper!(interp::Interpreter, frame::Frame)
             end
         end
         ret = @invoke evaluate_call!(BreakOnCall()::Interpreter, frame::Frame, last::Expr)
-        if !isa(ret, BreakpointRef) # Happens if next call is Compiled
+        if !isa(ret, BreakpointRef) # Happens if next call is compiled
             return frame
         end
         frame.framedata.ssavalues[frame.pc] = Wrapper()

src/construct.jl

@@ -15,20 +15,20 @@ for the generator itself, its framecode would be stored in [`framedict`](@ref).
 const genframedict = Dict{Tuple{Method,Type},FrameCode}() # the same for @generated functions
 
 """
-`meth ∈ compiled_methods` indicates that `meth` should be run using [`Compiled`](@ref)
+`meth ∈ compiled_methods` indicates that `meth` should be run using [`NonRecursiveInterpreter`](@ref)
 rather than recursed into via the interpreter.
 """
 const compiled_methods = Set{Method}()
 
 """
-`meth ∈ interpreted_methods` indicates that `meth` should *not* be run using [`Compiled`](@ref)
+`meth ∈ interpreted_methods` indicates that `meth` should *not* be run using [`NonRecursiveInterpreter`](@ref)
 and recursed into via the interpreter. This takes precedence over [`compiled_methods`](@ref) and
 [`compiled_modules`](@ref).
 """
 const interpreted_methods = Set{Method}()
 
 """
-`mod ∈ compiled_modules` indicates that any method in `mod` should be run using [`Compiled`](@ref)
+`mod ∈ compiled_modules` indicates that any method in `mod` should be run using [`NonRecursiveInterpreter`](@ref)
 rather than recursed into via the interpreter.
 """
 const compiled_modules = Set{Module}()

src/interpret.jl

@@ -224,7 +224,7 @@ function maybe_eval_with_scope(@nospecialize(f), fargs::Vector{Any}, frame::Fram
     return nothing
 end
 
-function evaluate_call!(interp::Compiled, frame::Frame, call_expr::Expr, enter_generated::Bool=false)
+function evaluate_call!(interp::NonRecursiveInterpreter, frame::Frame, call_expr::Expr, enter_generated::Bool=false)
     # @assert !enter_generated
     pc = frame.pc
     ret = bypass_builtins(interp, frame, call_expr, pc)
@@ -520,7 +520,7 @@ function step_expr!(interp::Interpreter, frame::Frame, @nospecialize(node), isto
                     end
                 elseif node.head === :thunk
                     newframe = Frame(moduleof(frame), node.args[1]::CodeInfo)
-                    if isa(interp, Compiled)
+                    if isa(interp, NonRecursiveInterpreter)
                         finish!(interp, newframe, true)
                     else
                         newframe.caller = frame
@@ -610,9 +610,9 @@ end
 Execute the next statement in `frame`. `pc` is the new program counter, or `nothing`
 if execution terminates, or a [`BreakpointRef`](@ref) if execution hits a breakpoint.
 
-`interp` controls call evaluation; `interp = Compiled()` evaluates :call expressions
-by normal dispatch. The default value `interp = RecursiveInterpreter()` will use recursive
-interpretation.
+`interp` controls call evaluation; `interp = NonRecursiveInterpreter()` evaluates :call
+expressions by normal dispatch.
+The default value `interp = RecursiveInterpreter()` will use recursive interpretation.
 
 If you are evaluating `frame` at module scope you should pass `istoplevel=true`.
 """

src/optimize.jl

@@ -181,7 +181,7 @@ function build_compiled_llvmcall!(stmt::Expr, code::CodeInfo, idx::Int, evalmod:
     frame.pc = idxstart
     if idxstart < idx
         while true
-            pc = step_expr!(Compiled(), frame)
+            pc = step_expr!(NonRecursiveInterpreter(), frame)
             pc === idx && break
             pc === nothing && error("this should never happen")
         end

src/packagedef.jl

@@ -10,8 +10,9 @@ using Random
 using Random.DSFMT
 using InteractiveUtils
 
-export BreakpointRef, Compiled, ExprSplitter, Frame, Interpreter, RecursiveInterpreter,
-       @bp, @breakpoint, @interpret,
+export BreakpointRef, Compiled, ExprSplitter, Frame,
+       Interpreter, NonRecursiveInterpreter, RecursiveInterpreter
+export @bp, @breakpoint, @interpret,
        break_off, break_on, breakpoint, breakpoints, debug_command, disable, enable, leaf,
        on_breakpoints_updated, remove, root, toggle
 

src/types.jl

@@ -29,6 +29,11 @@ compiler.
 """
 struct NonRecursiveInterpreter <: Interpreter end
 
+"""
+    const Compiled = NonRecursiveInterpreter
+
+See [`NonRecursiveInterpreter`](@ref) for the details.
+"""
 const Compiled = NonRecursiveInterpreter # for backward compatibility
 Base.similar(::Compiled, sz) = Compiled()  # to support similar(stack, 0)
 

test/interpret.jl

@@ -965,10 +965,10 @@ end
 @testset "changing interpreter for @interpret" begin
     @test sin(42) == @interpret sin(42)
     @test sin(42) == @interpret interp=RecursiveInterpreter() sin(42)
-    @test sin(42) == @interpret interp=Compiled() sin(42)
-    @test ((@allocated @interpret interp=RecursiveInterpreter() sin(42)) ≠ (@allocated @interpret interp=Compiled() sin(42)))
+    @test sin(42) == @interpret interp=NonRecursiveInterpreter() sin(42)
+    @test ((@allocated @interpret interp=RecursiveInterpreter() sin(42)) ≠ (@allocated @interpret interp=NonRecursiveInterpreter() sin(42)))
     let interp1 = RecursiveInterpreter(),
-        interp2 = Compiled()
+        interp2 = NonRecursiveInterpreter()
         @test sin(42) == @interpret interp=interp1 sin(42)
         @test sin(42) == @interpret interp=interp2 sin(42)
     end

test/interpret_scopedvalues.jl

@@ -33,7 +33,7 @@ let m = only(methods(_sval1_func2))
     end
 end
 let frame = JuliaInterpreter.enter_call(sval1_func2)
-    @test 2 == JuliaInterpreter.finish_and_return!(Compiled(), frame)
+    @test 2 == JuliaInterpreter.finish_and_return!(NonRecursiveInterpreter(), frame)
 end
 
 # preset `current_scope` support

test/utils.jl

@@ -23,7 +23,7 @@ function stacklength(frame)
 end
 
 # Execute a frame using Julia's regular compiled-code dispatch for any :call expressions
-runframe(frame) = Some{Any}(finish_and_return!(Compiled(), frame))
+runframe(frame) = Some{Any}(finish_and_return!(NonRecursiveInterpreter(), frame))
 
 # Execute a frame using the interpreter for all :call expressions (except builtins & intrinsics)
 runstack(frame) = Some{Any}(finish_and_return!(frame))
@@ -74,7 +74,7 @@ function evaluate_limited!(interp::Interpreter, frame::Frame, nstmts::Int, istop
         # _lnn_ = Aborted(frame, pc).at
         # _lnn_.file == Symbol("fake.jl") && _lnn_.line == 5 && isa(stmt, Core.GotoIfNot) && @show nstmts
         if isa(stmt, Expr)
-            if stmt.head === :call && !isa(interp, Compiled)
+            if stmt.head === :call && !isa(interp, NonRecursiveInterpreter)
                 limited_interp.nstmts = nstmts
                 try
                     rhs = evaluate_call!(limited_interp, frame, stmt)
@@ -86,7 +86,7 @@ function evaluate_limited!(interp::Interpreter, frame::Frame, nstmts::Int, istop
                     new_pc = handle_err(interp, frame, err)
                 end
                 nstmts = limited_interp.nstmts
-            elseif stmt.head === :(=) && isexpr(stmt.args[2], :call) && !isa(interp, Compiled)
+            elseif stmt.head === :(=) && isexpr(stmt.args[2], :call) && !isa(interp, NonRecursiveInterpreter)
                 limited_interp.nstmts = nstmts
                 try
                     rhs = evaluate_call!(limited_interp, frame, stmt.args[2])
@@ -105,7 +105,7 @@ function evaluate_limited!(interp::Interpreter, frame::Frame, nstmts::Int, istop
                 else
                     limited_interp.nstmts = nstmts
                     newframe = Frame(moduleof(frame), stmt)
-                    if isa(interp, Compiled)
+                    if isa(interp, NonRecursiveInterpreter)
                         finish!(interp, newframe, true)
                     else
                         newframe.caller = frame
@@ -161,7 +161,7 @@ end
 ### Functions needed on workers for running tests
 
 function configure_test()
-    # To run tests efficiently, certain methods must be run in Compiled mode,
+    # To run tests efficiently, certain methods must be run in the compiled mode,
     # in particular those that are used by the Test infrastructure
     cm = JuliaInterpreter.compiled_methods
     empty!(cm)
@@ -205,7 +205,7 @@ function run_test_by_eval(test, fullpath, nstmts)
             ret, nstmtsleft = evaluate_limited!(frame, nstmtsleft, true)
             if isa(ret, Aborted)
                 push!(aborts, ret)
-                JuliaInterpreter.finish_stack!(Compiled(), frame, true)
+                JuliaInterpreter.finish_stack!(NonRecursiveInterpreter(), frame, true)
             end
         end
         println("Finished ", $test)