adjust to the latest compiler changes (#264)

Author: aviatesk

.github/workflows/CI.yml

@@ -17,13 +17,12 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '^1.10.0-0'
+          - '1.10'
           - 'nightly'
         os:
           - ubuntu-latest
           - macOS-latest
-          # FIXME
-          # - windows-latest
+          # FIXME - windows-latest
         arch:
           - x64
         include:

src/Diffractor.jl

@@ -9,6 +9,13 @@ const CC = Core.Compiler
 
 const GENERATORS = Expr[]
 
+@static if VERSION ≥ v"1.11.0-DEV.1498"
+    import .CC: get_inference_world
+    using Base: get_world_counter
+else
+    import .CC: get_world_counter, get_world_counter as get_inference_world
+end
+
 @recompile_invalidations begin
     include("runtime.jl")
     include("interface.jl")

src/codegen/forward_demand.jl

@@ -352,11 +352,11 @@ function forward_diff!(interp::ADInterpreter, ir::IRCode, src::CodeInfo, mi::Met
 
     method_info = CC.MethodInfo(src)
     argtypes = ir.argtypes[1:mi.def.nargs]
-    world = CC.get_world_counter(interp)
+    world = get_inference_world(interp)
     irsv = IRInterpretationState(interp, method_info, ir, mi, argtypes, world, src.min_world, src.max_world)
     rt = CC._ir_abstract_constant_propagation(interp, irsv)
 
     ir = compact!(ir)
-    
+
     return ir
 end

src/debugutils.jl

@@ -2,7 +2,7 @@ using Core.Compiler: AbstractInterpreter, CodeInstance, MethodInstance, WorldVie
 using InteractiveUtils
 
 function infer_function(interp, tt)
-    world = Core.Compiler.get_world_counter()
+    world = get_world_counter()
 
     # Find all methods that are applicable to these types
     mthds = _methods_by_ftype(tt, -1, world)
@@ -43,12 +43,12 @@ ExtractingInterpreter(;optimize=false) = ExtractingInterpreter(
     optimize
 )
 
-import Core.Compiler: InferenceParams, OptimizationParams, get_world_counter,
+import Core.Compiler: InferenceParams, OptimizationParams, #=get_inference_world,=#
     get_inference_cache, code_cache,
     WorldView, lock_mi_inference, unlock_mi_inference, InferenceState
 InferenceParams(ei::ExtractingInterpreter) = InferenceParams(ei.native_interpreter)
 OptimizationParams(ei::ExtractingInterpreter) = OptimizationParams(ei.native_interpreter)
-get_world_counter(ei::ExtractingInterpreter) = get_world_counter(ei.native_interpreter)
+get_inference_world(ei::ExtractingInterpreter) = get_inference_world(ei.native_interpreter)
 get_inference_cache(ei::ExtractingInterpreter) = get_inference_cache(ei.native_interpreter)
 
 # No need to do any locking since we're not putting our results into the runtime cache

src/stage1/termination.jl

@@ -44,7 +44,7 @@ which(Tuple{∂⃖{N}, ∂⃖{1}, Vararg{Any}} where {N}).recursion_relation = f
            isa(Base.unwrap_unionall(new_sig.parameters[1].parameters[1]), Int)
 end
 
-for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆recurse{N}, Vararg{Any}} where {N}, nothing, -1, Base.get_world_counter())
+for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆recurse{N}, Vararg{Any}} where {N}, nothing, -1, get_world_counter())
     method.recursion_relation = function (method1, method2, parent_sig, new_sig)
         # Recursion from a higher to a lower order is always allowed
         parent_order = parent_sig.parameters[1].parameters[1]
@@ -57,13 +57,13 @@ for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆recurse{N}, Varar
     end
 end
 
-for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆internal{N}, Vararg{Any}} where {N}, nothing, -1, Base.get_world_counter())
+for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆internal{N}, Vararg{Any}} where {N}, nothing, -1, get_world_counter())
     method.recursion_relation = function (method1, method2, parent_sig, new_sig)
         return true
     end
 end
 
-for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆{N}, Vararg{Any}} where {N}, nothing, -1, Base.get_world_counter())
+for (;method) in Base._methods_by_ftype(Tuple{Diffractor.∂☆{N}, Vararg{Any}} where {N}, nothing, -1, get_world_counter())
     method.recursion_relation = function (method1, method2, parent_sig, new_sig)
         return true
     end

src/stage2/interpreter.jl

@@ -253,7 +253,7 @@ end
 
 CC.InferenceParams(ei::ADInterpreter) = InferenceParams(ei.native_interpreter)
 CC.OptimizationParams(ei::ADInterpreter) = OptimizationParams(ei.native_interpreter)
-CC.get_world_counter(ei::ADInterpreter) = get_world_counter(ei.native_interpreter)
+#=CC.=#get_inference_world(ei::ADInterpreter) = get_inference_world(ei.native_interpreter)
 CC.get_inference_cache(ei::ADInterpreter) = get_inference_cache(ei.native_interpreter)
 
 # No need to do any locking since we're not putting our results into the runtime cache
@@ -325,15 +325,6 @@ function CC.inlining_policy(interp::ADInterpreter,
         mi::MethodInstance, argtypes::Vector{Any})
 end
 
-# TODO remove this overload once https://github.com/JuliaLang/julia/pull/49191 gets merged
-function CC.abstract_call_gf_by_type(interp::ADInterpreter, @nospecialize(f),
-    arginfo::ArgInfo, si::StmtInfo, @nospecialize(atype),
-    sv::IRInterpretationState, max_methods::Int)
-    return @invoke CC.abstract_call_gf_by_type(interp::AbstractInterpreter, f::Any,
-        arginfo::ArgInfo, si::StmtInfo, atype::Any,
-        sv::CC.AbsIntState, max_methods::Int)
-end
-
 #=
 function CC.optimize(interp::ADInterpreter, opt::OptimizationState,
     params::OptimizationParams, caller::InferenceResult)
@@ -362,6 +353,17 @@ else
 CC.finish!(::ADInterpreter, caller::InferenceResult) = _finish!(caller)
 end
 
+@static if VERSION ≥ v"1.11.0-DEV.1278"
+function CC.bail_out_const_call(interp::ADInterpreter, result::CC.MethodCallResult,
+                                si::StmtInfo, sv::CC.AbsIntState)
+    if result.rt isa CC.LimitedAccuracy
+        return false
+    end
+    return @invoke CC.bail_out_const_call(interp::AbstractInterpreter, result::CC.MethodCallResult,
+                                          si::StmtInfo, sv::CC.AbsIntState)
+end
+end
+
 function ir2codeinst(ir::IRCode, inst::CodeInstance, ci::CodeInfo)
     CodeInstance(inst.def, inst.rettype, isdefined(inst, :rettype_const) ? inst.rettype_const : nothing,
                  Cthulhu.OptimizedSource(CC.copy(ir), ci, inst.inferred.isinlineable, CC.decode_effects(inst.purity_bits)),