Make Compiler tests runnable as package (#56632)

Makes `test Compiler` work properly (as in use the Compiler package, not
Base.Compiler) and pass tests, but still needs to be made parallel in a
follow-on.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>

Author: 3 people

Compiler/Project.toml

@@ -4,3 +4,12 @@ version = "0.0.2"
 
 [compat]
 julia = "1.10"
+
+[extras]
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
+
+[targets]
+test = ["Test", "InteractiveUtils", "Random", "Libdl"]

Compiler/test/AbstractInterpreter.jl

@@ -2,27 +2,34 @@ module EAUtils
 
 export code_escapes, @code_escapes, __clear_cache!
 
-const CC = Core.Compiler
+if !@isdefined(Compiler)
+    if Base.identify_package("Compiler") === nothing
+        import Base.Compiler: Compiler
+    else
+        import Compiler
+    end
+end
+
 using ..EscapeAnalysis
 const EA = EscapeAnalysis
 
 # AbstractInterpreter
 # -------------------
 
 # imports
-import .CC:
+import .Compiler:
     AbstractInterpreter, NativeInterpreter, WorldView, WorldRange, InferenceParams,
     OptimizationParams, get_world_counter, get_inference_cache, ipo_dataflow_analysis!
 # usings
 using Core:
     CodeInstance, MethodInstance, CodeInfo
-using .CC:
+using .Compiler:
     InferenceResult, InferenceState, OptimizationState, IRCode
 using .EA: analyze_escapes, ArgEscapeCache, ArgEscapeInfo, EscapeInfo, EscapeState
 
 struct EAToken end
 
-# when working outside of Core.Compiler,
+# when working outside of CC,
 # cache entire escape state for later inspection and debugging
 struct EscapeCacheInfo
     argescapes::ArgEscapeCache
@@ -59,18 +66,18 @@ mutable struct EscapeAnalyzer <: AbstractInterpreter
     end
 end
 
-CC.InferenceParams(interp::EscapeAnalyzer) = interp.inf_params
-CC.OptimizationParams(interp::EscapeAnalyzer) = interp.opt_params
-CC.get_inference_world(interp::EscapeAnalyzer) = interp.world
-CC.get_inference_cache(interp::EscapeAnalyzer) = interp.inf_cache
-CC.cache_owner(::EscapeAnalyzer) = EAToken()
-CC.get_escape_cache(interp::EscapeAnalyzer) = GetEscapeCache(interp)
+Compiler.InferenceParams(interp::EscapeAnalyzer) = interp.inf_params
+Compiler.OptimizationParams(interp::EscapeAnalyzer) = interp.opt_params
+Compiler.get_inference_world(interp::EscapeAnalyzer) = interp.world
+Compiler.get_inference_cache(interp::EscapeAnalyzer) = interp.inf_cache
+Compiler.cache_owner(::EscapeAnalyzer) = EAToken()
+Compiler.get_escape_cache(interp::EscapeAnalyzer) = GetEscapeCache(interp)
 
-function CC.ipo_dataflow_analysis!(interp::EscapeAnalyzer, opt::OptimizationState,
+function Compiler.ipo_dataflow_analysis!(interp::EscapeAnalyzer, opt::OptimizationState,
                                    ir::IRCode, caller::InferenceResult)
     # run EA on all frames that have been optimized
     nargs = Int(opt.src.nargs)
-    𝕃ₒ = CC.optimizer_lattice(interp)
+    𝕃ₒ = Compiler.optimizer_lattice(interp)
     get_escape_cache = GetEscapeCache(interp)
     estate = try
         analyze_escapes(ir, nargs, 𝕃ₒ, get_escape_cache)
@@ -82,19 +89,19 @@ function CC.ipo_dataflow_analysis!(interp::EscapeAnalyzer, opt::OptimizationStat
     end
     if caller.linfo === interp.entry_mi
         # return back the result
-        interp.result = EscapeResultForEntry(CC.copy(ir), estate, caller.linfo)
+        interp.result = EscapeResultForEntry(Compiler.copy(ir), estate, caller.linfo)
     end
     record_escapes!(interp, caller, estate, ir)
 
-    @invoke CC.ipo_dataflow_analysis!(interp::AbstractInterpreter, opt::OptimizationState,
+    @invoke Compiler.ipo_dataflow_analysis!(interp::AbstractInterpreter, opt::OptimizationState,
                                       ir::IRCode, caller::InferenceResult)
 end
 
 function record_escapes!(interp::EscapeAnalyzer,
     caller::InferenceResult, estate::EscapeState, ir::IRCode)
     argescapes = ArgEscapeCache(estate)
     ecacheinfo = EscapeCacheInfo(argescapes, estate, ir)
-    return CC.stack_analysis_result!(caller, ecacheinfo)
+    return Compiler.stack_analysis_result!(caller, ecacheinfo)
 end
 
 struct GetEscapeCache
@@ -113,19 +120,19 @@ struct FailedAnalysis
     get_escape_cache::GetEscapeCache
 end
 
-function CC.finish!(interp::EscapeAnalyzer, state::InferenceState; can_discard_trees::Bool=CC.may_discard_trees(interp))
-    ecacheinfo = CC.traverse_analysis_results(state.result) do @nospecialize result
+function Compiler.finish!(interp::EscapeAnalyzer, state::InferenceState; can_discard_trees::Bool=Compiler.may_discard_trees(interp))
+    ecacheinfo = Compiler.traverse_analysis_results(state.result) do @nospecialize result
         return result isa EscapeCacheInfo ? result : nothing
     end
     ecacheinfo isa EscapeCacheInfo && (interp.escape_cache.cache[state.linfo] = ecacheinfo)
-    return @invoke CC.finish!(interp::AbstractInterpreter, state::InferenceState; can_discard_trees)
+    return @invoke Compiler.finish!(interp::AbstractInterpreter, state::InferenceState; can_discard_trees)
 end
 
 # printing
 # --------
 
 using Core: Argument, SSAValue
-using .CC: widenconst, singleton_type
+using .Compiler: widenconst, singleton_type
 
 function get_name_color(x::EscapeInfo, symbol::Bool = false)
     getname(x) = string(nameof(x))
@@ -323,15 +330,15 @@ function code_escapes(@nospecialize(f), @nospecialize(types=Base.default_tt(f));
                       debuginfo::Symbol = :none)
     tt = Base.signature_type(f, types)
     match = Base._which(tt; world, raise=true)
-    mi = Core.Compiler.specialize_method(match)
+    mi = Compiler.specialize_method(match)
     return code_escapes(mi; world, debuginfo)
 end
 
 function code_escapes(mi::MethodInstance;
                       world::UInt = get_world_counter(),
                       interp::EscapeAnalyzer=EscapeAnalyzer(world, GLOBAL_ESCAPE_CACHE; entry_mi=mi),
                       debuginfo::Symbol = :none)
-    frame = Core.Compiler.typeinf_frame(interp, mi, #=run_optimizer=#true)
+    frame = Compiler.typeinf_frame(interp, mi, #=run_optimizer=#true)
     isdefined(interp, :result) || error("optimization didn't happen: maybe everything has been constant folded?")
     slotnames = let src = frame.src
         src isa CodeInfo ? src.slotnames : nothing
@@ -357,7 +364,7 @@ Note that this version does not cache the analysis results.
 function code_escapes(ir::IRCode, nargs::Int;
                       world::UInt = get_world_counter(),
                       interp::AbstractInterpreter=EscapeAnalyzer(world, EscapeCache()))
-    estate = analyze_escapes(ir, nargs, CC.optimizer_lattice(interp), CC.get_escape_cache(interp))
+    estate = analyze_escapes(ir, nargs, Compiler.optimizer_lattice(interp), Compiler.get_escape_cache(interp))
     return EscapeResult(ir, estate) # return back the result
 end
 

Compiler/test/EAUtils.jl

@@ -1,15 +1,10 @@
 module test_EA
 
-global use_core_compiler::Bool = true
+include("irutils.jl")
 
-if use_core_compiler
-    const EscapeAnalysis = Core.Compiler.EscapeAnalysis
-else
-    include(normpath(Sys.BINDIR, "..", "..", "Compiler", "src", "ssair", "EscapeAnalysis.jl"))
-end
+const EscapeAnalysis = Compiler.EscapeAnalysis
 
 include("EAUtils.jl")
-include("irutils.jl")
 
 using Test, .EscapeAnalysis, .EAUtils
 using .EscapeAnalysis: ignore_argescape

Compiler/test/EscapeAnalysis.jl

@@ -6,6 +6,14 @@ using Random
 using InteractiveUtils
 using Libdl
 
+if !@isdefined(Compiler)
+    if Base.identify_package("Compiler") === nothing
+        import Base.Compiler: Compiler
+    else
+        import Compiler
+    end
+end
+
 const opt_level = Base.JLOptions().opt_level
 const coverage = (Base.JLOptions().code_coverage > 0) || (Base.JLOptions().malloc_log > 0)
 const Iptr = sizeof(Int) == 8 ? "i64" : "i32"
@@ -181,15 +189,15 @@ end
 breakpoint_mutable(a::MutableStruct) = ccall(:jl_breakpoint, Cvoid, (Ref{MutableStruct},), a)
 
 # Allocation with uninitialized field as gcroot
-mutable struct BadRef
+mutable struct BadRefMutableStruct
     x::MutableStruct
     y::MutableStruct
-    BadRef(x) = new(x)
+    BadRefMutableStruct(x) = new(x)
 end
-Base.cconvert(::Type{Ptr{BadRef}}, a::MutableStruct) = BadRef(a)
-Base.unsafe_convert(::Type{Ptr{BadRef}}, ar::BadRef) = Ptr{BadRef}(pointer_from_objref(ar.x))
+Base.cconvert(::Type{Ptr{BadRefMutableStruct}}, a::MutableStruct) = BadRefMutableStruct(a)
+Base.unsafe_convert(::Type{Ptr{BadRefMutableStruct}}, ar::BadRefMutableStruct) = Ptr{BadRefMutableStruct}(pointer_from_objref(ar.x))
 
-breakpoint_badref(a::MutableStruct) = ccall(:jl_breakpoint, Cvoid, (Ptr{BadRef},), a)
+breakpoint_badref(a::MutableStruct) = ccall(:jl_breakpoint, Cvoid, (Ptr{BadRefMutableStruct},), a)
 
 struct PtrStruct
     a::Ptr{Cvoid}
@@ -372,10 +380,9 @@ mktemp() do f_22330, _
 end
 
 # Alias scope
-using Base.Experimental: @aliasscope, Const
 function foo31018!(a, b)
-    @aliasscope for i in eachindex(a, b)
-        a[i] = Const(b)[i]
+    @Base.Experimental.aliasscope for i in eachindex(a, b)
+        a[i] = Base.Experimental.Const(b)[i]
     end
 end
 io = IOBuffer()
@@ -788,8 +795,8 @@ f47247(a::Ref{Int}, b::Nothing) = setfield!(a, :x, b)
 @test_throws TypeError f47247(Ref(5), nothing)
 
 f48085(@nospecialize x...) = length(x)
-@test Core.Compiler.get_compileable_sig(which(f48085, (Vararg{Any},)), Tuple{typeof(f48085), Vararg{Int}}, Core.svec()) === nothing
-@test Core.Compiler.get_compileable_sig(which(f48085, (Vararg{Any},)), Tuple{typeof(f48085), Int, Vararg{Int}}, Core.svec()) === Tuple{typeof(f48085), Any, Vararg{Any}}
+@test Compiler.get_compileable_sig(which(f48085, (Vararg{Any},)), Tuple{typeof(f48085), Vararg{Int}}, Core.svec()) === nothing
+@test Compiler.get_compileable_sig(which(f48085, (Vararg{Any},)), Tuple{typeof(f48085), Int, Vararg{Int}}, Core.svec()) === Tuple{typeof(f48085), Any, Vararg{Any}}
 
 # Make sure that the bounds check is elided in tuple iteration
 @test !occursin("call void @", strip_debug_calls(get_llvm(iterate, Tuple{NTuple{4, Float64}, Int})))

Compiler/test/codegen.jl

@@ -1,4 +1,12 @@
-using Core.Compiler: IncrementalCompact, insert_node_here!, finish,
+if !@isdefined(Compiler)
+    if Base.identify_package("Compiler") === nothing
+        import Base.Compiler: Compiler
+    else
+        import Compiler
+    end
+end
+
+using .Compiler: IncrementalCompact, insert_node_here!, finish,
     NewInstruction, verify_ir, ReturnNode, SSAValue
 
 foo_test_function(i) = i == 1 ? 1 : 2
@@ -8,19 +16,19 @@ foo_test_function(i) = i == 1 ? 1 : 2
     compact = IncrementalCompact(ir)
 
     # set up first iterator
-    x = Core.Compiler.iterate(compact)
-    x = Core.Compiler.iterate(compact, x[2])
+    x = Compiler.iterate(compact)
+    x = Compiler.iterate(compact, x[2])
 
     # set up second iterator
-    x = Core.Compiler.iterate(compact)
+    x = Compiler.iterate(compact)
 
     # consume remainder
     while x !== nothing
-        x = Core.Compiler.iterate(compact, x[2])
+        x = Compiler.iterate(compact, x[2])
     end
 
     ir = finish(compact)
-    @test Core.Compiler.verify_ir(ir) === nothing
+    @test Compiler.verify_ir(ir) === nothing
 end
 
 # Test early finish of IncrementalCompact
@@ -40,7 +48,7 @@ end
 @testset "IncrementalCompact reverse affinity insert" begin
     ir = only(Base.code_ircode(foo_test_function, (Int,)))[1]
     compact = IncrementalCompact(ir)
-    @test !Core.Compiler.did_just_finish_bb(compact)
+    @test !Compiler.did_just_finish_bb(compact)
 
     insert_node_here!(compact, NewInstruction(ReturnNode(1), Union{}, ir[SSAValue(1)][:line]), true)
     new_ir = finish(compact)

Compiler/test/compact.jl

@@ -3,6 +3,14 @@
 # N.B.: This file is also run from interpreter.jl, so needs to be standalone-executable
 using Test
 
+if !@isdefined(Compiler)
+    if Base.identify_package("Compiler") === nothing
+        import Base.Compiler: Compiler
+    else
+        import Compiler
+    end
+end
+
 # Cassette
 # ========
 
@@ -11,7 +19,8 @@ module MiniCassette
     # fancy features, but sufficient to exercise this code path in the compiler.
 
     using Core.IR
-    using Core.Compiler: retrieve_code_info, quoted, anymap
+    using ..Compiler
+    using ..Compiler: retrieve_code_info, quoted, anymap
     using Base.Meta: isexpr
 
     export Ctx, overdub
@@ -45,7 +54,7 @@ module MiniCassette
 
     function transform!(mi::MethodInstance, ci::CodeInfo, nargs::Int, sparams::Core.SimpleVector)
         code = ci.code
-        di = Core.Compiler.DebugInfoStream(mi, ci.debuginfo, length(code))
+        di = Compiler.DebugInfoStream(mi, ci.debuginfo, length(code))
         ci.slotnames = Symbol[Symbol("#self#"), :ctx, :f, :args, ci.slotnames[nargs+1:end]...]
         ci.slotflags = UInt8[(0x00 for i = 1:4)..., ci.slotflags[nargs+1:end]...]
         # Insert one SSAValue for every argument statement
@@ -82,7 +91,7 @@ module MiniCassette
 
         tt = Tuple{f, args...}
         match = Base._which(tt; world)
-        mi = Core.Compiler.specialize_method(match)
+        mi = Base.specialize_method(match)
         # Unsupported in this mini-cassette
         @assert !mi.def.isva
         src = retrieve_code_info(mi, world)