Auto merge of #131797 - matthiaskrgr:rollup-lzpze2k, r=matthiaskrgr

Rollup of 9 pull requests

Successful merges:

 - #130989 (Don't check unsize goal in MIR validation when opaques remain)
 - #131657 (Rustfmt `for<'a> async` correctly)
 - #131691 (Delay ambiguous intra-doc link resolution after `Cache` has been populated)
 - #131730 (Refactor some `core::fmt` macros)
 - #131751 (Rename `can_coerce` to `may_coerce`, and then structurally resolve correctly in the probe)
 - #131753 (Unify `secondary_span` and `swap_secondary_and_primary` args in `note_type_err`)
 - #131776 (Emscripten: Xfail backtrace ui tests)
 - #131777 (Fix trivially_copy_pass_by_ref in stable_mir)
 - #131778 (Fix needless_lifetimes in stable_mir)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -592,14 +592,13 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
  &cause,
  hir.get_if_local(impl_m.def_id)
  .and_then(|node| node.fn_decl())
- .map(|decl| (decl.output.span(), Cow::from("return type in trait"))),
+ .map(|decl| (decl.output.span(), Cow::from("return type in trait"), false)),
  Some(infer::ValuePairs::Terms(ExpectedFound {
  expected: trait_return_ty.into(),
  found: impl_return_ty.into(),
  })),
  terr,
  false,
- false,
  );
  return Err(diag.emit());
  }
@@ -1018,14 +1017,13 @@ fn report_trait_method_mismatch<'tcx>(
  infcx.err_ctxt().note_type_err(
  &mut diag,
  &cause,
- trait_err_span.map(|sp| (sp, Cow::from("type in trait"))),
+ trait_err_span.map(|sp| (sp, Cow::from("type in trait"), false)),
  Some(infer::ValuePairs::PolySigs(ExpectedFound {
  expected: ty::Binder::dummy(trait_sig),
  found: ty::Binder::dummy(impl_sig),
  })),
  terr,
  false,
- false,
  );
 
  diag.emit()
@@ -1825,14 +1823,13 @@ fn compare_const_predicate_entailment<'tcx>(
  infcx.err_ctxt().note_type_err(
  &mut diag,
  &cause,
- trait_c_span.map(|span| (span, Cow::from("type in trait"))),
+ trait_c_span.map(|span| (span, Cow::from("type in trait"), false)),
  Some(infer::ValuePairs::Terms(ExpectedFound {
  expected: trait_ty.into(),
  found: impl_ty.into(),
  })),
  terr,
  false,
- false,
  );
  return Err(diag.emit());
  };

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -652,7 +652,6 @@ pub fn check_function_signature<'tcx>(
  })),
  err,
  false,
- false,
  );
  return Err(diag.emit());
  }

compiler/rustc_hir_typeck/src/_match.rs

@@ -235,8 +235,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  Some(ret_coercion) => {
  let ret_ty = ret_coercion.borrow().expected_ty();
  let ret_ty = self.infcx.shallow_resolve(ret_ty);
- self.can_coerce(arm_ty, ret_ty)
- && prior_arm.is_none_or(|(_, ty, _)| self.can_coerce(ty, ret_ty))
+ self.may_coerce(arm_ty, ret_ty)
+ && prior_arm.is_none_or(|(_, ty, _)| self.may_coerce(ty, ret_ty))
  // The match arms need to unify for the case of `impl Trait`.
  && !matches!(ret_ty.kind(), ty::Alias(ty::Opaque, ..))
  }

compiler/rustc_hir_typeck/src/cast.rs

@@ -409,7 +409,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
  let mut sugg_mutref = false;
  if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() {
  if let ty::RawPtr(expr_ty, _) = *self.expr_ty.kind()
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, expr_ty, mutbl),
  self.cast_ty,
  )
@@ -418,22 +418,22 @@ impl<'a, 'tcx> CastCheck<'tcx> {
  } else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind()
  && expr_mutbl == Mutability::Not
  && mutbl == Mutability::Mut
- && fcx.can_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
+ && fcx.may_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
  {
  sugg_mutref = true;
  }
 
  if !sugg_mutref
  && sugg == None
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, reg, self.expr_ty, mutbl),
  self.cast_ty,
  )
  {
  sugg = Some((format!("&{}", mutbl.prefix_str()), false));
  }
  } else if let ty::RawPtr(_, mutbl) = *self.cast_ty.kind()
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, self.expr_ty, mutbl),
  self.cast_ty,
  )

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1084,24 +1084,42 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  })
  }
 
- /// Same as `coerce()`, but without side-effects.
+ /// Probe whether `expr_ty` can be coerced to `target_ty`. This has no side-effects,
+ /// and may return false positives if types are not yet fully constrained by inference.
  ///
