Skip to content

Commit 798fb83

Browse files
committed
Auto merge of rust-lang#131797 - matthiaskrgr:rollup-lzpze2k, r=matthiaskrgr
Rollup of 9 pull requests Successful merges: - rust-lang#130989 (Don't check unsize goal in MIR validation when opaques remain) - rust-lang#131657 (Rustfmt `for<'a> async` correctly) - rust-lang#131691 (Delay ambiguous intra-doc link resolution after `Cache` has been populated) - rust-lang#131730 (Refactor some `core::fmt` macros) - rust-lang#131751 (Rename `can_coerce` to `may_coerce`, and then structurally resolve correctly in the probe) - rust-lang#131753 (Unify `secondary_span` and `swap_secondary_and_primary` args in `note_type_err`) - rust-lang#131776 (Emscripten: Xfail backtrace ui tests) - rust-lang#131777 (Fix trivially_copy_pass_by_ref in stable_mir) - rust-lang#131778 (Fix needless_lifetimes in stable_mir) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 7342830 + 50e93bc commit 798fb83

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

47 files changed

+610
-248
lines changed

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

+3-6
Original file line numberDiff line numberDiff line change
@@ -592,14 +592,13 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
592592
&cause,
593593
hir.get_if_local(impl_m.def_id)
594594
.and_then(|node| node.fn_decl())
595-
.map(|decl| (decl.output.span(), Cow::from("return type in trait"))),
595+
.map(|decl| (decl.output.span(), Cow::from("return type in trait"), false)),
596596
Some(infer::ValuePairs::Terms(ExpectedFound {
597597
expected: trait_return_ty.into(),
598598
found: impl_return_ty.into(),
599599
})),
600600
terr,
601601
false,
602-
false,
603602
);
604603
return Err(diag.emit());
605604
}
@@ -1018,14 +1017,13 @@ fn report_trait_method_mismatch<'tcx>(
10181017
infcx.err_ctxt().note_type_err(
10191018
&mut diag,
10201019
&cause,
1021-
trait_err_span.map(|sp| (sp, Cow::from("type in trait"))),
1020+
trait_err_span.map(|sp| (sp, Cow::from("type in trait"), false)),
10221021
Some(infer::ValuePairs::PolySigs(ExpectedFound {
10231022
expected: ty::Binder::dummy(trait_sig),
10241023
found: ty::Binder::dummy(impl_sig),
10251024
})),
10261025
terr,
10271026
false,
1028-
false,
10291027
);
10301028

10311029
diag.emit()
@@ -1825,14 +1823,13 @@ fn compare_const_predicate_entailment<'tcx>(
18251823
infcx.err_ctxt().note_type_err(
18261824
&mut diag,
18271825
&cause,
1828-
trait_c_span.map(|span| (span, Cow::from("type in trait"))),
1826+
trait_c_span.map(|span| (span, Cow::from("type in trait"), false)),
18291827
Some(infer::ValuePairs::Terms(ExpectedFound {
18301828
expected: trait_ty.into(),
18311829
found: impl_ty.into(),
18321830
})),
18331831
terr,
18341832
false,
1835-
false,
18361833
);
18371834
return Err(diag.emit());
18381835
};

compiler/rustc_hir_analysis/src/check/mod.rs

-1
Original file line numberDiff line numberDiff line change
@@ -652,7 +652,6 @@ pub fn check_function_signature<'tcx>(
652652
})),
653653
err,
654654
false,
655-
false,
656655
);
657656
return Err(diag.emit());
658657
}

compiler/rustc_hir_typeck/src/_match.rs

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

compiler/rustc_hir_typeck/src/cast.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -409,7 +409,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
409409
let mut sugg_mutref = false;
410410
if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() {
411411
if let ty::RawPtr(expr_ty, _) = *self.expr_ty.kind()
412-
&& fcx.can_coerce(
412+
&& fcx.may_coerce(
413413
Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, expr_ty, mutbl),
414414
self.cast_ty,
415415
)
@@ -418,22 +418,22 @@ impl<'a, 'tcx> CastCheck<'tcx> {
418418
} else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind()
419419
&& expr_mutbl == Mutability::Not
420420
&& mutbl == Mutability::Mut
421-
&& fcx.can_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
421+
&& fcx.may_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
422422
{
423423
sugg_mutref = true;
424424
}
425425

