diff options
Diffstat (limited to 'compiler/rustc_trait_selection')
4 files changed, 34 insertions, 32 deletions
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 9839f4768e2..3defc03e7f0 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -1203,7 +1203,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { let code = match obligation.cause.code() { ObligationCauseCode::FunctionArg { parent_code, .. } => parent_code, - c @ ObligationCauseCode::MiscItem(_) | c @ ObligationCauseCode::MiscItemInExpr(..) => c, + c @ ObligationCauseCode::WhereClause(_) + | c @ ObligationCauseCode::WhereClauseInExpr(..) => c, c if matches!( span.ctxt().outer_expn_data().kind, ExpnKind::Desugaring(DesugaringKind::ForLoop) @@ -1259,8 +1260,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { let mut_ref_self_ty_satisfies_pred = mk_result(trait_pred_and_mut_ref); let (ref_inner_ty_satisfies_pred, ref_inner_ty_mut) = - if let ObligationCauseCode::MiscItem(_) | ObligationCauseCode::MiscItemInExpr(..) = - obligation.cause.code() + if let ObligationCauseCode::WhereClause(_) + | ObligationCauseCode::WhereClauseInExpr(..) = obligation.cause.code() && let ty::Ref(_, ty, mutability) = old_pred.self_ty().skip_binder().kind() { ( @@ -1400,10 +1401,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { if let ObligationCauseCode::ImplDerived(cause) = &*code { try_borrowing(cause.derived.parent_trait_pred, &[]) - } else if let ObligationCauseCode::SpannedItem(_, _) - | ObligationCauseCode::MiscItem(_) - | ObligationCauseCode::MiscItemInExpr(..) - | ObligationCauseCode::SpannedItemInExpr(..) = code + } else if let ObligationCauseCode::SpannedWhereClause(_, _) + | ObligationCauseCode::WhereClause(_) + | ObligationCauseCode::WhereClauseInExpr(..) + | ObligationCauseCode::SpannedWhereClauseInExpr(..) = code { try_borrowing(poly_trait_pred, &never_suggest_borrow) } else { @@ -2099,10 +2100,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { cause: &ObligationCauseCode<'tcx>, err: &mut Diag<'tcx>, ) { - // First, look for an `SpannedItemInExpr`, which means we can get + // First, look for an `SpannedWhereClauseInExpr`, which means we can get // the uninstantiated predicate list of the called function. And check // that the predicate that we failed to satisfy is a `Fn`-like trait. - if let ObligationCauseCode::SpannedItemInExpr(def_id, _, _, idx) = cause + if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = cause && let predicates = self.tcx.predicates_of(def_id).instantiate_identity(self.tcx) && let Some(pred) = predicates.predicates.get(*idx) && let ty::ClauseKind::Trait(trait_pred) = pred.kind().skip_binder() @@ -2743,12 +2744,12 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { ObligationCauseCode::TupleElem => { err.note("only the last element of a tuple may have a dynamically sized type"); } - ObligationCauseCode::MiscItem(_) | ObligationCauseCode::MiscItemInExpr(..) => { + ObligationCauseCode::WhereClause(_) | ObligationCauseCode::WhereClauseInExpr(..) => { // We hold the `DefId` of the item introducing the obligation, but displaying it // doesn't add user usable information. It always point at an associated item. } - ObligationCauseCode::SpannedItem(item_def_id, span) - | ObligationCauseCode::SpannedItemInExpr(item_def_id, span, ..) => { + ObligationCauseCode::SpannedWhereClause(item_def_id, span) + | ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..) => { let item_name = tcx.def_path_str(item_def_id); let short_item_name = with_forced_trimmed_paths!(tcx.def_path_str(item_def_id)); let mut multispan = MultiSpan::from(span); @@ -3799,7 +3800,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { // to an associated type (as seen from `trait_pred`) in the predicate. Like in // trait_pred `S: Sum<<Self as Iterator>::Item>` and predicate `i32: Sum<&()>` let mut type_diffs = vec![]; - if let ObligationCauseCode::SpannedItemInExpr(def_id, _, _, idx) = parent_code + if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = parent_code && let Some(node_args) = typeck_results.node_args_opt(call_hir_id) && let where_clauses = self.tcx.predicates_of(def_id).instantiate(self.tcx, node_args) diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs index f3a4e933164..de8ec17b113 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs @@ -1533,10 +1533,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { *err, ); let code = error.obligation.cause.code().peel_derives().peel_match_impls(); - if let ObligationCauseCode::SpannedItem(..) - | ObligationCauseCode::MiscItem(..) - | ObligationCauseCode::SpannedItemInExpr(..) - | ObligationCauseCode::MiscItemInExpr(..) = code + if let ObligationCauseCode::SpannedWhereClause(..) + | ObligationCauseCode::WhereClause(..) + | ObligationCauseCode::SpannedWhereClauseInExpr(..) + | ObligationCauseCode::WhereClauseInExpr(..) = code { self.note_obligation_cause_code( error.obligation.cause.body_id, @@ -1610,10 +1610,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { let is_normalized_term_expected = !matches!( obligation.cause.code().peel_derives(), - ObligationCauseCode::MiscItem(_) - | ObligationCauseCode::SpannedItem(_, _) - | ObligationCauseCode::MiscItemInExpr(..) - | ObligationCauseCode::SpannedItemInExpr(..) + ObligationCauseCode::WhereClause(_) + | ObligationCauseCode::SpannedWhereClause(_, _) + | ObligationCauseCode::WhereClauseInExpr(..) + | ObligationCauseCode::SpannedWhereClauseInExpr(..) | ObligationCauseCode::Coercion { .. } ); @@ -2445,8 +2445,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { } } - if let ObligationCauseCode::MiscItem(def_id) - | ObligationCauseCode::MiscItemInExpr(def_id, ..) = *obligation.cause.code() + if let ObligationCauseCode::WhereClause(def_id) + | ObligationCauseCode::WhereClauseInExpr(def_id, ..) = *obligation.cause.code() { self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id()); } @@ -2881,8 +2881,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { else { return; }; - let (ObligationCauseCode::SpannedItem(item_def_id, span) - | ObligationCauseCode::SpannedItemInExpr(item_def_id, span, ..)) = + let (ObligationCauseCode::SpannedWhereClause(item_def_id, span) + | ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..)) = *obligation.cause.code().peel_derives() else { return; @@ -3179,7 +3179,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { ObligationCauseCode::RustCall => { err.primary_message("functions with the \"rust-call\" ABI must take a single non-self tuple argument"); } - ObligationCauseCode::SpannedItem(def_id, _) | ObligationCauseCode::MiscItem(def_id) + ObligationCauseCode::SpannedWhereClause(def_id, _) + | ObligationCauseCode::WhereClause(def_id) if self.tcx.is_fn_trait(*def_id) => { err.code(E0059); diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs index e99ecff44f9..0aafc1a2efe 100644 --- a/compiler/rustc_trait_selection/src/traits/project.rs +++ b/compiler/rustc_trait_selection/src/traits/project.rs @@ -574,9 +574,9 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>( // diagnostics which is not ideal. // Consider creating separate cause codes for this specific situation. if span.is_dummy() { - ObligationCauseCode::MiscItem(alias_ty.def_id) + ObligationCauseCode::WhereClause(alias_ty.def_id) } else { - ObligationCauseCode::SpannedItem(alias_ty.def_id, span) + ObligationCauseCode::SpannedWhereClause(alias_ty.def_id, span) }, ); @@ -2123,13 +2123,13 @@ fn assoc_ty_own_obligations<'cx, 'tcx>( ObligationCause::new( obligation.cause.span, obligation.cause.body_id, - ObligationCauseCode::MiscItem(obligation.predicate.def_id), + ObligationCauseCode::WhereClause(obligation.predicate.def_id), ) } else { ObligationCause::new( obligation.cause.span, obligation.cause.body_id, - ObligationCauseCode::SpannedItem(obligation.predicate.def_id, span), + ObligationCauseCode::SpannedWhereClause(obligation.predicate.def_id, span), ) }; nested.push(Obligation::with_depth( diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs index d4eb3af3b64..ebcda61f2ad 100644 --- a/compiler/rustc_trait_selection/src/traits/wf.rs +++ b/compiler/rustc_trait_selection/src/traits/wf.rs @@ -566,9 +566,9 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> { iter::zip(predicates, origins.into_iter().rev()) .map(|((pred, span), origin_def_id)| { let code = if span.is_dummy() { - ObligationCauseCode::MiscItem(origin_def_id) + ObligationCauseCode::WhereClause(origin_def_id) } else { - ObligationCauseCode::SpannedItem(origin_def_id, span) + ObligationCauseCode::SpannedWhereClause(origin_def_id, span) }; let cause = self.cause(code); traits::Obligation::with_depth( |