optimize Core.Compiler a bit (#49227)

Author: aviatesk

base/compiler/abstractinterpretation.jl

@@ -2023,7 +2023,7 @@ end
 function abstract_call_opaque_closure(interp::AbstractInterpreter,
     closure::PartialOpaque, arginfo::ArgInfo, si::StmtInfo, sv::InferenceState, check::Bool=true)
     sig = argtypes_to_type(arginfo.argtypes)
-    result = abstract_call_method(interp, closure.source, sig, Core.svec(), false, si, sv)
+    result = abstract_call_method(interp, closure.source::Method, sig, Core.svec(), false, si, sv)
     (; rt, edge, effects) = result
     tt = closure.typ
     sigT = (unwrap_unionall(tt)::DataType).parameters[1]
@@ -2276,7 +2276,9 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
             ismutable = ismutabletype(ut)
             fcount = datatype_fieldcount(ut)
             nargs = length(e.args) - 1
-            if fcount === nothing || (fcount > nargs && any(i::Int -> !is_undefref_fieldtype(fieldtype(t, i)), (nargs+1):fcount))
+            if (fcount === nothing || (fcount > nargs && (let t = t
+                    any(i::Int -> !is_undefref_fieldtype(fieldtype(t, i)), (nargs+1):fcount)
+                end)))
                 # allocation with undefined field leads to undefined behavior and should taint `:consistent`-cy
                 consistent = ALWAYS_FALSE
             elseif ismutable
@@ -2335,12 +2337,16 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
         if length(e.args) == 2 && isconcretedispatch(t) && !ismutabletype(t)
             at = abstract_eval_value(interp, e.args[2], vtypes, sv)
             n = fieldcount(t)
-            if isa(at, Const) && isa(at.val, Tuple) && n == length(at.val::Tuple) &&
-                let t = t, at = at; all(i::Int->getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n); end
+            if (isa(at, Const) && isa(at.val, Tuple) && n == length(at.val::Tuple) &&
+                (let t = t, at = at
+                    all(i::Int->getfield(at.val::Tuple, i) isa fieldtype(t, i), 1:n)
+                end))
                 nothrow = isexact
                 t = Const(ccall(:jl_new_structt, Any, (Any, Any), t, at.val))
-            elseif isa(at, PartialStruct) && at ⊑ᵢ Tuple && n == length(at.fields::Vector{Any}) &&
-                let t = t, at = at; all(i::Int->(at.fields::Vector{Any})[i] ⊑ᵢ fieldtype(t, i), 1:n); end
+            elseif (isa(at, PartialStruct) && at ⊑ᵢ Tuple && n == length(at.fields::Vector{Any}) &&
+                    (let t = t, at = at, ⊑ᵢ = ⊑ᵢ
+                        all(i::Int->(at.fields::Vector{Any})[i] ⊑ᵢ fieldtype(t, i), 1:n)
+                    end))
                 nothrow = isexact
                 t = PartialStruct(t, at.fields::Vector{Any})
             end

base/compiler/ssair/ir.jl

@@ -687,7 +687,7 @@ end
 function getindex(compact::IncrementalCompact, ssa::OldSSAValue)
     id = ssa.id
     if id < compact.idx
-        new_idx = compact.ssa_rename[id]
+        new_idx = compact.ssa_rename[id]::Int
         return compact.result[new_idx]
     elseif id <= length(compact.ir.stmts)
         return compact.ir.stmts[id]
@@ -721,7 +721,7 @@ end
 function block_for_inst(compact::IncrementalCompact, idx::OldSSAValue)
     id = idx.id
     if id < compact.idx # if ssa within result
-        id = compact.ssa_rename[id]
+        id = compact.ssa_rename[id]::Int
         return block_for_inst(compact, SSAValue(id))
     else
         return block_for_inst(compact.ir.cfg, id)
@@ -962,7 +962,7 @@ end
 function setindex!(compact::IncrementalCompact, @nospecialize(v), idx::OldSSAValue)
     id = idx.id
     if id < compact.idx
-        new_idx = compact.ssa_rename[id]
+        new_idx = compact.ssa_rename[id]::Int
         (compact.result[new_idx][:inst] === v) && return compact
         kill_current_uses!(compact, compact.result[new_idx][:inst])
         compact.result[new_idx][:inst] = v

base/compiler/stmtinfo.jl

@@ -56,26 +56,26 @@ nsplit_impl(info::UnionSplitInfo) = length(info.matches)
 getsplit_impl(info::UnionSplitInfo, idx::Int) = getsplit_impl(info.matches[idx], 1)
 getresult_impl(::UnionSplitInfo, ::Int) = nothing
 
-struct ConstPropResult
+abstract type ConstResult end
+
+struct ConstPropResult <: ConstResult
     result::InferenceResult
 end
 
-struct ConcreteResult
+struct ConcreteResult <: ConstResult
     mi::MethodInstance
     effects::Effects
     result
     ConcreteResult(mi::MethodInstance, effects::Effects) = new(mi, effects)
     ConcreteResult(mi::MethodInstance, effects::Effects, @nospecialize val) = new(mi, effects, val)
 end
 
-struct SemiConcreteResult
+struct SemiConcreteResult <: ConstResult
     mi::MethodInstance
     ir::IRCode
     effects::Effects
 end
 
-const ConstResult = Union{ConstPropResult, ConcreteResult, SemiConcreteResult}
-
 """
     info::ConstCallInfo <: CallInfo
 

base/compiler/tfuncs.jl

@@ -1793,12 +1793,12 @@ const _tvarnames = Symbol[:_A, :_B, :_C, :_D, :_E, :_F, :_G, :_H, :_I, :_J, :_K,
                 if i == largs && ub === Any
                     push!(tparams, Vararg)
                 elseif isT
-                    push!(tparams, rewrap_unionall(unw.parameters[1], ai))
+                    push!(tparams, rewrap_unionall((unw::DataType).parameters[1], ai))
                 else
                     push!(tparams, Any)
                 end
             elseif isT
-                push!(tparams, unw.parameters[1])
+                push!(tparams, (unw::DataType).parameters[1])
                 while isa(ai, UnionAll)
                     push!(outervars, ai.var)
                     ai = ai.body
@@ -2633,7 +2633,7 @@ function abstract_applicable(interp::AbstractInterpreter, argtypes::Vector{Any},
             rt = Const(true) # has applicable matches
             for i in 1:napplicable
                 match = applicable[i]::MethodMatch
-                edge = specialize_method(match)
+                edge = specialize_method(match)::MethodInstance
                 add_backedge!(sv, edge)
             end
 
@@ -2681,7 +2681,7 @@ function _hasmethod_tfunc(interp::AbstractInterpreter, argtypes::Vector{Any}, sv
         add_mt_backedge!(sv, mt, types) # this should actually be an invoke-type backedge
     else
         rt = Const(true)
-        edge = specialize_method(match)
+        edge = specialize_method(match)::MethodInstance
         add_invoke_backedge!(sv, types, edge)
     end
     return CallMeta(rt, EFFECTS_TOTAL, NoCallInfo())