update to avi/typelattice, incoming type lattice overhaul

Author: aviatesk

src/Cthulhu.jl

@@ -7,10 +7,12 @@ using InteractiveUtils
 using UUIDs
 using REPL: REPL, AbstractTerminal
 
-using Core: MethodInstance
+import Core: MethodInstance, OpaqueClosure
 const Compiler = Core.Compiler
-using Core.Compiler: MethodMatch, LimitedAccuracy, ignorelimited
+import Core.Compiler: MethodMatch, LimitedAccuracy, widenconst, ignorelimited, Const,
+                      PartialStruct, InterConditional, PartialOpaque
 import Base: unwrapva, isvarargtype
+
 const mapany = Base.mapany
 
 # branch on https://github.com/JuliaLang/julia/pull/42125
@@ -21,6 +23,15 @@ else
     macro constprop(_, ex); esc(ex); end
 end
 
+const IS_OVERHAULED = isdefined(Core.Compiler, :LatticeElement)
+@static if IS_OVERHAULED
+    import Core.Compiler: ⊤, ⊥, LatticeElement, NativeType, LatticeElement, isConst,
+                          isLimitedAccuracy, Argtypes, SSAValueTypes
+else
+    const Argtypes = Vector{Any}
+    const SSAValueTypes = Vector{Any}
+end
+
 Base.@kwdef mutable struct CthulhuConfig
     enable_highlighter::Bool = false
     highlighter::Cmd = `pygmentize -l`
@@ -167,15 +178,36 @@ const descend = descend_code_typed
 
 descend(interp::CthulhuInterpreter, mi::MethodInstance; kwargs...) = _descend(interp, mi; iswarn=false, interruptexc=false, kwargs...)
 
+@static if IS_OVERHAULED
+import Core.Compiler: ConditionalInfo
 function codeinst_rt(code::CodeInstance)
     rettype = code.rettype
     if isdefined(code, :rettype_const)
         rettype_const = code.rettype_const
         if isa(rettype_const, Vector{Any}) && !(Vector{Any} <: rettype)
-            return Core.PartialStruct(rettype, rettype_const)
-        elseif isa(rettype_const, Core.PartialOpaque) && rettype <: Core.OpaqueClosure
+            return PartialStruct(rettype, rettype_const)
+        elseif isa(rettype_const, PartialOpaque) && rettype <: OpaqueClosure
             return rettype_const
-        elseif isa(rettype_const, Core.InterConditional) && !(Core.InterConditional <: rettype)
+        elseif isa(rettype_const, ConditionalInfo) && !(ConditionalInfo <: rettype)
+            @assert rettype_const.inter
+            return InterConditional(rettype_const.slot_id, rettype_const.vtype, rettype_const.elsetype), mi
+        else
+            return Const(rettype_const)
+        end
+    else
+        return rettype
+    end
+end
+else # @static if IS_OVERHAULED
+function codeinst_rt(code::CodeInstance)
+    rettype = code.rettype
+    if isdefined(code, :rettype_const)
+        rettype_const = code.rettype_const
+        if isa(rettype_const, Vector{Any}) && !(Vector{Any} <: rettype)
+            return PartialStruct(rettype, rettype_const)
+        elseif isa(rettype_const, PartialOpaque) && rettype <: OpaqueClosure
+            return rettype_const
+        elseif isa(rettype_const, InterConditional) && !(InterConditional <: rettype)
             return rettype_const
         else
             return Const(rettype_const)
@@ -184,6 +216,7 @@ function codeinst_rt(code::CodeInstance)
         return rettype
     end
 end
+end # @static if IS_OVERHAULED
 
 # `@constprop :aggressive` here in order to make sure the constant propagation of `allow_no_codeinf`
 @constprop :aggressive function lookup(interp::CthulhuInterpreter, mi::MethodInstance, optimize::Bool; allow_no_codeinf::Bool=false)
@@ -193,7 +226,11 @@ end
         infos = interp.unopt[mi].stmt_infos
         slottypes = codeinf.slottypes
         if isnothing(slottypes)
-            slottypes = Any[ Any for i = 1:length(codeinf.slotflags) ]
+            @static if IS_OVERHAULED
+                slottypes = LatticeElement[ ⊤ for i = 1:length(codeinf.slotflags) ]
+            else
+                slottypes = Any[ Any for i = 1:length(codeinf.slotflags) ]
+            end
         end
     else
         codeinst = interp.opt[mi]
@@ -209,7 +246,11 @@ end
             # But with coverage on, the empty function body isn't empty due to :code_coverage_effect expressions.
             codeinf = nothing
             infos = []