- /// Returns false if the coercion creates any obligations that result in
- /// errors.
- pub(crate) fn can_coerce(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> bool {
- // FIXME(-Znext-solver): We need to structurally resolve both types here.
- let source = self.resolve_vars_with_obligations(expr_ty);
- debug!("coercion::can_with_predicates({:?} -> {:?})", source, target);
-
+ /// Returns false if the coercion is not possible, or if the coercion creates any
+ /// sub-obligations that result in errors.
+ ///
+ /// This should only be used for diagnostics.
+ pub(crate) fn may_coerce(&self, expr_ty: Ty<'tcx>, target_ty: Ty<'tcx>) -> bool {
  let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
  // We don't ever need two-phase here since we throw out the result of the coercion.
  // We also just always set `coerce_never` to true, since this is a heuristic.
- let coerce = Coerce::new(self, cause, AllowTwoPhase::No, true);
+ let coerce = Coerce::new(self, cause.clone(), AllowTwoPhase::No, true);
  self.probe(|_| {
- let Ok(ok) = coerce.coerce(source, target) else {
+ // Make sure to structurally resolve the types, since we use
+ // the `TyKind`s heavily in coercion.
+ let ocx = ObligationCtxt::new(self);
+ let structurally_resolve = |ty| {
+ let ty = self.shallow_resolve(ty);
+ if self.next_trait_solver()
+ && let ty::Alias(..) = ty.kind()
+ {
+ ocx.structurally_normalize(&cause, self.param_env, ty)
+ } else {
+ Ok(ty)
+ }
+ };
+ let Ok(expr_ty) = structurally_resolve(expr_ty) else {
+ return false;
+ };
+ let Ok(target_ty) = structurally_resolve(target_ty) else {
+ return false;
+ };
+
+ let Ok(ok) = coerce.coerce(expr_ty, target_ty) else {
  return false;
  };
- let ocx = ObligationCtxt::new(self);
  ocx.register_obligations(ok.obligations);
  ocx.select_where_possible().is_empty()
  })
@@ -1370,7 +1388,7 @@ pub fn can_coerce<'tcx>(
 ) -> bool {
  let root_ctxt = crate::typeck_root_ctxt::TypeckRootCtxt::new(tcx, body_id);
  let fn_ctxt = FnCtxt::new(&root_ctxt, param_env, body_id);
- fn_ctxt.can_coerce(ty, output_ty)
+ fn_ctxt.may_coerce(ty, output_ty)
 }
 
 /// CoerceMany encapsulates the pattern you should use when you have

compiler/rustc_hir_typeck/src/expr.rs

@@ -1330,9 +1330,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let refs_can_coerce = |lhs: Ty<'tcx>, rhs: Ty<'tcx>| {
  let lhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, lhs.peel_refs());
  let rhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, rhs.peel_refs());
- self.can_coerce(rhs, lhs)
+ self.may_coerce(rhs, lhs)
  };
- let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
+ let (applicability, eq) = if self.may_coerce(rhs_ty, lhs_ty) {
  (Applicability::MachineApplicable, true)
  } else if refs_can_coerce(rhs_ty, lhs_ty) {
  // The lhs and rhs are likely missing some references in either side. Subsequent
@@ -1349,7 +1349,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let actual_lhs_ty = self.check_expr(rhs_expr);
  (
  Applicability::MaybeIncorrect,
- self.can_coerce(rhs_ty, actual_lhs_ty)
+ self.may_coerce(rhs_ty, actual_lhs_ty)
  || refs_can_coerce(rhs_ty, actual_lhs_ty),
  )
  } else if let ExprKind::Binary(
@@ -1363,7 +1363,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let actual_rhs_ty = self.check_expr(lhs_expr);
  (
  Applicability::MaybeIncorrect,
- self.can_coerce(actual_rhs_ty, lhs_ty)
+ self.may_coerce(actual_rhs_ty, lhs_ty)
  || refs_can_coerce(actual_rhs_ty, lhs_ty),
  )
  } else {
@@ -1414,7 +1414,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  self.param_env,
  )
  .may_apply();
- if lhs_deref_ty_is_sized && self.can_coerce(rhs_ty, lhs_deref_ty) {
+ if lhs_deref_ty_is_sized && self.may_coerce(rhs_ty, lhs_deref_ty) {
  err.span_suggestion_verbose(
  lhs.span.shrink_to_lo(),
  "consider dereferencing here to assign to the mutably borrowed value",

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -658,7 +658,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  && fn_sig.inputs()[1..]
  .iter()
  .zip(input_types.iter())
- .all(|(expected, found)| self.can_coerce(*expected, *found))
+ .all(|(expected, found)| self.may_coerce(*expected, *found))
  && fn_sig.inputs()[1..].len() == input_types.len()
  {
  err.span_suggestion_verbose(
@@ -722,7 +722,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
  let expectation = Expectation::rvalue_hint(self, expected_input_ty);
  let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty);
- let can_coerce = self.can_coerce(arg_ty, coerced_ty);
+ let can_coerce = self.may_coerce(arg_ty, coerced_ty);
  if !can_coerce {
  return Compatibility::Incompatible(Some(ty::error::TypeError::Sorts(
  ty::error::ExpectedFound::new(true, coerced_ty, arg_ty),
@@ -802,7 +802,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx + tys.len()),
  ),
  ) {
- if !self.can_coerce(provided_ty, *expected_ty) {
+ if !self.may_coerce(provided_ty, *expected_ty) {
  satisfied = false;
  break;
  }
@@ -1023,7 +1023,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  std::iter::zip(formal_and_expected_inputs.iter(), removed_arg_tys.iter()).all(
  |((expected_ty, _), (provided_ty, _))| {
  !provided_ty.references_error()
- && self.can_coerce(*provided_ty, *expected_ty)
+ && self.may_coerce(*provided_ty, *expected_ty)
  },
  )
  };
@@ -1114,7 +1114,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  None,
  Some(trace.values),
  e,
- false,
  true,
  );
  }
@@ -2124,7 +2123,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let expr_ty = self.typeck_results.borrow().expr_ty(expr);
  let return_ty = fn_sig.output();
  if !matches!(expr.kind, hir::ExprKind::Ret(..))
- && self.can_coerce(expr_ty, return_ty)
+ && self.may_coerce(expr_ty, return_ty)
  {
  found_semi = true;
  }