lattice overhaul step 3: clean up implementations

Author: aviatesk

base/compiler/abstractinterpretation.jl

@@ -4,7 +4,6 @@
 # constants #
 #############
 
-const ⊤, ⊥ = LatticeElement(Any), LatticeElement(Bottom)
 const _REF_NAME = Ref.body.name
 
 #########
@@ -321,7 +320,7 @@ end
 function from_interconditional(typ::LatticeElement, sv::InferenceState, (; fargs, argtypes)::ArgInfo, @nospecialize(maybecondinfo))
     fargs === nothing && return widenconditional(typ)
     slot = 0
-    vtype = elsetype = Any
+    vtype = elsetype = ⊤
     condval = maybe_extract_const_bool(typ)
     for i in 1:length(fargs)
         # find the first argument which supports refinement,
@@ -339,36 +338,36 @@ function from_interconditional(typ::LatticeElement, sv::InferenceState, (; fargs
             else
                 # otherwise compute it on the fly
                 cnd = conditional_argtype(typ, maybecondinfo, argtypes, i)
-                new_vtype = cnd.vtype
-                new_elsetype = cnd.elsetype
+                new_vtype = LatticeElement(cnd.vtype)
+                new_elsetype = LatticeElement(cnd.elsetype)
             end
             if condval === false
-                vtype = Bottom
+                vtype = ⊥
             elseif new_vtype ⊑ vtype
                 vtype = new_vtype
             else
-                vtype = tmeet(vtype, widenconst(new_vtype))
+                vtype = vtype ⊓ widenconst(new_vtype)
             end
             if condval === true
                 elsetype = Bottom
             elseif new_elsetype ⊑ elsetype
                 elsetype = new_elsetype
             else
-                elsetype = tmeet(elsetype, widenconst(new_elsetype))
+                elsetype = elsetype ⊓ widenconst(new_elsetype)
             end
             if (slot > 0 || condval !== false) && vtype ⋤ old
                 slot = id
             elseif (slot > 0 || condval !== true) && elsetype ⋤ old
                 slot = id
             else # reset: no new useful information for this slot
-                vtype = elsetype = Any
+                vtype = elsetype = ⊤
                 if slot > 0
                     slot = 0
                 end
             end
         end
     end
-    if vtype === Bottom && elsetype === Bottom
+    if vtype === ⊥ && elsetype === ⊥
         return ⊥ # accidentally proved this call to be dead / throw !
     elseif slot > 0
         return Conditional(slot, vtype, elsetype) # record a Conditional improvement to this slot
@@ -383,7 +382,7 @@ function conditional_argtype(rt::LatticeElement, @nospecialize(sig), argtypes::V
             return cnd
         end
     end
-    vtype = elsetype = tmeet(argtypes[i], fieldtype(sig, i))
+    vtype = elsetype = argtypes[i] ⊓ fieldtype(sig, i)
     condval = maybe_extract_const_bool(rt)
     condval === true && (elsetype = Bottom)
     condval === false && (vtype = Bottom)
@@ -1201,10 +1200,10 @@ function abstract_call_builtin(
                 a = ssa_def_slot(fargs[3], sv)
                 b = ssa_def_slot(fargs[4], sv)
                 if isa(a, SlotNumber) && cnd.slot_id == slot_id(a)
-                    tx = (cnd.vtype ⊑ tx ? cnd.vtype : tmeet(tx, widenconst(cnd.vtype)))
+                    tx = (cnd.vtype ⊑ tx ? cnd.vtype : (tx ⊓ widenconst(cnd.vtype)))
                 end
                 if isa(b, SlotNumber) && cnd.slot_id == slot_id(b)
-                    ty = (cnd.elsetype ⊑ ty ? cnd.elsetype : tmeet(ty, widenconst(cnd.elsetype)))
+                    ty = (cnd.elsetype ⊑ ty ? cnd.elsetype : (ty ⊓ widenconst(cnd.elsetype)))
                 end
                 return tmerge(tx, ty)
             end
@@ -1452,7 +1451,7 @@ function abstract_call_known(
         aty = argtypes[2]
         if isConditional(aty)
             cnd = conditional(aty)
-            call = abstract_call_gf_by_type(interp, f, ArgInfo(fargs, LatticeElement[Const(f), NativeType(Bool)]), Tuple{typeof(f), Bool}, sv, max_methods) # make sure we've inferred `!(::Bool)`
+            call = abstract_call_gf_by_type(interp, f, ArgInfo(fargs, LatticeElement[Const(f), LBool]), Tuple{typeof(f), Bool}, sv, max_methods) # make sure we've inferred `!(::Bool)`
             return CallMeta(Conditional(cnd.slot_id, cnd.elsetype, cnd.vtype), call.info)
         end
     elseif la == 3 && istopfunction(f, :!==)
@@ -1610,7 +1609,7 @@ function abstract_eval_value_expr(interp::AbstractInterpreter, e::Expr, vtypes::
         n = e.args[1]::Int
         return 1 <= n <= length(sv.sptypes) ? sv.sptypes[n] : ⊤
     elseif e.head === :boundscheck
-        return NativeType(Bool)
+        return LBool
     else
         return ⊤
     end
@@ -1686,7 +1685,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
             for i = 2:length(e.args)
                 at = widenconditional(abstract_eval_value(interp, e.args[i], vtypes, sv))
                 ft = fieldtype(ty, i-1)
-                at = tmeet(at, ft)
+                at = at ⊓ ft
                 if at === ⊥
                     t = ⊥
                     @goto t_computed
@@ -1733,7 +1732,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
             argtypes = collect_argtypes(interp, ea, vtypes, sv)
             if argtypes !== nothing
                 t = _opaque_closure_tfunc(argtypes[1], argtypes[2], argtypes[3],
-                    argtypes[4], argtypes[5], anymap(unwraptype, argtypes[6:end]), sv.linfo)
+                    argtypes[4], argtypes[5], argtypes[6:end], sv.linfo)
                 if isPartialOpaque(t)
                     # Infer this now so that the specialization is available to
                     # optimization.
@@ -1770,7 +1769,7 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
         error("type inference data-flow error: tried to double infer a function")
     elseif ehead === :isdefined
         sym = e.args[1]
-        t = NativeType(Bool)
+        t = LBool
         if isa(sym, SlotNumber)
             vtyp = vtypes[slot_id(sym)]
             if vtyp.typ === ⊥
@@ -2103,7 +2102,7 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState)
 
             if t === nothing
                 # mark other reached expressions as `Any` to indicate they don't throw
-                ssavaluetypes[pc] = NativeType(Any)
+                ssavaluetypes[pc] = ⊤
             end
 
             pc´ > n && break # can't proceed with the fast-path fall-through
@@ -2139,7 +2138,7 @@ function conditional_changes(changes::VarTable, typ::LatticeElement, slot_id::In
     # since we probably formed these types with `typesubstract`, the comparison is likely simple
     typ′, oldtyp′ = ignorelimited(typ), ignorelimited(oldtyp)
     if typ′ ⊑ oldtyp′
-        # typ is better unlimited, but we may still need to compute the tmeet with the limit "causes" since we ignored those in the comparison
+        # typ is better unlimited, but we may still need to compute the meet with the limit "causes" since we ignored those in the comparison
         if isLimitedAccuracy(oldtyp)
             typ = LimitedAccuracy(typ′, causes(oldtyp))
         end

base/compiler/inferenceresult.jl

@@ -37,8 +37,8 @@ function matching_cache_argtypes(
             if slotid !== nothing
                 # using union-split signature, we may be able to narrow down `Conditional`
                 sigt = widenconst(slotid > nargs ? argtypes[slotid] : cache_argtypes[slotid])
-                vtype = tmeet(cnd.vtype, sigt)
-                elsetype = tmeet(cnd.elsetype, sigt)
+                vtype = LatticeElement(cnd.vtype) ⊓ sigt
+                elsetype = LatticeElement(cnd.elsetype) ⊓ sigt
                 if vtype === Bottom && elsetype === Bottom
                     # we accidentally proved this method match is impossible
                     # TODO bail out here immediately rather than just propagating Bottom ?
@@ -67,7 +67,7 @@ function matching_cache_argtypes(
             else
                 last = nargs
             end
-            isva_given_argtypes[nargs] = LatticeElement(tuple_tfunc(given_argtypes[last:end]))
+            isva_given_argtypes[nargs] = tuple_tfunc(given_argtypes[last:end])
             # invalidate `Conditional` imposed on varargs
             if condargs !== nothing
                 for (slotid, i) in condargs
@@ -219,7 +219,7 @@ function cache_lookup(linfo::MethodInstance, given_argtypes::Argtypes, cache::Ve
             end
         end
         if method.isva && cache_match
-            cache_match = is_argtype_match(LatticeElement(tuple_tfunc(anymap(unwraptype, given_argtypes[(nargs + 1):end]))),
+            cache_match = is_argtype_match(tuple_tfunc(given_argtypes[(nargs + 1):end]),
                                            cache_argtypes[end],
                                            cache_overridden_by_const[end])
         end

base/compiler/optimize.jl

@@ -354,7 +354,7 @@ function argextype(
         if x.head === :static_parameter
             return sptypes[x.args[1]::Int]
         elseif x.head === :boundscheck
-            return NativeType(Bool)
+            return LBool
         elseif x.head === :copyast
             return argextype(x.args[1], src, sptypes, slottypes)
         end
@@ -547,7 +547,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
             # insert a side-effect instruction before the current instruction in the same basic block
             insert!(code, idx, Expr(:code_coverage_effect))
             insert!(codelocs, idx, codeloc)
-            insert!(ssavaluetypes, idx, NativeType(Nothing))
+            insert!(ssavaluetypes, idx, LNothing)
             insert!(stmtinfo, idx, nothing)
             insert!(ssaflags, idx, IR_FLAG_NULL)
             changemap[oldidx] += 1

base/compiler/ssair/inlining.jl

@@ -330,7 +330,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
         push!(linetable, newentry)
     end
     if coverage && spec.ir.stmts[1][:line] + linetable_offset != topline
-        insert_node_here!(compact, NewInstruction(Expr(:code_coverage_effect), Nothing, topline))
+        insert_node_here!(compact, NewInstruction(Expr(:code_coverage_effect), LNothing, topline))
     end
     if def.isva
         nargs_def = Int(def.nargs::Int32)
@@ -400,7 +400,7 @@ function ir_inline_item!(compact::IncrementalCompact, idx::Int, argexprs::Vector
                         inline_compact.result[idx′][:type] =
                             argextype(val, isa(val, Expr) ? compact : inline_compact)
                         insert_node_here!(inline_compact, NewInstruction(GotoNode(post_bb_id),
-                                          Any, compact.result[idx′][:line]),
+                                          ⊤, compact.result[idx′][:line]),
                                           true)
                         push!(pn.values, SSAValue(idx′))
                     else
@@ -446,11 +446,11 @@ function fix_va_argexprs!(compact::IncrementalCompact,
         push!(newargexprs, argexprs[i])
     end
     tuple_call = Expr(:call, TOP_TUPLE)
-    tuple_typs = Any[]
+    tuple_typs = LatticeElement[]
     for i in nargs_def:length(argexprs)
         arg = argexprs[i]
         push!(tuple_call.args, arg)
-        push!(tuple_typs, unwraptype(argextype(arg, compact)))
+        push!(tuple_typs, argextype(arg, compact))
     end
     tuple_typ = tuple_tfunc(tuple_typs)
     push!(newargexprs, insert_node_here!(compact, NewInstruction(tuple_call, tuple_typ, line_idx)))
@@ -483,15 +483,15 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
             a <: m && continue
             # Generate isa check
             isa_expr = Expr(:call, isa, argexprs[i], m)
-            ssa = insert_node_here!(compact, NewInstruction(isa_expr, Bool, line))
+            ssa = insert_node_here!(compact, NewInstruction(isa_expr, LBool, line))
             if cond === true
                 cond = ssa
             else
                 and_expr = Expr(:call, and_int, cond, ssa)
-                cond = insert_node_here!(compact, NewInstruction(and_expr, Bool, line))
+                cond = insert_node_here!(compact, NewInstruction(and_expr, LBool, line))
             end
         end
-        insert_node_here!(compact, NewInstruction(GotoIfNot(cond, next_cond_bb), Union{}, line))
+        insert_node_here!(compact, NewInstruction(GotoIfNot(cond, next_cond_bb), ⊥, line))
         bb = next_cond_bb - 1
         finish_current_bb!(compact, 0)
         argexprs′ = argexprs
@@ -503,7 +503,7 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
                 a, m = aparams[i], mparams[i]
                 if !(a <: m)
                     argexprs′[i] = insert_node_here!(compact,
-                        NewInstruction(PiNode(argex, m), m, line))
+                        NewInstruction(PiNode(argex, m), NativeType(m), line))
                 end
             end
         end
@@ -520,25 +520,25 @@ function ir_inline_unionsplit!(compact::IncrementalCompact, idx::Int,
             push!(pn.edges, bb)
             push!(pn.values, val)
             insert_node_here!(compact,
-                NewInstruction(GotoNode(join_bb), Union{}, line))
+                NewInstruction(GotoNode(join_bb), ⊥, line))
         else
             insert_node_here!(compact,
-                NewInstruction(ReturnNode(), Union{}, line))
+                NewInstruction(ReturnNode(), ⊥, line))
         end
         finish_current_bb!(compact, 0)
     end
     bb += 1
     # We're now in the fall through block, decide what to do
     if fully_covered
         e = Expr(:call, GlobalRef(Core, :throw), FATAL_TYPE_BOUND_ERROR)
-        insert_node_here!(compact, NewInstruction(e, Union{}, line))
-        insert_node_here!(compact, NewInstruction(ReturnNode(), Union{}, line))
+        insert_node_here!(compact, NewInstruction(e, ⊥, line))
+        insert_node_here!(compact, NewInstruction(ReturnNode(), ⊥, line))
         finish_current_bb!(compact, 0)
     else
         ssa = insert_node_here!(compact, NewInstruction(stmt, typ, line))
         push!(pn.edges, bb)
         push!(pn.values, ssa)
-        insert_node_here!(compact, NewInstruction(GotoNode(join_bb), Union{}, line))
+        insert_node_here!(compact, NewInstruction(GotoNode(join_bb), ⊥, line))
         finish_current_bb!(compact, 0)
     end
 
@@ -702,15 +702,15 @@ function rewrite_apply_exprargs!(
                         new_sig, istate, todo)
                 end
                 if i != length(thisarginfo.each)
-                    valT = getfield_tfunc(unwraptype(call.rt), Const(1))
+                    valT = LatticeElement(getfield_tfunc(unwraptype(call.rt), Const(1)))
                     val_extracted = insert_node!(ir, idx, NewInstruction(
                         Expr(:call, GlobalRef(Core, :getfield), state1, 1),
                         valT))
                     push!(new_argexprs, val_extracted)
-                    push!(new_argtypes, LatticeElement(valT))
+                    push!(new_argtypes, valT)
                     state_extracted = insert_node!(ir, idx, NewInstruction(
                         Expr(:call, GlobalRef(Core, :getfield), state1, 2),
-                        getfield_tfunc(unwraptype(call.rt), Const(2))))
+                        LatticeElement(getfield_tfunc(unwraptype(call.rt), Const(2)))))
                     state = Core.svec(state_extracted)
                 end
             end
@@ -907,7 +907,7 @@ function inline_splatnew!(ir::IRCode, idx::Int, stmt::Expr, rt::LatticeElement)
             n = constant(tnf)::Int
             new_argexprs = Any[eargs[1]]
             for j = 1:n
-                atype = getfield_tfunc(unwraptype(tt), Const(j))
+                atype = LatticeElement(getfield_tfunc(unwraptype(tt), Const(j)))
                 new_call = Expr(:call, Core.getfield, tup, j)
                 new_argexpr = insert_node!(ir, idx, NewInstruction(new_call, atype))
                 push!(new_argexprs, new_argexpr)
@@ -1045,8 +1045,8 @@ function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), sta
         ub, exact = instanceof_tfunc(unwraptype(ubt))
         exact || return
         # Narrow opaque closure type
-        newT = widenconst(tmeet(tmerge(lb, info.unspec.rt), ub))
-        if newT != ub
+        newT = widenconst(tmerge(lb, info.unspec.rt) ⊓ ub)
+        if newT !== ub
             # N.B.: Narrowing the ub requires a backdge on the mi whose type
             # information we're using, since a change in that function may
             # invalidate ub result.
@@ -1436,7 +1436,7 @@ function late_inline_special_case!(
             return SomeCase(quoted(constant(type)))
         end
         cmp_call = Expr(:call, GlobalRef(Core, :(===)), stmt.args[2], stmt.args[3])
-        cmp_call_ssa = insert_node!(ir, idx, effect_free(NewInstruction(cmp_call, Bool)))
+        cmp_call_ssa = insert_node!(ir, idx, effect_free(NewInstruction(cmp_call, LBool)))
         not_call = Expr(:call, GlobalRef(Core.Intrinsics, :not_int), cmp_call_ssa)
         return SomeCase(not_call)
     elseif isinlining && length(argtypes) == 3 && istopfunction(f, :(>:))

base/compiler/ssair/ir.jl

@@ -166,17 +166,17 @@ struct NewInstruction
     # Don't bother redoing so on insertion.
     effect_free_computed::Bool
 
-    function NewInstruction(@nospecialize(stmt), @nospecialize(type), @nospecialize(info),
+    function NewInstruction(@nospecialize(stmt), type::LatticeElement, @nospecialize(info),
             line::Union{Int32, Nothing}, flag::UInt8, effect_free_computed::Bool)
         if isa(type, Type)
             type = NativeType(type)
         end
         return new(stmt, type, info, line, flag, effect_free_computed)
     end
 end
-NewInstruction(@nospecialize(stmt), @nospecialize(type)) =
+NewInstruction(@nospecialize(stmt), type::LatticeElement) =
     NewInstruction(stmt, type, nothing)
-NewInstruction(@nospecialize(stmt), @nospecialize(type), line::Union{Nothing, Int32}) =
+NewInstruction(@nospecialize(stmt), type::LatticeElement, line::Union{Nothing, Int32}) =
     NewInstruction(stmt, type, nothing, line, IR_FLAG_NULL, false)
 
 effect_free(inst::NewInstruction) =
@@ -1156,7 +1156,7 @@ function finish_current_bb!(compact::IncrementalCompact, active_bb, old_result_i
             if unreachable
                 node[:inst], node[:type], node[:line] = ReturnNode(), ⊥, 0
             else
-                node[:inst], node[:type], node[:line] = nothing, NativeType(Nothing), 0
+                node[:inst], node[:type], node[:line] = nothing, LNothing, 0
             end
             compact.result_idx = old_result_idx + 1
         elseif compact.cfg_transforms_enabled && compact.result_idx - 1 == first(bb.stmts)