sroa: Don't use unwrapped type for type constraint (JuliaLang#50499)

In SROA, when we lift getfields over branches (ifelse or phi), we
try to exclude branches that we know to not contribute by their
types. However, we were incorrectly using the `unwrap_unionall`'ed
version of the type. Type intersection has a bunch of fallbacks for
free typevars, but the results are not necessarily correct (e.g.
in the test case where `hasintersect(Wrap1{Wrap{Int}}, Wrap1{Wrap{T}})`
gives false). We should ideally get around to just making type-quries
for things with free typevars an error, but for now, just fix the
particular issue in sroa, by using the non-unwrapped type.

base/compiler/ssair/passes.jl

@@ -1105,25 +1105,25 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
  # analyze `getfield` / `isdefined` / `setfield!` call
  val = stmt.args[2]
  end
- struct_typ = unwrap_unionall(widenconst(argextype(val, compact)))
+ struct_typ = widenconst(argextype(val, compact))
+ struct_typ_unwrapped = unwrap_unionall(struct_typ)
  if isa(struct_typ, Union) && struct_typ <: Tuple
- struct_typ = unswitchtupleunion(struct_typ)
+ struct_typ_unwrapped = unswitchtupleunion(struct_typ_unwrapped)
  end
- if isa(struct_typ, Union) && is_isdefined
+ if isa(struct_typ_unwrapped, Union) && is_isdefined
  lift_comparison!(isdefined, compact, idx, stmt, lifting_cache, 𝕃ₒ)
  continue
  end
- isa(struct_typ, DataType) || continue
+ isa(struct_typ_unwrapped, DataType) || continue
 
- struct_typ.name.atomicfields == C_NULL || continue # TODO: handle more
+ struct_typ_unwrapped.name.atomicfields == C_NULL || continue # TODO: handle more
  if !((field_ordering === :unspecified) ||
  (field_ordering isa Const && field_ordering.val === :not_atomic))
  continue
  end
 
-
  # analyze this mutable struct here for the later pass
- if ismutabletype(struct_typ)
+ if ismutabletype(struct_typ_unwrapped)
  isa(val, SSAValue) || continue
  let intermediaries = SPCSet()
  callback = IntermediaryCollector(intermediaries)
@@ -1153,7 +1153,7 @@ function sroa_pass!(ir::IRCode, inlining::Union{Nothing,InliningState}=nothing)
  end
 
  # perform SROA on immutable structs here on
- field = try_compute_fieldidx_stmt(compact, stmt, struct_typ)
+ field = try_compute_fieldidx_stmt(compact, stmt, struct_typ_unwrapped)
  field === nothing && continue
 
  leaves, visited_philikes = collect_leaves(compact, val, struct_typ, 𝕃ₒ, phi_or_ifelse_predecessors)

test/compiler/irpasses.jl

@@ -1371,3 +1371,22 @@ struct TParamTypeofTest2{S,T}
 end
 tparam_typeof_test_elim2(x, y) = TParamTypeofTest2(x, y).x
 @test fully_eliminated(tparam_typeof_test_elim2, Tuple{Any,Any})
+
+# Test that sroa doesn't get confused by free type parameters in struct types
+struct Wrap1{T}
+ x::T
+ @eval @inline (T::Type{Wrap1{X}} where X)(x) = $(Expr(:new, :T, :x))
+end
+Wrap1(x) = Wrap1{typeof(x)}(x)
+
+function wrap1_wrap1_ifelse(b, x, w1)
+ w2 = Wrap1(Wrap1(x))
+ w3 = Wrap1(typeof(w1)(w1.x))
+ Core.ifelse(b, w3, w2).x.x
+end
+function wrap1_wrap1_wrapper(b, x, y)
+ w1 = Base.inferencebarrier(Wrap1(y))::Wrap1{<:Union{Int, Float64}}
+ wrap1_wrap1_ifelse(b, x, w1)
+end
+@test wrap1_wrap1_wrapper(true, 1, 1.0) === 1.0
+@test wrap1_wrap1_wrapper(false, 1, 1.0) === 1