-            slottypes = Any[Base.unwrap_unionall(mi.specTypes).parameters...]
+            @static if IS_OVERHAULED
+                slottypes = AbstractLatticce[NativeType(t) for t in Base.unwrap_unionall(mi.specTypes).parameters]
+            else
+                slottypes = Any[Base.unwrap_unionall(mi.specTypes).parameters...]
+            end
         else
             Core.eval(Main, quote
                 interp = $interp
@@ -219,7 +260,7 @@ end
             error("couldn't find the source; inspect `Main.interp` and `Main.mi`")
         end
     end
-    (codeinf, rt, infos, slottypes::Vector{Any})
+    return codeinf, rt, infos, slottypes::Argtypes
 end
 
 ##

src/callsite.jl

@@ -7,7 +7,7 @@ struct MICallInfo <: CallInfo
     mi::MethodInstance
     rt
     function MICallInfo(mi::MethodInstance, @nospecialize(rt))
-        if isa(rt, LimitedAccuracy)
+        if @static IS_OVERHAULED ? isLimitedAccuracy(rt) : isa(rt, LimitedAccuracy)
             return LimitedCallInfo(new(mi, ignorelimited(rt)))
         else
             return new(mi, rt)
@@ -36,9 +36,9 @@ struct UncachedCallInfo <: WrappedCallInfo
 end
 
 struct PureCallInfo <: CallInfo
-    argtypes::Vector{Any}
+    argtypes::Argtypes
     rt
-    PureCallInfo(argtypes::Vector{Any}, @nospecialize(rt)) =
+    PureCallInfo(argtypes::Argtypes, @nospecialize(rt)) =
         new(argtypes, rt)
 end
 get_mi(::PureCallInfo) = nothing
@@ -239,7 +239,7 @@ end
 function show_callinfo(limiter, ci::Union{MultiCallInfo, FailedCallInfo, GeneratedCallInfo})
     types = (ci.sig::DataType).parameters
     ft, tt... = types
-    f = Compiler.singleton_type(ft)
+    f = Compiler.singleton_type((@static IS_OVERHAULED ? LatticeElement : identity)(ft))
     if f !== nothing
         name = "→ $f"
     elseif ft isa Union

src/codeview.jl

@@ -119,7 +119,11 @@ function cthulhu_typed(io::IO, debuginfo::Symbol,
     if isa(src, Core.CodeInfo)
         # we're working on pre-optimization state, need to ignore `LimitedAccuracy`
         src = copy(src)
-        src.ssavaluetypes = Base.mapany(ignorelimited, src.ssavaluetypes::Vector{Any})
+        @static if IS_OVERHAULED
+            src.ssavaluetypes = SSAValueTypes([ignorelimited(t) for t in src.ssavaluetypes::SSAValueTypes])
+        else
+            src.ssavaluetypes = Base.mapany(ignorelimited, src.ssavaluetypes::SSAValueTypes)
+        end
         src.rettype = ignorelimited(src.rettype)
 
         if src.slotnames !== nothing
@@ -144,8 +148,9 @@ function cthulhu_typed(io::IO, debuginfo::Symbol,
         isa(mi, MethodInstance) || throw("`mi::MethodInstance` is required")
         code = src isa IRCode ? src.stmts.inst : src.code
         cst = Vector{Int}(undef, length(code))
+        sptypes = Core.Compiler.sptypes_from_meth_instance(mi)
         params = Core.Compiler.OptimizationParams(Core.Compiler.NativeInterpreter())
-        maxcost = Core.Compiler.statement_costs!(cst, code, src, Any[mi.sparam_vals...], false, params)
+        maxcost = Core.Compiler.statement_costs!(cst, code, src, sptypes, false, params)
         nd = ndigits(maxcost)
         _lineprinter = lineprinter(src)
         function preprinter(io, linestart, idx)
@@ -195,8 +200,9 @@ function show_variables(io, src, slotnames)
     slottypes = src.slottypes
     for i = 1:length(slotnames)
         print(io, "  ", slotnames[i])
-        if isa(slottypes, Vector{Any})
-            InteractiveUtils.warntype_type_printer(io, slottypes[i], true)
+        if isa(slottypes, Argtypes)
+            typ = (@static IS_OVERHAULED ? Core.Compiler.unwraptype : identity)(slottypes[i])
+            InteractiveUtils.warntype_type_printer(io, typ, true)
         end
         println(io)
     end

src/interpreter.jl

@@ -90,8 +90,8 @@ end
 @static if isdefined(Compiler, :is_stmt_inline)
 function Compiler.inlining_policy(
     interp::CthulhuInterpreter, @nospecialize(src), stmt_flag::UInt8,
-    mi::MethodInstance, argtypes::Vector{Any})
-    @assert isa(src, OptimizedSource) || isnothing(src)
+    mi::MethodInstance, argtypes::Argtypes)
+    @assert isa(src, OptimizedSource) || isnothing(src) "`inlining_policy(::CthulhuInterpreter, ...)` got unexpected source: `$(typeof(src))`"
     if isa(src, OptimizedSource)
         if Compiler.is_stmt_inline(stmt_flag) || src.isinlineable
             return src.ir
@@ -100,7 +100,7 @@ function Compiler.inlining_policy(
         # the default inlining policy may try additional effor to find the source in a local cache
         return Base.@invoke Compiler.inlining_policy(
             interp::AbstractInterpreter, nothing, stmt_flag::UInt8,
-            mi::MethodInstance, argtypes::Vector{Any})
+            mi::MethodInstance, argtypes::Argtypes)
     end
     return nothing
 end

src/reflection.jl

@@ -23,13 +23,13 @@ function transform(::Val{:CuFunction}, callsite, callexpr, CI, mi, slottypes; pa
     sptypes = sptypes_from_meth_instance(mi)
     tt = argextype(callexpr.args[4], CI, sptypes, slottypes)
     ft = argextype(callexpr.args[3], CI, sptypes, slottypes)
-    isa(tt, Const) || return callsite
+    (@static IS_OVERHAULED ? isConst(tt) : isa(tt, Const)) || return callsite
     return Callsite(callsite.id, CuCallInfo(callinfo(Tuple{widenconst(ft), tt.val.parameters...}, Nothing, params)), callsite.head)
 end
 
 function find_callsites(interp::CthulhuInterpreter, CI::Union{Core.CodeInfo, IRCode},
                         stmt_info::Union{Vector, Nothing}, mi::Core.MethodInstance,
-                        slottypes::Vector{Any}, optimize::Bool=true;
+                        slottypes::Argtypes, optimize::Bool=true;
                         params=current_params())
     sptypes = sptypes_from_meth_instance(mi)
     callsites = Callsite[]
@@ -47,25 +47,27 @@ function find_callsites(interp::CthulhuInterpreter, CI::Union{Core.CodeInfo, IRC
                 if !optimize
                     args = (ignorelhs(c)::Expr).args
                 end
-                types = mapany(function (@nospecialize(arg),)
-                                   t = argextype(arg, CI, sptypes, slottypes)
-                                   return widenconst(ignorelimited(t))
-                               end, args)
+                argtypes = @static IS_OVERHAULED ?
+                           LatticeElement[argextype(arg, CI, sptypes, slottypes) for arg in args] :
+                           mapany(function (@nospecialize(arg),)
+                                      t = argextype(arg, CI, sptypes, slottypes)
+                                      return widenconst(ignorelimited(t))
+                                  end, args)
                 was_return_type = false
                 if isa(info, Core.Compiler.ReturnTypeCallInfo)
                     info = info.info
                     was_return_type = true
                 end
 
-                callinfos = process_info(interp, info, types, rt, optimize)
+                callinfos = process_info(interp, info, argtypes, rt, optimize)
                 if !was_return_type && isempty(callinfos)
                     continue
                 end
                 callsite = let
                     if length(callinfos) == 1
                         callinfo = callinfos[1]
                     else
-                        callinfo = MultiCallInfo(Compiler.argtypes_to_type(types), rt, callinfos)
+                        callinfo = MultiCallInfo(Compiler.argtypes_to_type(argtypes), rt, callinfos)
                     end
                     if was_return_type
                         callinfo = ReturnTypeCallInfo(callinfo)
@@ -113,10 +115,9 @@ function find_callsites(interp::CthulhuInterpreter, CI::Union{Core.CodeInfo, IRC
     return callsites
 end
 
-function process_info(interp, @nospecialize(info), types, @nospecialize(rt), optimize::Bool)
+function process_info(interp, @nospecialize(info), argtypes::Argtypes, @nospecialize(rt), optimize::Bool)
     is_cached(@nospecialize(key)) = haskey(optimize ? interp.opt : interp.unopt, key)
-    process_recursive(@nospecialize(newinfo)) = process_info(interp, newinfo, types, rt, optimize)
-
+    process_recursive(@nospecialize(newinfo)) = process_info(interp, newinfo, argtypes, rt, optimize)
 
     if isa(info, MethodMatchInfo)
         if info.results === missing
@@ -130,7 +131,7 @@ function process_info(interp, @nospecialize(info), types, @nospecialize(rt), opt
             return is_cached(mi) ? mici : UncachedCallInfo(mici)
         end
     elseif isa(info, MethodResultPure)
-        return Any[PureCallInfo(types, rt)]
+        return Any[PureCallInfo(argtypes, rt)]
     elseif isa(info, UnionSplitInfo)
         return mapreduce(process_recursive, vcat, info.matches; init=[])::Vector{Any}
     elseif isa(info, UnionSplitApplyCallInfo)