Auto merge of rust-lang#124977 - compiler-errors:higher-ranked-err, r=<try>

Improve location reporting of trait placeholder error

Self-explanatory

Author: bors

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -63,7 +63,7 @@ impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
             ConstraintCategory::OpaqueType => "opaque type ",
             ConstraintCategory::ClosureUpvar(_) => "closure capture ",
             ConstraintCategory::Usage => "this usage ",
-            ConstraintCategory::Predicate(_)
+            ConstraintCategory::Predicate(..)
             | ConstraintCategory::Boring
             | ConstraintCategory::BoringNoLocation
             | ConstraintCategory::Internal => "",

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -2040,7 +2040,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 continue;
             };
             debug!(?constraint, ?p);
-            let ConstraintCategory::Predicate(span) = constraint.category else {
+            let ConstraintCategory::Predicate(_, span) = constraint.category else {
                 continue;
             };
             extra_info.push(ExtraConstraintInfo::PlaceholderFromPredicate(span));
@@ -2055,14 +2055,13 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         let cause_code = path
             .iter()
             .find_map(|constraint| {
-                if let ConstraintCategory::Predicate(predicate_span) = constraint.category {
+                if let ConstraintCategory::Predicate(source_def_id, predicate_span) =
+                    constraint.category
+                {
                     // We currently do not store the `DefId` in the `ConstraintCategory`
                     // for performances reasons. The error reporting code used by NLL only
                     // uses the span, so this doesn't cause any problems at the moment.
-                    Some(ObligationCauseCode::BindingObligation(
-                        CRATE_DEF_ID.to_def_id(),
-                        predicate_span,
-                    ))
+                    Some(ObligationCauseCode::BindingObligation(source_def_id, predicate_span))
                 } else {
                     None
                 }
@@ -2156,7 +2155,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     | ConstraintCategory::Boring
                     | ConstraintCategory::BoringNoLocation
                     | ConstraintCategory::Internal
-                    | ConstraintCategory::Predicate(_) => false,
+                    | ConstraintCategory::Predicate(..) => false,
                     ConstraintCategory::TypeAnnotation
                     | ConstraintCategory::Return(_)
                     | ConstraintCategory::Yield => true,
@@ -2169,7 +2168,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                         | ConstraintCategory::Boring
                         | ConstraintCategory::BoringNoLocation
                         | ConstraintCategory::Internal
-                        | ConstraintCategory::Predicate(_)
+                        | ConstraintCategory::Predicate(..)
                 )
             }
         };

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -101,13 +101,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         &mut self,
         // Keep this parameter for now, in case we start using
         // it in `ConstraintCategory` at some point.
-        _def_id: DefId,
+        def_id: DefId,
         instantiated_predicates: ty::InstantiatedPredicates<'tcx>,
         locations: Locations,
     ) {
         for (predicate, span) in instantiated_predicates {
             debug!(?span, ?predicate);
-            let category = ConstraintCategory::Predicate(span);
+            let category = ConstraintCategory::Predicate(def_id, span);
             let predicate = self.normalize_with_category(predicate, locations, category);
             self.prove_predicate(predicate, locations, category);
         }

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -239,20 +239,21 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
     ) -> Diag<'tcx> {
         let span = cause.span();
 