426426
if !sugg_mutref
427427
&& sugg == None
428-
&& fcx.can_coerce(
428+
&& fcx.may_coerce(
429429
Ty::new_ref(fcx.tcx, reg, self.expr_ty, mutbl),
430430
self.cast_ty,
431431
)
432432
{
433433
sugg = Some((format!("&{}", mutbl.prefix_str()), false));
434434
}
435435
} else if let ty::RawPtr(_, mutbl) = *self.cast_ty.kind()
436-
&& fcx.can_coerce(
436+
&& fcx.may_coerce(
437437
Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, self.expr_ty, mutbl),
438438
self.cast_ty,
439439
)

compiler/rustc_hir_typeck/src/coercion.rs

+30-12
Original file line numberDiff line numberDiff line change
@@ -1084,24 +1084,42 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10841084
})
10851085
}
10861086

1087-
/// Same as `coerce()`, but without side-effects.
1087+
/// Probe whether `expr_ty` can be coerced to `target_ty`. This has no side-effects,
1088+
/// and may return false positives if types are not yet fully constrained by inference.
10881089
///
1089-
/// Returns false if the coercion creates any obligations that result in
1090-
/// errors.
1091-
pub(crate) fn can_coerce(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> bool {
1092-
// FIXME(-Znext-solver): We need to structurally resolve both types here.
1093-
let source = self.resolve_vars_with_obligations(expr_ty);
1094-
debug!("coercion::can_with_predicates({:?} -> {:?})", source, target);
1095-
1090+
/// Returns false if the coercion is not possible, or if the coercion creates any
1091+
/// sub-obligations that result in errors.
1092+
///
1093+
/// This should only be used for diagnostics.
1094+
pub(crate) fn may_coerce(&self, expr_ty: Ty<'tcx>, target_ty: Ty<'tcx>) -> bool {
10961095
let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
10971096
// We don't ever need two-phase here since we throw out the result of the coercion.
10981097
// We also just always set `coerce_never` to true, since this is a heuristic.
1099-
let coerce = Coerce::new(self, cause, AllowTwoPhase::No, true);
1098+
let coerce = Coerce::new(self, cause.clone(), AllowTwoPhase::No, true);
11001099
self.probe(|_| {
1101-
let Ok(ok) = coerce.coerce(source, target) else {
1100+
// Make sure to structurally resolve the types, since we use
1101+
// the `TyKind`s heavily in coercion.
1102+
let ocx = ObligationCtxt::new(self);
1103+
let structurally_resolve = |ty| {
1104+
let ty = self.shallow_resolve(ty);
1105+
if self.next_trait_solver()
1106+
&& let ty::Alias(..) = ty.kind()
1107+
{
1108+
ocx.structurally_normalize(&cause, self.param_env, ty)
1109+
} else {
1110+
Ok(ty)
1111+
}
1112+
};
1113+
let Ok(expr_ty) = structurally_resolve(expr_ty) else {
1114+
return false;
1115+
};
1116+
let Ok(target_ty) = structurally_resolve(target_ty) else {
1117+
return false;
1118+
};
1119+
1120+
let Ok(ok) = coerce.coerce(expr_ty, target_ty) else {
11021121
return false;
11031122
};
1104-
let ocx = ObligationCtxt::new(self);
11051123
ocx.register_obligations(ok.obligations);
11061124
ocx.select_where_possible().is_empty()
11071125
})
@@ -1370,7 +1388,7 @@ pub fn can_coerce<'tcx>(
13701388
) -> bool {
13711389
let root_ctxt = crate::typeck_root_ctxt::TypeckRootCtxt::new(tcx, body_id);
13721390
let fn_ctxt = FnCtxt::new(&root_ctxt, param_env, body_id);
1373-
fn_ctxt.can_coerce(ty, output_ty)
1391+
fn_ctxt.may_coerce(ty, output_ty)
13741392
}
13751393

13761394
/// CoerceMany encapsulates the pattern you should use when you have

compiler/rustc_hir_typeck/src/expr.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -1330,9 +1330,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13301330
let refs_can_coerce = |lhs: Ty<'tcx>, rhs: Ty<'tcx>| {
13311331
let lhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, lhs.peel_refs());
13321332
let rhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, rhs.peel_refs());
1333-
self.can_coerce(rhs, lhs)
1333+
self.may_coerce(rhs, lhs)
13341334
};
1335-
let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
1335+
let (applicability, eq) = if self.may_coerce(rhs_ty, lhs_ty) {
13361336
(Applicability::MachineApplicable, true)
13371337
} else if refs_can_coerce(rhs_ty, lhs_ty) {
13381338
// The lhs and rhs are likely missing some references in either side. Subsequent
@@ -1349,7 +1349,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13491349
let actual_lhs_ty = self.check_expr(rhs_expr);
13501350
(
13511351
Applicability::MaybeIncorrect,
1352-
self.can_coerce(rhs_ty, actual_lhs_ty)
1352+
self.may_coerce(rhs_ty, actual_lhs_ty)
13531353
|| refs_can_coerce(rhs_ty, actual_lhs_ty),
13541354
)
13551355
} else if let ExprKind::Binary(
@@ -1363,7 +1363,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
13631363
let actual_rhs_ty = self.check_expr(lhs_expr);
13641364
(
13651365
Applicability::MaybeIncorrect,
1366-
self.can_coerce(actual_rhs_ty, lhs_ty)
1366+
self.may_coerce(actual_rhs_ty, lhs_ty)
13671367
|| refs_can_coerce(actual_rhs_ty, lhs_ty),
13681368
)
13691369
} else {
@@ -1414,7 +1414,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
14141414
self.param_env,
14151415
)
14161416
.may_apply();
1417-
if lhs_deref_ty_is_sized && self.can_coerce(rhs_ty, lhs_deref_ty) {
1417+
if lhs_deref_ty_is_sized && self.may_coerce(rhs_ty, lhs_deref_ty) {
14181418
err.span_suggestion_verbose(
14191419
lhs.span.shrink_to_lo(),
14201420
"consider dereferencing here to assign to the mutably borrowed value",

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

+5-6
Original file line numberDiff line numberDiff line change
@@ -658,7 +658,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
658658
&& fn_sig.inputs()[1..]
659659
.iter()
660660
.zip(input_types.iter())
661-
.all(|(expected, found)| self.can_coerce(*expected, *found))
661+
.all(|(expected, found)| self.may_coerce(*expected, *found))
662662
&& fn_sig.inputs()[1..].len() == input_types.len()
663663
{
664664
err.span_suggestion_verbose(
@@ -722,7 +722,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
722722

723723
let expectation = Expectation::rvalue_hint(self, expected_input_ty);
724724
let coerced_ty = expectation.only_has_type(self).unwrap_or(formal_input_ty);
725-
let can_coerce = self.can_coerce(arg_ty, coerced_ty);
725+
let can_coerce = self.may_coerce(arg_ty, coerced_ty);
726726
if !can_coerce {
727727
return Compatibility::Incompatible(Some(ty::error::TypeError::Sorts(
728728
ty::error::ExpectedFound::new(true, coerced_ty, arg_ty),
@@ -802,7 +802,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
802802
provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx + tys.len()),
803803
),
804804
) {
805-
if !self.can_coerce(provided_ty, *expected_ty) {
805+
if !self.may_coerce(provided_ty, *expected_ty) {
806806
satisfied = false;
807807
break;
808808
}
@@ -1023,7 +1023,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
10231023
std::iter::zip(formal_and_expected_inputs.iter(), removed_arg_tys.iter()).all(
10241024
|((expected_ty, _), (provided_ty, _))| {
10251025
!provided_ty.references_error()
1026-
&& self.can_coerce(*provided_ty, *expected_ty)
1026+
&& self.may_coerce(*provided_ty, *expected_ty)
10271027
},
10281028
)
10291029
};
@@ -1114,7 +1114,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
11141114
None,
11151115
Some(trace.values),
11161116
e,
1117-
false,
11181117
true,
11191118
);
11201119
}
@@ -2124,7 +2123,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
21242123
let expr_ty = self.typeck_results.borrow().expr_ty(expr);
21252124
let return_ty = fn_sig.output();
21262125
if !matches!(expr.kind, hir::ExprKind::Ret(..))
2127-
&& self.can_coerce(expr_ty, return_ty)
2126+
&& self.may_coerce(expr_ty, return_ty)
21282127
{
21292128
found_semi = true;
21302129
}

0 commit comments

Comments
 (0)