diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs index 147061dafeb1e..c26ea4c966903 100644 --- a/compiler/rustc_infer/src/infer/at.rs +++ b/compiler/rustc_infer/src/infer/at.rs @@ -258,7 +258,10 @@ impl<'tcx> ToTrace<'tcx> for Ty<'tcx> { a: Self, b: Self, ) -> TypeTrace<'tcx> { - TypeTrace { cause: cause.clone(), values: Types(ExpectedFound::new(a_is_expected, a, b)) } + TypeTrace { + cause: cause.clone(), + values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())), + } } } @@ -282,27 +285,22 @@ impl<'tcx> ToTrace<'tcx> for &'tcx Const<'tcx> { a: Self, b: Self, ) -> TypeTrace<'tcx> { - TypeTrace { cause: cause.clone(), values: Consts(ExpectedFound::new(a_is_expected, a, b)) } + TypeTrace { + cause: cause.clone(), + values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())), + } } } impl<'tcx> ToTrace<'tcx> for ty::Term<'tcx> { fn to_trace( - tcx: TyCtxt<'tcx>, + _: TyCtxt<'tcx>, cause: &ObligationCause<'tcx>, a_is_expected: bool, a: Self, b: Self, ) -> TypeTrace<'tcx> { - match (a, b) { - (ty::Term::Ty(a), ty::Term::Ty(b)) => { - ToTrace::to_trace(tcx, cause, a_is_expected, a, b) - } - (ty::Term::Const(a), ty::Term::Const(b)) => { - ToTrace::to_trace(tcx, cause, a_is_expected, a, b) - } - (_, _) => todo!(), - } + TypeTrace { cause: cause.clone(), values: Terms(ExpectedFound::new(a_is_expected, a, b)) } } } @@ -348,7 +346,7 @@ impl<'tcx> ToTrace<'tcx> for ty::ProjectionTy<'tcx> { let b_ty = tcx.mk_projection(b.item_def_id, b.substs); TypeTrace { cause: cause.clone(), - values: Types(ExpectedFound::new(a_is_expected, a_ty, b_ty)), + values: Terms(ExpectedFound::new(a_is_expected, a_ty.into(), b_ty.into())), } } } diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs index 1eb8190bd7d2f..22f25ee396b51 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs @@ -1582,18 +1582,18 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { None => (None, Mismatch::Fixed("type"), false), Some(values) => { let (is_simple_error, exp_found) = match values { - ValuePairs::Types(exp_found) => { - let is_simple_err = - exp_found.expected.is_simple_text() && exp_found.found.is_simple_text(); - OpaqueTypesVisitor::visit_expected_found( - self.tcx, - exp_found.expected, - exp_found.found, - span, - ) - .report(diag); + ValuePairs::Terms(infer::ExpectedFound { + expected: ty::Term::Ty(expected), + found: ty::Term::Ty(found), + }) => { + let is_simple_err = expected.is_simple_text() && found.is_simple_text(); + OpaqueTypesVisitor::visit_expected_found(self.tcx, expected, found, span) + .report(diag); - (is_simple_err, Mismatch::Variable(exp_found)) + ( + is_simple_err, + Mismatch::Variable(infer::ExpectedFound { expected, found }), + ) } ValuePairs::TraitRefs(_) => (false, Mismatch::Fixed("trait")), _ => (false, Mismatch::Fixed("type")), @@ -1624,7 +1624,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { }; if let Some((sp, msg)) = secondary_span { if swap_secondary_and_primary { - let terr = if let Some(infer::ValuePairs::Types(infer::ExpectedFound { + let terr = if let Some(infer::ValuePairs::Terms(infer::ExpectedFound { expected, .. })) = values @@ -2036,9 +2036,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } FailureCode::Error0308(failure_str) => { let mut err = struct_span_err!(self.tcx.sess, span, E0308, "{}", failure_str); - if let ValuePairs::Types(ty::error::ExpectedFound { expected, found }) = - trace.values - { + if let Some((expected, found)) = trace.values.ty() { match (expected.kind(), found.kind()) { (ty::Tuple(_), ty::Tuple(_)) => {} // If a tuple of length one was expected and the found expression has @@ -2124,9 +2122,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { values: ValuePairs<'tcx>, ) -> Option<(DiagnosticStyledString, DiagnosticStyledString)> { match values { - infer::Types(exp_found) => self.expected_found_str_ty(exp_found), infer::Regions(exp_found) => self.expected_found_str(exp_found), - infer::Consts(exp_found) => self.expected_found_str(exp_found), + infer::Terms(exp_found) => self.expected_found_str_term(exp_found), infer::TraitRefs(exp_found) => { let pretty_exp_found = ty::error::ExpectedFound { expected: exp_found.expected.print_only_trait_path(), @@ -2154,16 +2151,22 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { } } - fn expected_found_str_ty( + fn expected_found_str_term( &self, - exp_found: ty::error::ExpectedFound>, + exp_found: ty::error::ExpectedFound>, ) -> Option<(DiagnosticStyledString, DiagnosticStyledString)> { let exp_found = self.resolve_vars_if_possible(exp_found); if exp_found.references_error() { return None; } - Some(self.cmp(exp_found.expected, exp_found.found)) + Some(match (exp_found.expected, exp_found.found) { + (ty::Term::Ty(expected), ty::Term::Ty(found)) => self.cmp(expected, found), + (expected, found) => ( + DiagnosticStyledString::highlighted(expected.to_string()), + DiagnosticStyledString::highlighted(found.to_string()), + ), + }) } /// Returns a string of the form "expected `{}`, found `{}`". diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs index bbea450a76973..a79ed20730b5c 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs @@ -2,7 +2,7 @@ use crate::infer::error_reporting::nice_region_error::NiceRegionError; use crate::infer::lexical_region_resolve::RegionResolutionError; -use crate::infer::{SubregionOrigin, Subtype, ValuePairs}; +use crate::infer::{SubregionOrigin, Subtype}; use crate::traits::ObligationCauseCode::CompareImplMethodObligation; use rustc_errors::ErrorReported; use rustc_hir as hir; @@ -34,16 +34,16 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { { if let (&Subtype(ref sup_trace), &Subtype(ref sub_trace)) = (&sup_origin, &sub_origin) { if let ( - ValuePairs::Types(sub_expected_found), - ValuePairs::Types(sup_expected_found), + sub_expected_found @ Some((sub_expected, sub_found)), + sup_expected_found @ Some(_), CompareImplMethodObligation { trait_item_def_id, .. }, - ) = (&sub_trace.values, &sup_trace.values, sub_trace.cause.code()) + ) = (&sub_trace.values.ty(), &sup_trace.values.ty(), sub_trace.cause.code()) { if sup_expected_found == sub_expected_found { self.emit_err( var_origin.span(), - sub_expected_found.expected, - sub_expected_found.found, + sub_expected, + sub_found, *trait_item_def_id, ); return Some(ErrorReported); diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index d1b24b332bdcc..c18d36d1f74a2 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -368,13 +368,26 @@ pub struct InferCtxt<'a, 'tcx> { /// See the `error_reporting` module for more details. #[derive(Clone, Copy, Debug, PartialEq, Eq, TypeFoldable)] pub enum ValuePairs<'tcx> { - Types(ExpectedFound>), Regions(ExpectedFound>), - Consts(ExpectedFound<&'tcx ty::Const<'tcx>>), + Terms(ExpectedFound>), TraitRefs(ExpectedFound>), PolyTraitRefs(ExpectedFound>), } +impl<'tcx> ValuePairs<'tcx> { + pub fn ty(&self) -> Option<(Ty<'tcx>, Ty<'tcx>)> { + if let ValuePairs::Terms(ExpectedFound { + expected: ty::Term::Ty(expected), + found: ty::Term::Ty(found), + }) = self + { + Some((expected, found)) + } else { + None + } + } +} + /// The trace designates the path through inference that we took to /// encounter an error or subtyping constraint. /// @@ -1790,7 +1803,10 @@ impl<'tcx> TypeTrace<'tcx> { a: Ty<'tcx>, b: Ty<'tcx>, ) -> TypeTrace<'tcx> { - TypeTrace { cause: cause.clone(), values: Types(ExpectedFound::new(a_is_expected, a, b)) } + TypeTrace { + cause: cause.clone(), + values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())), + } } pub fn consts( @@ -1799,7 +1815,10 @@ impl<'tcx> TypeTrace<'tcx> { a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>, ) -> TypeTrace<'tcx> { - TypeTrace { cause: cause.clone(), values: Consts(ExpectedFound::new(a_is_expected, a, b)) } + TypeTrace { + cause: cause.clone(), + values: Terms(ExpectedFound::new(a_is_expected, a.into(), b.into())), + } } } diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs index 6cb19416cd769..7f44f55c0d82b 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs @@ -1378,26 +1378,11 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> { normalized_ty, data.term, ) { - values = Some(match (normalized_ty, data.term) { - (ty::Term::Ty(normalized_ty), ty::Term::Ty(ty)) => { - infer::ValuePairs::Types(ExpectedFound::new( - is_normalized_ty_expected, - normalized_ty, - ty, - )) - } - (ty::Term::Const(normalized_ct), ty::Term::Const(ct)) => { - infer::ValuePairs::Consts(ExpectedFound::new( - is_normalized_ty_expected, - normalized_ct, - ct, - )) - } - (_, _) => span_bug!( - obligation.cause.span, - "found const or type where other expected" - ), - }); + values = Some(infer::ValuePairs::Terms(ExpectedFound::new( + is_normalized_ty_expected, + normalized_ty, + data.term, + ))); err_buf = error; err = &err_buf; } diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index 74910234b7edc..5bb528458c59e 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -377,9 +377,9 @@ fn compare_predicate_entailment<'tcx>( &mut diag, &cause, trait_err_span.map(|sp| (sp, "type in trait".to_owned())), - Some(infer::ValuePairs::Types(ExpectedFound { - expected: trait_fty, - found: impl_fty, + Some(infer::ValuePairs::Terms(ExpectedFound { + expected: trait_fty.into(), + found: impl_fty.into(), })), &terr, false, @@ -1068,9 +1068,9 @@ crate fn compare_const_impl<'tcx>( &mut diag, &cause, trait_c_span.map(|span| (span, "type in trait".to_owned())), - Some(infer::ValuePairs::Types(ExpectedFound { - expected: trait_ty, - found: impl_ty, + Some(infer::ValuePairs::Terms(ExpectedFound { + expected: trait_ty.into(), + found: impl_ty.into(), })), &terr, false,