[NewOptimizer] Port JuliaLang#26826 to new optimizer (JuliaLang#26981)

* fix InferenceResult cache lookup for new optimizer

* utilize cached vararg type info in new inlining pass

* fix test to work with new optimizer

* fix predicate for exploiting cached varargs type info

* atypes no longer needs to be modified to match cached types

* don't require varargs to be in last position to exploit cached type info

* restore missing isva boolean

base/compiler/ssair/inlining2.jl

@@ -576,15 +576,6 @@ function analyze_method!(idx, f, ft, metharg, methsp, method, stmt, atypes, sv,
  return ConstantCase(quoted(linfo.inferred_const), method, Any[methsp...], metharg)
  end
 
- # Handle vararg functions
- isva = na > 0 && method.isva
- if isva
- @assert length(atypes) >= na - 1
- va_type = tuple_tfunc(Tuple{Any[widenconst(atypes[i]) for i in 1:length(atypes)]...})
- atypes = Any[atypes[1:(na - 1)]..., va_type]
- end
-
- # Go see if we already have a pre-inferred result
  res = find_inferred(linfo, atypes, sv)
  res === nothing && return nothing
 
@@ -627,7 +618,8 @@ function analyze_method!(idx, f, ft, metharg, methsp, method, stmt, atypes, sv,
  #verify_ir(ir2)
 
  return InliningTodo(idx,
- isva, isinvoke, isapply, na,
+ na > 0 && method.isva,
+ isinvoke, isapply, na,
  method, Any[methsp...], metharg,
  inline_linetable, ir2, linear_inline_eligible(ir2))
 end
@@ -694,7 +686,6 @@ function handle_single_case!(ir, stmt, idx, case, isinvoke, todo)
  end
 end
 
-
 function assemble_inline_todo!(ir::IRCode, linetable::Vector{LineInfoNode}, sv::OptimizationState)
  # todo = (inline_idx, (isva, isinvoke, isapply, na), method, spvals, inline_linetable, inline_ir, lie)
  todo = Any[]
@@ -761,11 +752,13 @@ function assemble_inline_todo!(ir::IRCode, linetable::Vector{LineInfoNode}, sv::
  # As a special case, if we can see the tuple() call, look at it's arguments to find
  # our types. They can be more precise (e.g. f(Bool, A...) would be lowered as
  # _apply(f, tuple(Bool)::Tuple{DataType}, A), which might not be precise enough to
- # get a good method match. This pattern is used in the array code a bunch.
+ # get a good method match). This pattern is used in the array code a bunch.
  if isa(def, SSAValue) && is_tuple_call(ir, ir[def])
  for tuparg in ir[def].args[2:end]
  push!(new_atypes, exprtype(tuparg, ir, ir.mod))
  end
+ elseif isa(def, Argument) && def.n === length(ir.argtypes) && !isempty(sv.result_vargs)
+ append!(new_atypes, sv.result_vargs)
  else
  append!(new_atypes, typ.parameters)
  end

test/compiler/compiler.jl

@@ -1536,9 +1536,9 @@ x26826 = rand()
 
 apply26826(f, args...) = f(args...)
 
-f26826(x) = apply26826(Base.getproperty, Foo26826(1, x), :b)
 # We use getproperty to drive these tests because it requires constant
 # propagation in order to lower to a well-inferred getfield call.
+f26826(x) = apply26826(Base.getproperty, Foo26826(1, x), :b)
 
 @test @inferred(f26826(x26826)) === x26826
 
@@ -1554,12 +1554,10 @@ g26826(x) = getfield26826(x, :a, :b)
 # InferenceResult cache properly for varargs methods.
 typed_code = Core.Compiler.code_typed(f26826, (Float64,))[1].first.code
 found_well_typed_getfield_call = false
-for stmnt in typed_code
- if Meta.isexpr(stmnt, :(=)) && Meta.isexpr(stmnt.args[2], :call)
- lhs = stmnt.args[2]
- if lhs.args[1] == GlobalRef(Base, :getfield) && lhs.typ === Float64
- global found_well_typed_getfield_call = true
- end
+for stmt in typed_code
+ lhs = Meta.isexpr(stmt, :(=)) ? stmt.args[2] : stmt
+ if Meta.isexpr(lhs, :call) && lhs.args[1] == GlobalRef(Base, :getfield) && lhs.typ === Float64
+ global found_well_typed_getfield_call = true
  end
 end