effects: don't taint :noub for :new allocations (#52222)

After #52169, the UB previously associated with allocations with
uninitialized fields has been addressed, so there's no longer a need to
taint `:noub` for `:new` allocations during abstract interpretation.

I believe, even without #52169, uninitialized field does not inherently
leads to UB, but just causes inconsistency of the program, since what
actually causes UB is `getfield` that accesses into whatever object, but
not the allocation itself.

base/compiler/abstractinterpretation.jl

@@ -2352,24 +2352,22 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
  elseif ehead === :new
  t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
  ut = unwrap_unionall(t)
- consistent = noub = ALWAYS_FALSE
- nothrow = false
  if isa(ut, DataType) && !isabstracttype(ut)
  ismutable = ismutabletype(ut)
  fcount = datatype_fieldcount(ut)
  nargs = length(e.args) - 1
- if (fcount === nothing || (fcount > nargs && (let t = t
+ has_any_uninitialized = (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 `:noub`
+ if has_any_uninitialized
+ # allocation with undefined field is inconsistent always
+ consistent = ALWAYS_FALSE
  elseif ismutable
- # mutable object isn't `:consistent`, but we still have a chance that
+ # mutable allocation isn't `:consistent`, but we still have a chance that
  # return type information later refines the `:consistent`-cy of the method
  consistent = CONSISTENT_IF_NOTRETURNED
- noub = ALWAYS_TRUE
  else
- consistent = ALWAYS_TRUE
- noub = ALWAYS_TRUE
+ consistent = ALWAYS_TRUE # immutable allocation is consistent
  end
  if isconcretedispatch(t)
  nothrow = true
@@ -2411,9 +2409,13 @@ function abstract_eval_statement_expr(interp::AbstractInterpreter, e::Expr, vtyp
  end
  else
  t = refine_partial_type(t)
+ nothrow = false
  end
+ else
+ consistent = ALWAYS_FALSE
+ nothrow = false
  end
- effects = Effects(EFFECTS_TOTAL; consistent, nothrow, noub)
+ effects = Effects(EFFECTS_TOTAL; consistent, nothrow)
  elseif ehead === :splatnew
  t, isexact = instanceof_tfunc(abstract_eval_value(interp, e.args[1], vtypes, sv), true)
  nothrow = false # TODO: More precision

base/compiler/ssair/inlining.jl

@@ -1265,7 +1265,7 @@ function check_effect_free!(ir::IRCode, idx::Int, @nospecialize(stmt), @nospecia
  elseif nothrow
  ir.stmts[idx][:flag] |= IR_FLAG_NOTHROW
  end
- if !isexpr(stmt, :call) && !isexpr(stmt, :invoke)
+ if !(isexpr(stmt, :call) || isexpr(stmt, :invoke))
  # There is a bit of a subtle point here, which is that some non-call
  # statements (e.g. PiNode) can be UB:, however, we consider it
  # illegal to introduce such statements that actually cause UB (for any