Auto merge of rust-lang#125153 - compiler-errors:opt-poly, r=lcnr

bors · bors · commit 1a7397988684 · 2024-05-17T18:23:47.000Z
`to_opt_poly_X_pred` -&gt; `as_X_clause`

r? lcnr
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -2250,7 +2250,7 @@ fn try_report_async_mismatch<'tcx>(
     for error in errors {
         if let ObligationCauseCode::WhereClause(def_id, _) = *error.root_obligation.cause.code()
             && def_id == async_future_def_id
-            && let Some(proj) = error.root_obligation.predicate.to_opt_poly_projection_pred()
+            && let Some(proj) = error.root_obligation.predicate.as_projection_clause()
             && let Some(proj) = proj.no_bound_vars()
             && infcx.can_eq(
                 error.root_obligation.param_env,
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1350,12 +1350,12 @@ fn check_impl<'tcx>(
                         // We already have a better span.
                         continue;
                     }
-                    if let Some(pred) = obligation.predicate.to_opt_poly_trait_pred()
+                    if let Some(pred) = obligation.predicate.as_trait_clause()
                         && pred.skip_binder().self_ty() == trait_ref.self_ty()
                     {
                         obligation.cause.span = hir_self_ty.span;
                     }
-                    if let Some(pred) = obligation.predicate.to_opt_poly_projection_pred()
+                    if let Some(pred) = obligation.predicate.as_projection_clause()
                         && pred.skip_binder().self_ty() == trait_ref.self_ty()
                     {
                         obligation.cause.span = hir_self_ty.span;
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
@@ -583,7 +583,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         if !errors.is_empty() {
                             for error in errors {
                                 if let Some(trait_pred) =
-                                    error.obligation.predicate.to_opt_poly_trait_pred()
+                                    error.obligation.predicate.as_trait_clause()
                                 {
                                     let output_associated_item = match error.obligation.cause.code()
                                     {
@@ -797,9 +797,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     );
 
                     if operand_ty.has_non_region_param() {
-                        let predicates = errors.iter().filter_map(|error| {
-                            error.obligation.predicate.to_opt_poly_trait_pred()
-                        });
+                        let predicates = errors
+                            .iter()
+                            .filter_map(|error| error.obligation.predicate.as_trait_clause());
                         for pred in predicates {
                             self.err_ctxt().suggest_restricting_param_bound(
                                 &mut err,
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
@@ -455,7 +455,7 @@ impl<'tcx, I: Iterator<Item = ty::Predicate<'tcx>>> Iterator for FilterToTraits<
 
     fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
         while let Some(pred) = self.base_iterator.next() {
-            if let Some(data) = pred.to_opt_poly_trait_pred() {
+            if let Some(data) = pred.as_trait_clause() {
                 return Some(data.map_bound(|t| t.trait_ref));
             }
         }
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
@@ -702,7 +702,7 @@ impl<'tcx> UpcastFrom<TyCtxt<'tcx>, NormalizesTo<'tcx>> for Predicate<'tcx> {
 }
 
 impl<'tcx> Predicate<'tcx> {
-    pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {
+    pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'tcx>> {
         let predicate = self.kind();
         match predicate.skip_binder() {
             PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
@@ -722,7 +722,7 @@ impl<'tcx> Predicate<'tcx> {
         }
     }
 
-    pub fn to_opt_poly_projection_pred(self) -> Option<PolyProjectionPredicate<'tcx>> {
+    pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'tcx>> {
         let predicate = self.kind();
         match predicate.skip_binder() {
             PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -2739,7 +2739,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             | ObligationCauseCode::ReferenceOutlivesReferent(..)
             | ObligationCauseCode::ObjectTypeBound(..) => {}
             ObligationCauseCode::RustCall => {
-                if let Some(pred) = predicate.to_opt_poly_trait_pred()
+                if let Some(pred) = predicate.as_trait_clause()
                     && Some(pred.def_id()) == tcx.lang_items().sized_trait()
                 {
                     err.note("argument required to be sized due to `extern \"rust-call\"` ABI");
@@ -3725,7 +3725,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         {
             if let hir::Expr { kind: hir::ExprKind::MethodCall(_, rcvr, _, _), .. } = expr
                 && let Some(ty) = typeck_results.node_type_opt(rcvr.hir_id)
-                && let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()
+                && let Some(failed_pred) = failed_pred.as_trait_clause()
                 && let pred = failed_pred.map_bound(|pred| pred.with_self_ty(tcx, ty))
                 && self.predicate_must_hold_modulo_regions(&Obligation::misc(
                     tcx, expr.span, body_id, param_env, pred,
@@ -3816,7 +3816,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                 && let Some(where_pred) = where_clauses.predicates.get(*idx)
             {
                 if let Some(where_pred) = where_pred.as_trait_clause()
-                    && let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()
+                    && let Some(failed_pred) = failed_pred.as_trait_clause()
                 {
                     self.enter_forall(where_pred, |where_pred| {
                         let failed_pred = self.instantiate_binder_with_fresh_vars(
@@ -3842,7 +3842,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                         }
                     })
                 } else if let Some(where_pred) = where_pred.as_projection_clause()
-                    && let Some(failed_pred) = failed_pred.to_opt_poly_projection_pred()
+                    && let Some(failed_pred) = failed_pred.as_projection_clause()
                     && let Some(found) = failed_pred.skip_binder().term.ty()
                 {
                     type_diffs = vec![Sorts(ty::error::ExpectedFound {
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
@@ -1417,7 +1417,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         };
 
         let mut code = obligation.cause.code();
-        let mut pred = obligation.predicate.to_opt_poly_trait_pred();
+        let mut pred = obligation.predicate.as_trait_clause();
         while let Some((next_code, next_pred)) = code.parent() {
             if let Some(pred) = pred {
                 self.enter_forall(pred, |pred| {
@@ -1481,16 +1481,16 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             return true;
         }
 
-        if let Some(error) = error.to_opt_poly_trait_pred() {
+        if let Some(error) = error.as_trait_clause() {
             self.enter_forall(error, |error| {
                 elaborate(self.tcx, std::iter::once(cond))
-                    .filter_map(|implied| implied.to_opt_poly_trait_pred())
+                    .filter_map(|implied| implied.as_trait_clause())
                     .any(|implied| self.can_match_trait(error, implied))
             })
-        } else if let Some(error) = error.to_opt_poly_projection_pred() {
+        } else if let Some(error) = error.as_projection_clause() {
             self.enter_forall(error, |error| {
                 elaborate(self.tcx, std::iter::once(cond))
-                    .filter_map(|implied| implied.to_opt_poly_projection_pred())
+                    .filter_map(|implied| implied.as_projection_clause())
                     .any(|implied| self.can_match_projection(error, implied))
             })
         } else {
@@ -2415,8 +2415,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                         return e;
                     }
                     err.note(format!("cannot satisfy `{predicate}`"));
-                    let impl_candidates = self
-                        .find_similar_impl_candidates(predicate.to_opt_poly_trait_pred().unwrap());
+                    let impl_candidates =
+                        self.find_similar_impl_candidates(predicate.as_trait_clause().unwrap());
                     if impl_candidates.len() < 40 {
                         self.report_similar_impl_candidates(
                             impl_candidates.as_slice(),
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -653,7 +653,7 @@ fn object_ty_for_trait<'tcx>(
     let mut elaborated_predicates: Vec<_> = elaborate(tcx, [pred])
         .filter_map(|pred| {
             debug!(?pred);
-            let pred = pred.to_opt_poly_projection_pred()?;
+            let pred = pred.as_projection_clause()?;
             Some(pred.map_bound(|p| {
                 ty::ExistentialPredicate::Projection(ty::ExistentialProjection::erase_self_ty(
                     tcx, p,
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -377,7 +377,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         let item = self.item;
 
         let extend = |traits::PredicateObligation { predicate, mut cause, .. }| {
-            if let Some(parent_trait_pred) = predicate.to_opt_poly_trait_pred() {
+            if let Some(parent_trait_pred) = predicate.as_trait_clause() {
                 cause = cause.derived_cause(
                     parent_trait_pred,
                     traits::ObligationCauseCode::WellFormedDerived,

Original file line number	Diff line number	Diff line change
`@@ -1350,12 +1350,12 @@ fn check_impl<'tcx>(`
`1350`	`1350`	`// We already have a better span.`
`1351`	`1351`	`continue;`
`1352`	`1352`	`}`
`1353`		`- if let Some(pred) = obligation.predicate.to_opt_poly_trait_pred()`
	`1353`	`+ if let Some(pred) = obligation.predicate.as_trait_clause()`
`1354`	`1354`	`&& pred.skip_binder().self_ty() == trait_ref.self_ty()`
`1355`	`1355`	`{`
`1356`	`1356`	`obligation.cause.span = hir_self_ty.span;`
`1357`	`1357`	`}`
`1358`		`- if let Some(pred) = obligation.predicate.to_opt_poly_projection_pred()`
	`1358`	`+ if let Some(pred) = obligation.predicate.as_projection_clause()`
`1359`	`1359`	`&& pred.skip_binder().self_ty() == trait_ref.self_ty()`
`1360`	`1360`	`{`
`1361`	`1361`	`obligation.cause.span = hir_self_ty.span;`
Original file line number	Diff line number	Diff line change
`@@ -455,7 +455,7 @@ impl<'tcx, I: Iterator<Item = ty::Predicate<'tcx>>> Iterator for FilterToTraits<`
`455`	`455`
`456`	`456`	`fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {`
`457`	`457`	`while let Some(pred) = self.base_iterator.next() {`
`458`		`- if let Some(data) = pred.to_opt_poly_trait_pred() {`
	`458`	`+ if let Some(data) = pred.as_trait_clause() {`
`459`	`459`	`return Some(data.map_bound(\|t\| t.trait_ref));`
`460`	`460`	`}`
`461`	`461`	`}`
Original file line number	Diff line number	Diff line change
`@@ -702,7 +702,7 @@ impl<'tcx> UpcastFrom<TyCtxt<'tcx>, NormalizesTo<'tcx>> for Predicate<'tcx> {`
`702`	`702`	`}`
`703`	`703`
`704`	`704`	`impl<'tcx> Predicate<'tcx> {`
`705`		`- pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {`
	`705`	`+ pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'tcx>> {`
`706`	`706`	`let predicate = self.kind();`
`707`	`707`	`match predicate.skip_binder() {`
`708`	`708`	`PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),`
`@@ -722,7 +722,7 @@ impl<'tcx> Predicate<'tcx> {`
`722`	`722`	`}`
`723`	`723`	`}`
`724`	`724`
`725`		`- pub fn to_opt_poly_projection_pred(self) -> Option<PolyProjectionPredicate<'tcx>> {`
	`725`	`+ pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'tcx>> {`
`726`	`726`	`let predicate = self.kind();`
`727`	`727`	`match predicate.skip_binder() {`
`728`	`728`	`PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),`
Original file line number	Diff line number	Diff line change
`@@ -2739,7 +2739,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`2739`	`2739`	`\| ObligationCauseCode::ReferenceOutlivesReferent(..)`
`2740`	`2740`	`\| ObligationCauseCode::ObjectTypeBound(..) => {}`
`2741`	`2741`	`ObligationCauseCode::RustCall => {`
`2742`		`- if let Some(pred) = predicate.to_opt_poly_trait_pred()`
	`2742`	`+ if let Some(pred) = predicate.as_trait_clause()`
`2743`	`2743`	`&& Some(pred.def_id()) == tcx.lang_items().sized_trait()`
`2744`	`2744`	`{`
`2745`	`2745`	err.note("argument required to be sized due to `extern \"rust-call\"` ABI");
`@@ -3725,7 +3725,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`3725`	`3725`	`{`
`3726`	`3726`	`if let hir::Expr { kind: hir::ExprKind::MethodCall(_, rcvr, _, _), .. } = expr`
`3727`	`3727`	`&& let Some(ty) = typeck_results.node_type_opt(rcvr.hir_id)`
`3728`		`- && let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()`
	`3728`	`+ && let Some(failed_pred) = failed_pred.as_trait_clause()`
`3729`	`3729`	`&& let pred = failed_pred.map_bound(\|pred\| pred.with_self_ty(tcx, ty))`
`3730`	`3730`	`&& self.predicate_must_hold_modulo_regions(&Obligation::misc(`
`3731`	`3731`	`tcx, expr.span, body_id, param_env, pred,`
`@@ -3816,7 +3816,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`3816`	`3816`	`&& let Some(where_pred) = where_clauses.predicates.get(*idx)`
`3817`	`3817`	`{`
`3818`	`3818`	`if let Some(where_pred) = where_pred.as_trait_clause()`
`3819`		`- && let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()`
	`3819`	`+ && let Some(failed_pred) = failed_pred.as_trait_clause()`
`3820`	`3820`	`{`
`3821`	`3821`	`self.enter_forall(where_pred, \|where_pred\| {`
`3822`	`3822`	`let failed_pred = self.instantiate_binder_with_fresh_vars(`
`@@ -3842,7 +3842,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`3842`	`3842`	`}`
`3843`	`3843`	`})`
`3844`	`3844`	`} else if let Some(where_pred) = where_pred.as_projection_clause()`
`3845`		`- && let Some(failed_pred) = failed_pred.to_opt_poly_projection_pred()`
	`3845`	`+ && let Some(failed_pred) = failed_pred.as_projection_clause()`
`3846`	`3846`	`&& let Some(found) = failed_pred.skip_binder().term.ty()`
`3847`	`3847`	`{`
`3848`	`3848`	`type_diffs = vec![Sorts(ty::error::ExpectedFound {`