lattice overhaul step 3: clean up implementations

Author: aviatesk

base/compiler/abstractinterpretation.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 = cnd.vtype ⊓ sigt
+                elsetype = 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/inferenceresult.jl

@@ -223,7 +223,7 @@ function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src::Union{IRC
             rt === ⊥ && return false
             return _builtin_nothrow(f, LatticeElement[argextype(args[i], src) for i = 2:length(args)], rt)
         elseif head === :new
-            typ = unwraptype(argextype(args[1], src))
+            typ = argextype(args[1], src)
             # `Expr(:new)` of unknown type could raise arbitrary TypeError.
             typ, isexact = instanceof_tfunc(typ)
             isexact || return false
@@ -240,7 +240,7 @@ function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src::Union{IRC
             return foreigncall_effect_free(stmt, rt, src)
         elseif head === :new_opaque_closure
             length(args) < 5 && return false
-            typ = unwraptype(argextype(args[1], src))
+            typ = argextype(args[1], src)
             typ, isexact = instanceof_tfunc(typ)
             isexact || return false
             typ ⊑ Tuple || return false
@@ -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/optimize.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
@@ -443,11 +443,11 @@ function fix_va_argexprs!(compact::IncrementalCompact,
     argexprs::Vector{Any}, nargs_def::Int, line_idx::Int32)
     newargexprs = argexprs[1:(nargs_def-1)]
     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)))
@@ -480,15 +480,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
@@ -500,7 +500,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
@@ -517,25 +517,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
 
@@ -642,7 +642,7 @@ function rewrite_apply_exprargs!(
         if thisarginfo === nothing
             if isPartialStruct(def_type)
                 # def_type.typ <: Tuple is assumed
-                def_argtypes = LatticeElement[LatticeElement(t) for t in partialfields(def_type)]
+                def_argtypes = partialfields(def_type)
             else
                 def_argtypes = LatticeElement[]
                 if isConst(def_type) # && isa(constant(def_type), Union{Tuple, SimpleVector}) is implied
@@ -699,15 +699,15 @@ function rewrite_apply_exprargs!(
                         new_sig, istate, todo)
                 end
                 if i != length(thisarginfo.each)
-                    valT = getfield_tfunc(unwraptype(call.rt), Const(1))
+                    valT = getfield_tfunc(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))))
+                        getfield_tfunc(call.rt, Const(2))))
                     state = Core.svec(state_extracted)
                 end
             end
@@ -892,19 +892,19 @@ function is_valid_type_for_apply_rewrite(typ::LatticeElement, params::Optimizati
 end
 
 function inline_splatnew!(ir::IRCode, idx::Int, stmt::Expr, rt::LatticeElement)
-    nf = nfields_tfunc(unwraptype(rt))
+    nf = nfields_tfunc(rt)
     if isConst(nf)
         eargs = stmt.args
         tup = eargs[2]
         tt = argextype(tup, ir)
-        tnf = nfields_tfunc(unwraptype(tt))
+        tnf = nfields_tfunc(tt)
         # TODO: hoisting this constant(tnf) === constant(nf) check into codegen
         # would enable us to almost always do this transform
         if isConst(tnf) && constant(tnf) === constant(nf)
             n = constant(tnf)::Int
             new_argexprs = Any[eargs[1]]
             for j = 1:n
-                atype = getfield_tfunc(unwraptype(tt), Const(j))
+                atype = getfield_tfunc(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)
@@ -1036,14 +1036,14 @@ end
 function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), state::InliningState)
     if isa(info, OpaqueClosureCreateInfo)
         lbt = argextype(stmt.args[3], ir)
-        lb, exact = instanceof_tfunc(unwraptype(lbt))
+        lb, exact = instanceof_tfunc(lbt)
         exact || return
         ubt = argextype(stmt.args[4], ir)
-        ub, exact = instanceof_tfunc(unwraptype(ubt))
+        ub, exact = instanceof_tfunc(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.
@@ -1433,7 +1433,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/inlining.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)

base/compiler/ssair/ir.jl

@@ -340,7 +340,7 @@ const LiftedLeaves = IdDict{Any, Union{Nothing,LiftedValue}}
 # try to compute lifted values that can replace `getfield(x, field)` call
 # where `x` is an immutable struct that are defined at any of `leaves`
 function lift_leaves(compact::IncrementalCompact,
-                     @nospecialize(result_t), field::Int, leaves::Vector{Any})
+                     result_t::LatticeElement, field::Int, leaves::Vector{Any})
     # For every leaf, the lifted value
     lifted_leaves = LiftedLeaves()
     maybe_undef = false
