Auto merge of #163081 - estebank:not-general-enough, r=<try>

Provide more context on "not general enough" error

Author: bors

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -415,7 +415,7 @@ impl<'tcx> BorrowExplanation<'tcx> {
                 let mut preds = path
                     .iter()
                     .filter_map(|constraint| match constraint.category {
-                        ConstraintCategory::Predicate(pred) if !pred.is_dummy() => Some(pred),
+                        ConstraintCategory::Predicate(pred, _) if !pred.is_dummy() => Some(pred),
                         _ => None,
                     })
                     .collect::<Vec<Span>>();

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

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

compiler/rustc_borrowck/src/lib.rs

@@ -232,7 +232,7 @@ pub struct ClosureOutlivesRequirement<'tcx> {
 
 // Make sure this enum doesn't unintentionally grow
 #[cfg(target_pointer_width = "64")]
-rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 16);
+rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 24);
 
 /// The subject of a `ClosureOutlivesRequirement` -- that is, the thing
 /// that must outlive some region.

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1790,7 +1790,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                 // Generic arguments are unlikely to be what relates regions together
                 ConstraintCategory::TypeAnnotation(AnnotationSource::GenericArg) => 3,
                 // We handle predicates and opaque types specially; don't prioritize them here.
-                ConstraintCategory::Predicate(_) | ConstraintCategory::OpaqueType => 4,
+                ConstraintCategory::Predicate(_, _) | ConstraintCategory::OpaqueType => 4,
                 // `Boring` constraints can correspond to user-written code and have useful spans,
                 // but don't provide any other useful information for diagnostics.
                 ConstraintCategory::Boring => 5,
@@ -1928,11 +1928,11 @@ impl<'tcx> BestBlame<'tcx> {
             .path
             .iter()
             .find_map(|constraint| {
-                if let ConstraintCategory::Predicate(predicate_span) = constraint.category {
+                if let ConstraintCategory::Predicate(predicate_span, def_id) = 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::WhereClause(CRATE_DEF_ID.to_def_id(), predicate_span))
+                    Some(ObligationCauseCode::WhereClause(def_id, predicate_span))
                 } else {
                     None
                 }

compiler/rustc_borrowck/src/type_check/canonical.rs

@@ -142,15 +142,13 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     pub(super) fn normalize_and_prove_instantiated_clauses(
         &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_clauses: ty::InstantiatedClauses<'tcx>,
         locations: Locations,
     ) {
         for (clause, span) in instantiated_clauses {
             debug!(?span, ?clause);
-            let category = ConstraintCategory::Predicate(span);
+            let category = ConstraintCategory::Predicate(span, def_id);
             let clause = self.normalize_with_category(clause, locations, category);
             self.prove_clause(clause, locations, category);
         }

compiler/rustc_infer/src/infer/mod.rs

@@ -465,7 +465,7 @@ pub enum SubregionOrigin<'tcx> {
         trait_item_def_id: DefId,
     },
 
-    AscribeUserTypeProvePredicate(Span),
+    AscribeUserTypeProvePredicate(Span, DefId),
 
     // FIXME(-Zassumptions-on-binders): this is a temporary hack until we support
     // proper diagnostics for solver region constraints.
@@ -480,7 +480,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(span, def_id) => {
+                ConstraintCategory::Predicate(*span, *def_id)
+            }
             Self::SolverRegionConstraint(span) => ConstraintCategory::SolverRegionConstraint(*span),
             _ => ConstraintCategory::BoringNoLocation,
         }
@@ -1836,7 +1838,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
             SubregionOrigin::Reborrow(a) => a,
             SubregionOrigin::ReferenceOutlivesReferent(_, a) => a,
             SubregionOrigin::CompareImplItemObligation { span, .. } => span,
-            SubregionOrigin::AscribeUserTypeProvePredicate(span) => span,
+            SubregionOrigin::AscribeUserTypeProvePredicate(span, _) => span,
             SubregionOrigin::CheckAssociatedTypeBounds { ref parent, .. } => parent.span(),
             SubregionOrigin::SolverRegionConstraint(a) => a,
         }
