lattice overhaul step 1: separate contexts where native Julia types are expected from those where extended lattice wrappers are

Author: aviatesk

base/compiler/abstractinterpretation.jl

@@ -112,6 +112,36 @@ something(x::Any, y...) = x
 # compiler #
 ############
 
+# TODO remove me in the future, this is just to check the coverage of the overhaul
+import Core: Const, PartialStruct, InterConditional, PartialOpaque, TypeofVararg
+abstract type _AbstractLattice end
+const AbstractLattice = Union{
+    Const, PartialStruct, InterConditional, PartialOpaque, TypeofVararg,
+    _AbstractLattice}
+const Argtypes = Vector{AbstractLattice}
+
+macro latticeop(mode, def)
+    @assert is_function_def(def)
+    sig, body = def.args
+    if mode === :args || mode === :op
+        nospecs = Symbol[]
+        for arg in sig.args
+            if isexpr(arg, :macrocall) && arg.args[1] === Symbol("@nospecialize")
+                push!(nospecs, arg.args[3])
+            end
+        end
+        idx = findfirst(x->!isa(x, LineNumberNode), body.args)
+        for var in nospecs
+            insert!(body.args, idx, Expr(:(=), var, Expr(:(::), var, :AbstractLattice)))
+        end
+    end
+    if mode === :ret || mode === :op
+        sig = Expr(:(::), sig, :AbstractLattice)
+    end
+    return esc(Expr(def.head, sig, body))
+end
+anymap(f::Function, a::Vector{AbstractLattice}) = Any[ f(a[i]) for i in 1:length(a) ]
+
 include("compiler/cicache.jl")
 include("compiler/types.jl")
 include("compiler/utilities.jl")

base/compiler/compiler.jl