@@ -513,7 +513,7 @@ function lift_comparison!(compact::IncrementalCompact,
     # Let's check if we evaluate the comparison for each one of the leaves
     lifted_leaves = nothing
     for leaf in leaves
-        r = egal_tfunc(unwraptype(argextype(leaf, compact)), cmp)
+        r = egal_tfunc(argextype(leaf, compact), cmp)
         if isConst(r)
             if lifted_leaves === nothing
                 lifted_leaves = LiftedLeaves()
@@ -525,7 +525,7 @@ function lift_comparison!(compact::IncrementalCompact,
     end
 
     lifted_val = perform_lifting!(compact,
-        visited_phinodes, cmp, lifting_cache, Bool,
+        visited_phinodes, cmp, lifting_cache, LBool,
         lifted_leaves::LiftedLeaves, val)::LiftedValue
 
     compact[idx] = lifted_val.x
@@ -546,7 +546,7 @@ end
 function perform_lifting!(compact::IncrementalCompact,
     visited_phinodes::Vector{AnySSAValue}, @nospecialize(cache_key),
     lifting_cache::IdDict{Pair{AnySSAValue, Any}, AnySSAValue},
-    @nospecialize(result_t), lifted_leaves::LiftedLeaves, @nospecialize(stmt_val))
+    result_t::LatticeElement, lifted_leaves::LiftedLeaves, @nospecialize(stmt_val))
     reverse_mapping = IdDict{AnySSAValue, Int}(ssa => id for (id, ssa) in enumerate(visited_phinodes))
 
     # Insert PhiNodes
@@ -792,7 +792,7 @@ function sroa_pass!(ir::IRCode)
         if any_undef
             if val === nothing
                 insert_node!(compact, SSAValue(idx),
-                    non_effect_free(NewInstruction(Expr(:throw_undef_if_not, Symbol("##getfield##"), false), Nothing)))
+                    non_effect_free(NewInstruction(Expr(:throw_undef_if_not, Symbol("##getfield##"), false), LNothing)))
             else
                 # val must be defined
             end
@@ -914,7 +914,7 @@ function sroa_mutables!(ir::IRCode, defuses::IdDict{Int, Tuple{SPCSet, SSADefUse
                 phinodes = IdDict{Int, SSAValue}()
                 for b in phiblocks
                     phinodes[b] = insert_node!(ir, first(ir.cfg.blocks[b].stmts),
-                        NewInstruction(PhiNode(), ftyp))
+                        NewInstruction(PhiNode(), NativeType(ftyp)))
                 end
                 # Now go through all uses and rewrite them
                 for stmt in du.uses
@@ -1156,15 +1156,15 @@ function type_lift_pass!(ir::IRCode)
                         new_phi = if length(values) == 0
                             false
                         else
-                            insert_node!(ir, item, NewInstruction(PhiNode(edges, values), Bool))
+                            insert_node!(ir, item, NewInstruction(PhiNode(edges, values), LBool))
                         end
                     else
                         def = def::PhiCNode
                         values = Vector{Any}(undef, length(def.values))
                         new_phi = if length(values) == 0
                             false
                         else
-                            insert_node!(ir, item, NewInstruction(PhiCNode(values), Bool))
+                            insert_node!(ir, item, NewInstruction(PhiCNode(values), LBool))
                         end
                     end
                     processed[item] = new_phi
@@ -1215,7 +1215,7 @@ function type_lift_pass!(ir::IRCode)
                         if isa(def, PhiNode)
                             values[i] = val
                         else
-                            values[i] = insert_node!(ir, up_id, NewInstruction(UpsilonNode(val), Bool))
+                            values[i] = insert_node!(ir, up_id, NewInstruction(UpsilonNode(val), LBool))
                         end
                     end
                     if which !== SSAValue(0)
@@ -1224,7 +1224,7 @@ function type_lift_pass!(ir::IRCode)
                             phi.values[use] = new_phi
                         else
                             phi = phi::PhiCNode
-                            phi.values[use] = insert_node!(ir, w_up_id, NewInstruction(UpsilonNode(new_phi), Bool))
+                            phi.values[use] = insert_node!(ir, w_up_id, NewInstruction(UpsilonNode(new_phi), LBool))
                         end
                     end
                 end