drop v1.9 support (#545)

* drop v1.9 support

* minor version bump

Author: aviatesk

.github/workflows/CI.yml

@@ -14,7 +14,7 @@ jobs:
       matrix:
         version:
           - '1'
-          - '1.9.0'
+          - '1.10.0'
           - 'nightly'
         os:
           - ubuntu-latest

Project.toml

@@ -1,7 +1,7 @@
 name = "Cthulhu"
 uuid = "f68482b8-f384-11e8-15f7-abe071a5a75f"
 authors = ["Valentin Churavy <v.churavy@gmail.com> and contributors"]
-version = "2.10.2"
+version = "2.11.0"
 
 [deps]
 CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2"
@@ -28,7 +28,7 @@ TypedSyntax = "1.2.2"
 UUIDs = "1.9"
 Unicode = "1.9"
 WidthLimitedIO = "1"
-julia = "1.9"
+julia = "1.10.0"
 
 [extras]
 DeepDiffs = "ab62b9b5-e342-54a8-a765-a90f495de1a6"

src/codeview.jl

@@ -22,41 +22,25 @@ end
 
 function cthulhu_llvm(io::IO, mi, optimize::Bool, debuginfo, world::UInt,
                       config::CthulhuConfig, dump_module::Bool=false, raw::Bool=false)
-    dump = @static if VERSION ≥ v"1.10.0-DEV.1386"
-        InteractiveUtils._dump_function_llvm(
-            mi, world,
-            #=wrapper=# false, !raw,
-            dump_module, optimize, debuginfo != DInfo.none ? :source : :none,
-            Base.CodegenParams())
-    else
-        InteractiveUtils._dump_function_linfo_llvm(
-            mi, world,
-            #=wrapper=# false, #=strip_ir_metadata=# true,
-            dump_module, optimize, debuginfo != DInfo.none ? :source : :none,
-            Base.CodegenParams())
-    end
+    dump = InteractiveUtils._dump_function_llvm(
+        mi, world,
+        #=wrapper=# false, !raw,
+        dump_module, optimize, debuginfo != DInfo.none ? :source : :none,
+        Base.CodegenParams())
     highlight(io, dump, "llvm", config)
 end
 
 function cthulhu_native(io::IO, mi, ::Bool, debuginfo, world::UInt,
                         config::CthulhuConfig, dump_module::Bool=false, raw::Bool=false)
-    dump = @static if VERSION ≥ v"1.10.0-DEV.1386"
-        if dump_module
-            InteractiveUtils._dump_function_native_assembly(
-                mi, world,
-                #=wrapper=# false, #=syntax=# config.asm_syntax,
-                debuginfo != DInfo.none ? :source : :none,
-                #=binary=# false, raw,
-                Base.CodegenParams())
-        else
-            InteractiveUtils._dump_function_native_disassembly(
-                mi, world,
-                #=wrapper=# false, #=syntax=# config.asm_syntax,
-                debuginfo != DInfo.none ? :source : :none,
-                #=binary=# false)
-        end
+    if dump_module
+        dump = InteractiveUtils._dump_function_native_assembly(
+            mi, world,
+            #=wrapper=# false, #=syntax=# config.asm_syntax,
+            debuginfo != DInfo.none ? :source : :none,
+            #=binary=# false, raw,
+            Base.CodegenParams())
     else
-        InteractiveUtils._dump_function_linfo_native(
+        dump = InteractiveUtils._dump_function_native_disassembly(
             mi, world,
             #=wrapper=# false, #=syntax=# config.asm_syntax,
             debuginfo != DInfo.none ? :source : :none,
@@ -221,10 +205,11 @@ function cthulhu_typed(io::IO, debuginfo::Symbol,
         end
         cst = Vector{Int}(undef, length(code))
         params = CC.OptimizationParams(interp)
+        sparams = CC.VarState[CC.VarState(sparam, false) for sparam in mi.sparam_vals]
         @static if VERSION ≥ v"1.11.0-DEV.32"
-            CC.statement_costs!(cst, code, src, sptypes(mi.sparam_vals), params)
+            CC.statement_costs!(cst, code, src, sparams, params)
         else
-            CC.statement_costs!(cst, code, src, sptypes(mi.sparam_vals), false, params)
+            CC.statement_costs!(cst, code, src, sparams, false, params)
         end
         total_cost = sum(cst)
         nd = ndigits(total_cost)
@@ -386,13 +371,6 @@ function add_callsites!(d::AbstractDict, visited_mis::AbstractSet, diagnostics::
     end
 end
 
-@static if VERSION >= v"1.10.0-DEV.552"
-    using Core.Compiler: VarState
-    sptypes(sparams) = VarState[VarState.(sparams, false)...]
-else
-    sptypes(sparams) = Any[sparams...]
-end
-
 function show_variables(io, src, slotnames)
     println(io, "Variables")
     slottypes = src.slottypes
@@ -465,12 +443,7 @@ function InteractiveUtils.code_typed(b::Bookmark; optimize::Bool=true)
     (; src, rt, codeinf) = lookup(interp, mi, optimize)
     src = preprocess_ci!(src, mi, optimize, CONFIG)
     if src isa IRCode
-        @static if VERSION ≥ v"1.10.0-DEV.870"
-            CC.replace_code_newstyle!(codeinf, src)
-        else
-            nargs = Int((mi.def::Method).nargs) - 1
-            CC.replace_code_newstyle!(codeinf, src, nargs)
-        end
+        CC.replace_code_newstyle!(codeinf, src)
     end
     return codeinf => rt
 end

src/interpreter.jl

@@ -1,8 +1,6 @@
 using .CC: AbstractInterpreter, NativeInterpreter, InferenceState, OptimizationState,
-    CodeInfo, CodeInstance, InferenceResult, WorldRange, WorldView, IRCode, SSAValue
-
-const CCCallInfo = CC.CallInfo
-const NoCallInfo = CC.NoCallInfo
+    CodeInfo, CodeInstance, InferenceResult, WorldRange, WorldView, IRCode, SSAValue,
+    CallInfo as CCCallInfo, NoCallInfo
 
 struct InferredSource
     src::CodeInfo
@@ -103,57 +101,8 @@ function CC.merge_effects!(interp::CthulhuInterpreter, sv::InferenceState, effec
     @invoke CC.merge_effects!(interp::AbstractInterpreter, sv::InferenceState, effects::Effects)
 end
 
-@static if VERSION ≤ v"1.10.0-DEV.221"
-function CC.type_annotate!(interp::CthulhuInterpreter, sv::InferenceState, run_optimizer::Bool)
-    changemap = @invoke CC.type_annotate!(interp::AbstractInterpreter, sv::InferenceState, run_optimizer::Bool)
-    changemap === nothing && return nothing
-    key = CC.any(sv.result.overridden_by_const) ? sv.result : sv.linfo
-    pc2remarks = get(interp.remarks, key, nothing)
-    if pc2remarks !== nothing
-        sort!(pc2remarks)
-        unique!(pc2remarks)
-        for (idx, v) in enumerate(changemap)
-            if v == typemin(Int)
-                for i = searchsorted(pc2remarks, idx=>"", by=((idx,msg),)->idx)
-                    @assert false "remarks found in unreached region"
-                end
-            end
-        end
-        for (idx, v) in enumerate(changemap)
-            if v < 0
-                for i = searchsorted(pc2remarks, idx=>"", by=((idx,msg),)->idx)
-                    pc2remarks[i] = pc2remarks[i].first+v => pc2remarks[i].second
-                end
-            end
-        end
-    end
-    pc2effects = get(interp.effects, key, nothing)
-    if pc2effects !== nothing
-        for (idx, v) in enumerate(changemap)
-            if v == typemin(Int)
-                delete!(pc2effects, idx)
-            end
-        end
-        for (idx, v) in enumerate(changemap)
-            if v < 0
-                haskey(pc2effects, idx) || continue
-                pc2effects[idx+v] = pc2effects[idx]
-                delete!(pc2effects, idx)
-            end
-        end
-    end
-    return changemap
-end
-end
-
 function InferredSource(state::InferenceState)
     unoptsrc = copy(state.src)
-    @static if VERSION < v"1.10.0-DEV.1033"
-        # xref: https://github.com/JuliaLang/julia/pull/49378
-        unoptsrc.slottypes = let slottypes = unoptsrc.slottypes
-            slottypes === nothing ? nothing : copy(slottypes)
-        end
-    end
     exct = @static VERSION ≥ v"1.11.0-DEV.207" ? state.result.exc_result : nothing
     return InferredSource(
         unoptsrc,
@@ -218,7 +167,6 @@ function CC.inlining_policy(interp::CthulhuInterpreter,
 end
 end
 
-@static if isdefined(CC, :AbsIntState)
 function CC.IRInterpretationState(interp::CthulhuInterpreter,
     code::CodeInstance, mi::MethodInstance, argtypes::Vector{Any}, world::UInt)
     inferred = @atomic :monotonic code.inferred
@@ -230,14 +178,6 @@ function CC.IRInterpretationState(interp::CthulhuInterpreter,
     return CC.IRInterpretationState(interp, method_info, ir, mi, argtypes, world,
                                     src.min_world, src.max_world)
 end
-else
-function CC.codeinst_to_ir(interp::CthulhuInterpreter, code::CodeInstance)
-    inferred = @atomic :monotonic code.inferred
-    inferred === nothing && return nothing
-    inferred = inferred::OptimizedSource
-    return CC.copy(inferred.ir)
-end
-end
 
 @static if VERSION ≥ v"1.11.0-DEV.737"
 function CC.finish!(interp::CthulhuInterpreter, caller::InferenceState)

src/reflection.jl

@@ -261,11 +261,7 @@ function preprocess_ci!(ci::CodeInfo, mi::MethodInstance, optimize, config::Cthu
         argtypes = CC.matching_cache_argtypes(mi, nothing, false)[1]
         ir = CC.inflate_ir(ci, sptypes_from_meth_instance(mi), argtypes)
         ir = dce!(ir)
-        @static if VERSION ≥ v"1.10.0-DEV.870"
-            ci = CC.replace_code_newstyle!(ci, ir)
-        else
-            ci = CC.replace_code_newstyle!(ci, ir, length(argtypes)-1)
-        end
+        ci = CC.replace_code_newstyle!(ci, ir)
     end
     return ci
 end
@@ -384,11 +380,7 @@ function truncate_if_defaultargs!(tsn, mappings, meth)
     return tsn, mappings
 end
 
-if isdefined(Core, :kwcall)
-    is_kw_dispatch(meth::Method) = meth.name == :kwcall || Base.unwrap_unionall(meth.sig).parameters[1] === typeof(Core.kwcall) || !isempty(Base.kwarg_decl(meth))
-else
-    is_kw_dispatch(meth::Method) = endswith(string(meth.name), "##kw") || !isempty(Base.kwarg_decl(meth))
-end
+is_kw_dispatch(meth::Method) = meth.name == :kwcall || Base.unwrap_unionall(meth.sig).parameters[1] === typeof(Core.kwcall) || !isempty(Base.kwarg_decl(meth))
 
 function tag_runtime(node::TypedSyntaxNode, info)
     node.runtime = isa(info, RTCallInfo)

test/irutils.jl

@@ -1,14 +1,10 @@
 using Core: CodeInfo, ReturnNode, MethodInstance
-using Core.Compiler: IRCode, IncrementalCompact, singleton_type, VarState
+using Core.Compiler: IRCode, IncrementalCompact, singleton_type
 using Base.Meta: isexpr
 using InteractiveUtils: gen_call_with_extracted_types_and_kwargs
 
 argextype(@nospecialize args...) = Core.Compiler.argextype(args...)
-@static if VERSION >= v"1.10.0-DEV.556"
-    argextype(@nospecialize(x), src::CodeInfo) = argextype(x, src, VarState[])
-else
-    argextype(@nospecialize(x), src::CodeInfo) = argextype(x, src, Any[])
-end
+argextype(@nospecialize(x), src::CodeInfo) = argextype(x, src, Core.Compiler.VarState[])
 code_typed1(args...; kwargs...) = first(only(code_typed(args...; kwargs...)))::CodeInfo
 macro code_typed1(ex0...)
     return gen_call_with_extracted_types_and_kwargs(__module__, :code_typed1, ex0)

test/setup.jl

@@ -26,9 +26,3 @@ end
 macro find_callsites_by_ftt(ex0...)
     return InteractiveUtils.gen_call_with_extracted_types_and_kwargs(__module__, :find_callsites_by_ftt, ex0)
 end
-
-@static if isdefined(Core.Compiler, :is_foldable_nothrow)
-    using Core.Compiler: is_foldable_nothrow
-else
-    const is_foldable_nothrow = Core.Compiler.is_total
-end

test/test_Cthulhu.jl

@@ -352,7 +352,7 @@ function bar346(x::ComplexF64)
     x = ComplexF64(x.re, 1.0)
     return sin(x.im)
 end
-@static VERSION >= v"1.10-" && @testset "issue #346" begin
+@testset "issue #346" begin
     let (; interp, src, infos, mi, slottypes) = cthulhu_info(bar346, Tuple{ComplexF64}; optimize=false)
         callsites, _ = Cthulhu.find_callsites(interp, src, infos, mi, slottypes, false)
         @test isa(callsites[1].info, Cthulhu.SemiConcreteCallInfo)
@@ -373,8 +373,8 @@ struct SingletonPureCallable{N} end
     @test occursin("SingletonPureCallable{1}()(::Float64)::Float64", s)
 
 
-    @test Cthulhu.get_effects(c1) |> is_foldable_nothrow
-    @test Cthulhu.get_effects(c2) |> is_foldable_nothrow
+    @test Cthulhu.get_effects(c1) |> Core.Compiler.is_foldable_nothrow
+    @test Cthulhu.get_effects(c2) |> Core.Compiler.is_foldable_nothrow
 end
 
 @testset "ReturnTypeCallInfo" begin
@@ -406,8 +406,8 @@ end
     print(io, callsites[2])
     @test occursin("return_type < only_ints(::Float64)::Union{} >", String(take!(io)))
 
-    @test Cthulhu.get_effects(callinfo1) |> is_foldable_nothrow
-    @test Cthulhu.get_effects(callinfo2) |> is_foldable_nothrow
+    @test Cthulhu.get_effects(callinfo1) |> Core.Compiler.is_foldable_nothrow
+    @test Cthulhu.get_effects(callinfo2) |> Core.Compiler.is_foldable_nothrow
 end
 
 @testset "OCCallInfo" begin
@@ -418,7 +418,7 @@ end
         @test length(callsites) == 1
         callinfo = only(callsites).info
         @test callinfo isa Cthulhu.OCCallInfo
-        @test Cthulhu.get_effects(callinfo) |> !is_foldable_nothrow
+        @test Cthulhu.get_effects(callinfo) |> !Core.Compiler.is_foldable_nothrow
         # TODO not sure what these effects are (and neither is Base.infer_effects yet)
         @test callinfo.ci.rt === Base.return_types((Int,Int)) do a, b
             sin(a) + cos(b)
@@ -476,7 +476,7 @@ invoke_constcall(a::Number, c::Bool) = c ? Number : :number
         callsite = only(callsites)
         info = callsite.info
         @test isa(info, Cthulhu.InvokeCallInfo)
-        @test Cthulhu.get_effects(info) |> is_foldable_nothrow
+        @test Cthulhu.get_effects(info) |> Core.Compiler.is_foldable_nothrow
         rt = Core.Compiler.Const(:Integer)
         @test info.ci.rt === rt
         buf = IOBuffer()
@@ -489,7 +489,7 @@ invoke_constcall(a::Number, c::Bool) = c ? Number : :number
         callsite = only(callsites)
         info = callsite.info
         @test isa(info, Cthulhu.InvokeCallInfo)
-        @test Cthulhu.get_effects(info) |> is_foldable_nothrow
+        @test Cthulhu.get_effects(info) |> Core.Compiler.is_foldable_nothrow
         @test info.ci.rt === Core.Compiler.Const(:Int)
     end
 
@@ -500,7 +500,7 @@ invoke_constcall(a::Number, c::Bool) = c ? Number : :number
         callsite = only(callsites)
         info = callsite.info
         @test isa(info, Cthulhu.InvokeCallInfo)
-        @test Cthulhu.get_effects(info) |> is_foldable_nothrow
+        @test Cthulhu.get_effects(info) |> Core.Compiler.is_foldable_nothrow
         inner = info.ci
         rt = Core.Compiler.Const(Any)
         @test Cthulhu.get_rt(info) === rt
@@ -1015,11 +1015,7 @@ end
 let (interp, mi) = Cthulhu.mkinterp((Int,)) do var::Int
         countvars50037(1, var)
     end
-    @static if VERSION ≥ v"1.10"
     key = only(Base.specializations(only(methods(countvars50037))))
-    else
-    key = only(methods(countvars50037)).specializations[1]
-    end
     codeinst = interp.opt[key]
     inferred = @atomic :monotonic codeinst.inferred
     @test length(inferred.ir.cfg.blocks) == 1