Introduce traits::util::filter_predicates

Author: estebank

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -19,7 +19,7 @@ use rustc_infer::infer::{
     error_reporting::unexpected_hidden_region_diagnostic,
     BoundRegionConversionTime, NllRegionVariableOrigin, RelateParamBound,
 };
-use rustc_infer::traits::util::elaborate_predicates_of;
+use rustc_infer::traits::util::{elaborate_predicates_of, filter_predicates};
 use rustc_middle::hir::place::PlaceBase;
 use rustc_middle::mir::{ConstraintCategory, ReturnConstraint};
 use rustc_middle::traits::ObligationCauseCode;
@@ -692,20 +692,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
         let mut predicates: Vec<Span> = elaborate_predicates_of(tcx, def_id)
             .chain(elaborate_predicates_of(tcx, parent))
             .chain(trait_preds)
-            .filter_map(|(pred, pred_span)| {
-                if let ty::PredicateKind::Clause(clause) = pred.kind().skip_binder()
-                    && let ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(pred_ty, r)) = clause
-                    && r.kind() == ty::ReStatic
-                    && (self.infcx.can_eq(self.param_env, ty, pred_ty)
-                        || matches!(
+            .filter_map(filter_predicates(tcx.lifetimes.re_static, |pred_ty| {
+                self.infcx.can_eq(self.param_env, ty, pred_ty)
+                    || matches!(
                         pred_ty.kind(),
-                        ty::Param(name) if name.name == kw::SelfUpper))
-                {
-                    Some(pred_span)
-                } else {
-                    None
-                }
-            })
+                        ty::Param(name) if name.name == kw::SelfUpper)
+            }))
             .collect();
         debug!(?predicates);
 

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

@@ -53,7 +53,7 @@ use crate::errors::{self, ObligationCauseFailureCode, TypeErrorAdditionalDiags};
 use crate::infer;
 use crate::infer::error_reporting::nice_region_error::find_anon_type::find_anon_type;
 use crate::infer::ExpectedFound;
-use crate::traits::util::elaborate_predicates_of;
+use crate::traits::util::{elaborate_predicates_of, filter_predicates};
 use crate::traits::{
     IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode,
     PredicateObligation,
@@ -498,20 +498,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                                     self.tcx,
                                     generic_param_scope.into(),
                                 ))
-                                .filter_map(|(pred, pred_span)| {
-                                    if let ty::PredicateKind::Clause(clause) =
-                                        pred.kind().skip_binder()
-                                        && let ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(
-                                            _pred_ty,
-                                            r,
-                                        )) = clause
-                                        && r.kind() == ty::ReStatic
-                                    {
-                                        Some(pred_span)
-                                    } else {
-                                        None
-                                    }
-                                })
+                                .filter_map(filter_predicates(self.tcx.lifetimes.re_static, |_| {
+                                    true
+                                }))
                                 .collect();
 
                             if !spans.is_empty() {
@@ -2750,19 +2739,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                             if let Some(def_id) = ptr.trait_ref.trait_def_id() {
                                 // Find the bounds on the trait with the lifetime that couldn't be met.
                                 let bindings: Vec<Span> = elaborate_predicates_of(self.tcx, def_id)
-                                    .filter_map(|(pred, pred_span)| {
-                                        if let ty::PredicateKind::Clause(clause) =
-                                            pred.kind().skip_binder()
-                                            && let ty::ClauseKind::TypeOutlives(
-                                                ty::OutlivesPredicate(_pred_ty, r),
-                                            ) = clause
-                                            && r == self.found_region
-                                        {
-                                            Some(pred_span)
-                                        } else {
-                                            None
-                                        }
-                                    })
+                                    .filter_map(filter_predicates(self.found_region, |_| true))
                                     .collect();
                                 if !bindings.is_empty() {
                                     self.lifetime_spans.insert(ptr.span);
@@ -2775,21 +2752,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     // definition of that associated item couldn't meet.
                     hir::TyKind::Path(hir::QPath::Resolved(Some(_), path)) => {
                         self.pred_spans = elaborate_predicates_of(self.tcx, path.res.def_id())
-                            .filter_map(|(pred, pred_span)| {
-                                match pred.kind().skip_binder() {
-                                    ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(
-                                        ty::OutlivesPredicate(
-                                            // What should I filter this with?
-                                            _pred_ty,
-                                            r,
-                                        ),
-                                    )) if r == self.found_region => Some(pred_span),
-                                    ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(
-                                        ty::OutlivesPredicate(_, r),
-                                    )) if r == self.found_region => Some(pred_span),
-                                    _ => None,
-                                }
-                            })
+                            .filter_map(filter_predicates(self.found_region, |_| true))
                             .collect();
                     }
                     _ => {}

compiler/rustc_infer/src/traits/util.rs

@@ -246,6 +246,27 @@ pub fn elaborate_predicates_of<'tcx>(
     )
 }
 
+pub fn filter_predicates<'tcx>(
+    region: ty::Region<'tcx>,
+    check_ty: impl Fn(Ty<'tcx>) -> bool,
+) -> impl Fn((ty::Predicate<'tcx>, Span)) -> Option<Span> {
+    move |(pred, span)| {
+        let ty::PredicateKind::Clause(clause) = pred.kind().skip_binder() else {
+            return None;
+        };
+        match clause {
+            ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(pred_ty, r))
+                if r == region && check_ty(pred_ty) =>
+            {
+                Some(span)
+            }
+            ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(_, r)) if r == region => {
+                Some(span)
+            }
+            _ => None,
+        }
+    }
+}
 impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
     fn extend_deduped(&mut self, obligations: impl IntoIterator<Item = O>) {
         // Only keep those bounds that we haven't already seen.