@@ -1870,8 +1872,8 @@ impl<'tcx> SubregionOrigin<'tcx> {
                 parent: Box::new(default()),
             },
 
-            traits::ObligationCauseCode::AscribeUserTypeProvePredicate(span) => {
-                SubregionOrigin::AscribeUserTypeProvePredicate(span)
+            traits::ObligationCauseCode::AscribeUserTypeProvePredicate(span, def_id) => {
+                SubregionOrigin::AscribeUserTypeProvePredicate(span, def_id)
             }
 
             traits::ObligationCauseCode::ObjectTypeBound(ty, _reg) => {

compiler/rustc_middle/src/mir/query.rs

@@ -7,6 +7,7 @@ use rustc_errors::ErrorGuaranteed;
 use rustc_index::IndexVec;
 use rustc_index::bit_set::BitMatrix;
 use rustc_macros::{StableHash, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
+use rustc_span::def_id::DefId;
 use rustc_span::{Span, Symbol};
 
 use super::{ConstValue, SourceInfo};
@@ -129,7 +130,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(Span, DefId),
 
     /// 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

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

compiler/rustc_trait_selection/src/diagnostics.rs

@@ -1166,7 +1166,7 @@ impl<'tcx> ActualImplExplNotes<'tcx> {
 pub(crate) struct TraitPlaceholderMismatch<'tcx> {
     #[primary_span]
     pub span: Span,
-    #[label("doesn't satisfy where-clause")]
+    #[label("unsatisfied where-clause on `{$def_id}`")]
     pub satisfy_span: Option<Span>,
     #[label("due to a where-clause on `{$def_id}`...")]
     pub where_span: Option<Span>,

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

@@ -255,15 +255,43 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
     ) -> Diag<'tcx> {
         let span = cause.span;
 
+        let mut code = cause.code();
+        loop {
+            match code {
+                ObligationCauseCode::MatchImpl(inner_cause, _) => {
+                    code = inner_cause.code();
+                }
+                ObligationCauseCode::ImplDerived(derived) => {
+                    code = &derived.derived.parent_code;
+                }
+                ObligationCauseCode::BuiltinDerived(derived) => {
+                    code = &derived.parent_code;
+                }
+                ObligationCauseCode::WellFormedDerived(derived) => {
+                    code = &derived.parent_code;
+                }
+                ObligationCauseCode::ImplDerivedHost(derived) => {
+                    code = &derived.derived.parent_code;
+                }
+                ObligationCauseCode::BuiltinDerivedHost(derived) => {
+                    code = &derived.parent_code;
+                }
+                _ => break,
+            }
+        }
         let (leading_ellipsis, satisfy_span, where_span, dup_span, def_id) =
             if let ObligationCauseCode::WhereClause(def_id, span)
-            | ObligationCauseCode::WhereClauseInExpr(def_id, span, ..) = *cause.code()
+            | ObligationCauseCode::WhereClauseInExpr(def_id, span, ..) = *code
                 && def_id != CRATE_DEF_ID.to_def_id()
             {
                 (
                     true,
                     Some(span),
-                    Some(self.tcx().def_span(def_id)),
+                    Some(
+                        self.tcx()
+                            .opt_item_ident(def_id)
+                            .map_or_else(|| self.tcx().def_span(def_id), |n| n.span),
+                    ),
                     None,
                     self.tcx().def_path_str(def_id),
                 )
@@ -356,6 +384,17 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
 
         let mut current_code = cause.code();
         let mut coroutine_def_id = None;
+        if cause.body_def_id != CRATE_DEF_ID {
+            self.cx.note_obligation_cause_code(
+                cause.body_def_id,
+                &mut err,
+                actual_trait_ref,
+                self.tcx().param_env(cause.body_def_id),
+                cause.code(),
+                &mut vec![],
+                &mut Default::default(),
+            );
+        }
 
         loop {
             match current_code {