@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-function is_argtype_match(@nospecialize(given_argtype),
+@latticeop args function is_argtype_match(@nospecialize(given_argtype),
                           @nospecialize(cache_argtype),
                           overridden_by_const::Bool)
     if is_forwardable_argtype(given_argtype)
@@ -26,7 +26,7 @@ function matching_cache_argtypes(
     @assert isa(linfo.def, Method) # ensure the next line works
     nargs::Int = linfo.def.nargs
     cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo, nothing, va_override)
-    given_argtypes = Vector{Any}(undef, length(argtypes))
+    given_argtypes = Vector{AbstractLattice}(undef, length(argtypes))
     local condargs = nothing
     for i in 1:length(argtypes)
         argtype = argtypes[i]
@@ -42,7 +42,7 @@ function matching_cache_argtypes(
                 if vtype === Bottom && elsetype === Bottom
                     # we accidentally proved this method match is impossible
                     # TODO bail out here immediately rather than just propagating Bottom ?
-                    given_argtypes[i] = Bottom
+                    given_argtypes[i] = ⊥
                 else
                     if condargs === nothing
                         condargs = Tuple{Int,Int}[]
@@ -56,18 +56,18 @@ function matching_cache_argtypes(
         given_argtypes[i] = widenconditional(argtype)
     end
     isva = va_override || linfo.def.isva
-    if isva || isvarargtype(given_argtypes[end])
+    if isva || isvarargtype(unwraptype(given_argtypes[end]))
         isva_given_argtypes = Vector{Any}(undef, nargs)
         for i = 1:(nargs - isva)
             isva_given_argtypes[i] = argtype_by_index(given_argtypes, i)
         end
         if isva
-            if length(given_argtypes) < nargs && isvarargtype(given_argtypes[end])
+            if length(given_argtypes) < nargs && isvarargtype(unwraptype(given_argtypes[end]))
                 last = length(given_argtypes)
             else
                 last = nargs
             end
-            isva_given_argtypes[nargs] = tuple_tfunc(given_argtypes[last:end])
+            isva_given_argtypes[nargs] = TypeLattice(tuple_tfunc(anymap(unwraptype, given_argtypes[last:end])))
             # invalidate `Conditional` imposed on varargs
             if condargs !== nothing
                 for (slotid, i) in condargs
@@ -101,7 +101,7 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
         # For opaque closure, the closure environment is processed elsewhere
         nargs -= 1
     end
-    cache_argtypes = Vector{Any}(undef, nargs)
+    cache_argtypes = Vector{AbstractLattice}(undef, nargs)
     # First, if we're dealing with a varargs method, then we set the last element of `args`
     # to the appropriate `Tuple` type or `PartialStruct` instance.
     if !toplevel && isva
@@ -140,7 +140,7 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
                 vargtype = tuple_tfunc(vargtype_elements)
             end
         end
-        cache_argtypes[nargs] = vargtype
+        cache_argtypes[nargs] = TypeLattice(vargtype)
         nargs -= 1
     end
     # Now, we propagate type info from `linfo_argtypes` into `cache_argtypes`, improving some
@@ -168,10 +168,10 @@ function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(spe
                 atyp = elim_free_typevars(rewrap_unionall(atyp, specTypes))
             end
             i == n && (lastatype = atyp)
-            cache_argtypes[i] = atyp
+            cache_argtypes[i] = TypeLattice(atyp)
         end
         for i = (tail_index + 1):nargs
-            cache_argtypes[i] = lastatype
+            cache_argtypes[i] = TypeLattice(lastatype)
         end
     else
         @assert nargs == 0 "invalid specialization of method" # wrong number of arguments
@@ -199,7 +199,7 @@ function matching_cache_argtypes(linfo::MethodInstance, ::Nothing, va_override::
     return cache_argtypes, falses(length(cache_argtypes))
 end
 
-function cache_lookup(linfo::MethodInstance, given_argtypes::Vector{Any}, cache::Vector{InferenceResult})
+function cache_lookup(linfo::MethodInstance, given_argtypes::Vector{AbstractLattice}, cache::Vector{InferenceResult})
     method = linfo.def::Method
     nargs::Int = method.nargs
     method.isva && (nargs -= 1)
@@ -218,7 +218,7 @@ function cache_lookup(linfo::MethodInstance, given_argtypes::Vector{Any}, cache:
             end
         end
         if method.isva && cache_match
-            cache_match = is_argtype_match(tuple_tfunc(given_argtypes[(nargs + 1):end]),
+            cache_match = is_argtype_match(TypeLattice(tuple_tfunc(anymap(unwraptype, given_argtypes[(nargs + 1):end]))),
                                            cache_argtypes[end],
                                            cache_overridden_by_const[end])
         end

base/compiler/inferenceresult.jl

@@ -5,9 +5,9 @@ const LineNum = Int
 # The type of a variable load is either a value or an UndefVarError
 # (only used in abstractinterpret, doesn't appear in optimize)
 struct VarState
-    typ
+    typ::AbstractLattice
     undef::Bool
-    VarState(@nospecialize(typ), undef::Bool) = new(typ, undef)
+    @latticeop args VarState(@nospecialize(typ), undef::Bool) = new(typ, undef)
 end
 
 """
@@ -24,8 +24,8 @@ mutable struct InferenceState
     params::InferenceParams
     result::InferenceResult # remember where to put the result
     linfo::MethodInstance
-    sptypes::Vector{Any}    # types of static parameter
-    slottypes::Vector{Any}
+    sptypes::Vector{AbstractLattice}    # types of static parameter
+    slottypes::Vector{AbstractLattice}
     mod::Module
     currpc::LineNum
     pclimitations::IdSet{InferenceState} # causes of precision restrictions (LimitedAccuracy) on currpc ssavalue
@@ -40,7 +40,7 @@ mutable struct InferenceState
     stmt_edges::Vector{Union{Nothing, Vector{Any}}}
     stmt_info::Vector{Any}
     # return type
-    bestguess #::Type
+    bestguess::AbstractLattice
     # current active instruction pointers
     ip::BitSet
     pc´´::LineNum
@@ -79,7 +79,7 @@ mutable struct InferenceState
         sp = sptypes_from_meth_instance(linfo::MethodInstance)
 
         nssavalues = src.ssavaluetypes::Int
-        src.ssavaluetypes = Any[ NOT_FOUND for i = 1:nssavalues ]
+        src.ssavaluetypes = AbstractLattice[ NOT_FOUND for i = 1:nssavalues ]
         stmt_info = Any[ nothing for i = 1:length(code) ]
 
         n = length(code)
@@ -91,9 +91,9 @@ mutable struct InferenceState
         argtypes = result.argtypes
         nargs = length(argtypes)
         s_argtypes = VarTable(undef, nslots)
-        slottypes = Vector{Any}(undef, nslots)
+        slottypes = Vector{AbstractLattice}(undef, nslots)
         for i in 1:nslots
-            at = (i > nargs) ? Bottom : argtypes[i]
+            at = (i > nargs) ? ⊥ : TypeLattice(argtypes[i])
             s_argtypes[i] = VarState(at, i > nargs)
             slottypes[i] = at
         end
@@ -120,7 +120,7 @@ mutable struct InferenceState
             IdSet{InferenceState}(), IdSet{InferenceState}(),
             src, get_world_counter(interp), valid_worlds,
             nargs, s_types, s_edges, stmt_info,
-            Union{}, ip, 1, n, handler_at,
+            ⊥, ip, 1, n, handler_at,
             ssavalue_uses,
             Vector{Tuple{InferenceState,LineNum}}(), # cycle_backedges
             Vector{InferenceState}(), # callers_in_cycle
@@ -316,9 +316,9 @@ function sptypes_from_meth_instance(linfo::MethodInstance)
         else
             ty = Const(v)
         end
-        sp[i] = ty
+        sp[i] = TypeLattice(ty)
     end
-    return sp
+    return collect(AbstractLattice, sp)
 end
 
 _topmod(sv::InferenceState) = _topmod(sv.mod)
@@ -332,8 +332,8 @@ end
 
 update_valid_age!(edge::InferenceState, sv::InferenceState) = update_valid_age!(sv, edge.valid_worlds)
 
-function record_ssa_assign(ssa_id::Int, @nospecialize(new), frame::InferenceState)
-    ssavaluetypes = frame.src.ssavaluetypes::Vector{Any}
+@latticeop args function record_ssa_assign(ssa_id::Int, @nospecialize(new), frame::InferenceState)
+    ssavaluetypes = frame.src.ssavaluetypes::Vector{AbstractLattice}
     old = ssavaluetypes[ssa_id]
     if old === NOT_FOUND || !(new ⊑ old)
         # typically, we expect that old ⊑ new (that output information only