-        let (leading_ellipsis, satisfy_span, where_span, dup_span, def_id) =
-            if let ObligationCauseCode::ItemObligation(def_id)
-            | ObligationCauseCode::ExprItemObligation(def_id, ..) = *cause.code()
-            {
-                (
-                    true,
-                    Some(span),
-                    Some(self.tcx().def_span(def_id)),
-                    None,
-                    self.tcx().def_path_str(def_id),
-                )
-            } else {
-                (false, None, None, Some(span), String::new())
-            };
+        let (leading_ellipsis, satisfy_span, where_span, dup_span, def_id) = match *cause.code() {
+            ObligationCauseCode::ItemObligation(def_id)
+            | ObligationCauseCode::ExprItemObligation(def_id, ..) => (
+                true,
+                Some(span),
+                self.tcx().def_ident_span(def_id),
+                None,
+                self.tcx().def_path_str(def_id),
+            ),
+            ObligationCauseCode::BindingObligation(def_id, pred_span)
+            | ObligationCauseCode::ExprBindingObligation(def_id, pred_span, ..) => {
+                (true, Some(span), Some(pred_span), None, self.tcx().def_path_str(def_id))
+            }
+            _ => (false, None, None, Some(span), String::new()),
+        };
 
         let expected_trait_ref = self.cx.resolve_vars_if_possible(ty::TraitRef::new(
             self.cx.tcx,

compiler/rustc_infer/src/infer/error_reporting/note.rs

@@ -63,7 +63,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             infer::CheckAssociatedTypeBounds { ref parent, .. } => {
                 self.note_region_origin(err, parent);
             }
-            infer::AscribeUserTypeProvePredicate(span) => {
+            infer::AscribeUserTypeProvePredicate(_, span) => {
                 RegionOriginNote::Plain {
                     span,
                     msg: fluent::infer_ascribe_user_type_prove_predicate,
@@ -259,7 +259,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 );
                 err
             }
-            infer::AscribeUserTypeProvePredicate(span) => {
+            infer::AscribeUserTypeProvePredicate(_, span) => {
                 let instantiated = note_and_explain::RegionExplanation::new(
                     self.tcx,
                     sup,

compiler/rustc_infer/src/infer/mod.rs

@@ -474,7 +474,7 @@ pub enum SubregionOrigin<'tcx> {
         trait_item_def_id: DefId,
     },
 
-    AscribeUserTypeProvePredicate(Span),
+    AscribeUserTypeProvePredicate(DefId, Span),
 }
 
 // `SubregionOrigin` is used a lot. Make sure it doesn't unintentionally get bigger.
@@ -485,7 +485,9 @@ impl<'tcx> SubregionOrigin<'tcx> {
     pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
         match self {
             Self::Subtype(type_trace) => type_trace.cause.to_constraint_category(),
-            Self::AscribeUserTypeProvePredicate(span) => ConstraintCategory::Predicate(*span),
+            Self::AscribeUserTypeProvePredicate(def_id, span) => {
+                ConstraintCategory::Predicate(*def_id, *span)
+            }
             _ => ConstraintCategory::BoringNoLocation,
         }
     }
@@ -1862,7 +1864,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
             Reborrow(a) => a,
             ReferenceOutlivesReferent(_, a) => a,
             CompareImplItemObligation { span, .. } => span,
-            AscribeUserTypeProvePredicate(span) => span,
+            AscribeUserTypeProvePredicate(_, span) => span,
             CheckAssociatedTypeBounds { ref parent, .. } => parent.span(),
         }
     }
@@ -1895,8 +1897,8 @@ impl<'tcx> SubregionOrigin<'tcx> {
                 parent: Box::new(default()),
             },
 
-            traits::ObligationCauseCode::AscribeUserTypeProvePredicate(span) => {
-                SubregionOrigin::AscribeUserTypeProvePredicate(span)
+            traits::ObligationCauseCode::AscribeUserTypeProvePredicate(def_id, span) => {
+                SubregionOrigin::AscribeUserTypeProvePredicate(def_id, span)
             }
 
             _ => default(),

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -67,6 +67,7 @@ use crate::infer::snapshot::undo_log::UndoLog;
 use crate::infer::{self, GenericKind, InferCtxt, RegionObligation, SubregionOrigin, VerifyBound};
 use crate::traits::{ObligationCause, ObligationCauseCode};
 use rustc_data_structures::undo_log::UndoLogs;
+use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_middle::mir::ConstraintCategory;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::{
@@ -148,11 +149,20 @@ impl<'tcx> InferCtxt<'tcx> {
                 Some(
                     deeply_normalize_ty(
                         outlives,
-                        SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP),
+                        SubregionOrigin::AscribeUserTypeProvePredicate(
+                            CRATE_DEF_ID.to_def_id(),
+                            DUMMY_SP,
+                        ),
                     )
                     // FIXME(-Znext-solver): How do we accurately report an error span here :(
                     .map_err(|NoSolution| {
-                        (outlives, SubregionOrigin::AscribeUserTypeProvePredicate(DUMMY_SP))
+                        (
+                            outlives,
+                            SubregionOrigin::AscribeUserTypeProvePredicate(
+                                CRATE_DEF_ID.to_def_id(),
+                                DUMMY_SP,
+                            ),
+                        )
                     }),
                 )
             })

compiler/rustc_middle/src/mir/query.rs

@@ -4,7 +4,7 @@ use crate::mir;
 use crate::ty::{self, OpaqueHiddenType, Ty, TyCtxt};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::def_id::LocalDefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_index::bit_set::BitMatrix;
 use rustc_index::{Idx, IndexVec};
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
@@ -263,7 +263,7 @@ pub enum ConstraintCategory<'tcx> {
     /// A constraint from a user-written predicate
     /// with the provided span, written on the item
     /// with the given `DefId`
-    Predicate(Span),
+    Predicate(#[derivative(PartialOrd = "ignore", Ord = "ignore")] DefId, Span),
 
     /// A "boring" constraint (caused by the given location) is one that
     /// the user probably doesn't want to see described in diagnostics,

compiler/rustc_middle/src/traits/mod.rs

@@ -189,9 +189,9 @@ impl<'tcx> ObligationCause<'tcx> {
 
     pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
         match self.code() {
-            MatchImpl(cause, _) => cause.to_constraint_category(),
-            AscribeUserTypeProvePredicate(predicate_span) => {
-                ConstraintCategory::Predicate(*predicate_span)
+            ObligationCauseCode::MatchImpl(cause, _) => cause.to_constraint_category(),
+            ObligationCauseCode::AscribeUserTypeProvePredicate(def_id, predicate_span) => {
+                ConstraintCategory::Predicate(*def_id, *predicate_span)
             }
             _ => ConstraintCategory::BoringNoLocation,
         }
@@ -447,7 +447,7 @@ pub enum ObligationCauseCode<'tcx> {
         output_ty: Option<Ty<'tcx>>,
     },
 
-    AscribeUserTypeProvePredicate(Span),
+    AscribeUserTypeProvePredicate(DefId, Span),
 
     RustCall,
 

compiler/rustc_trait_selection/src/traits/query/type_op/ascribe_user_type.rs

@@ -107,8 +107,8 @@ fn relate_mir_and_user_args<'tcx>(
         let span = if span == DUMMY_SP { predicate_span } else { span };
         let cause = ObligationCause::new(
             span,
-            CRATE_DEF_ID,
-            ObligationCauseCode::AscribeUserTypeProvePredicate(predicate_span),
+            def_id.as_local().unwrap_or(CRATE_DEF_ID),
+            ObligationCauseCode::AscribeUserTypeProvePredicate(def_id, predicate_span),
         );
         let instantiated_predicate =
             ocx.normalize(&cause.clone(), param_env, instantiated_predicate);
@@ -118,7 +118,7 @@ fn relate_mir_and_user_args<'tcx>(
 
     // Now prove the well-formedness of `def_id` with `args`.
     // Note for some items, proving the WF of `ty` is not sufficient because the
-    // well-formedness of an item may depend on the WF of gneneric args not present in the
+    // well-formedness of an item may depend on the WF of generic args not present in the
     // item's type. Currently this is true for associated consts, e.g.:
     // ```rust
     // impl<T> MyTy<T> {