clippy

src/tools/clippy/clippy_lints/src/future_not_send.rs

@@ -3,7 +3,7 @@ use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, HirId};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{Opaque, PredicateKind::Trait, ToPolyTraitRef};
+use rustc_middle::ty::{Opaque, PredicateKind::Trait};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::{sym, Span};
 use rustc_trait_selection::traits::error_reporting::suggestions::InferCtxtExt;
@@ -91,12 +91,11 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
                             cx.tcx.infer_ctxt().enter(|infcx| {
                                 for FulfillmentError { obligation, .. } in send_errors {
                                     infcx.maybe_note_obligation_cause_for_async_await(db, &obligation);
-                                    if let Trait(trait_pred, _) = obligation.predicate.kind() {
-                                        let trait_ref = trait_pred.to_poly_trait_ref();
-                                        db.note(&*format!(
+                                    if let Trait(trait_pred, _) = obligation.predicate.ignore_qualifiers().skip_binder().kind() {
+                                        db.note(&format!(
                                             "`{}` doesn't implement `{}`",
-                                            trait_ref.skip_binder().self_ty(),
-                                            trait_ref.print_only_trait_path(),
+                                            trait_pred.self_ty(),
+                                            trait_pred.trait_ref.print_only_trait_path(),
                                         ));
                                     }
                                 }

src/tools/clippy/clippy_lints/src/methods/mod.rs

@@ -1558,13 +1558,10 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             // if return type is impl trait, check the associated types
             if let ty::Opaque(def_id, _) = ret_ty.kind {
                 // one of the associated types must be Self
-                for predicate in cx.tcx.predicates_of(def_id).predicates {
-                    if let ty::PredicateKind::Projection(poly_projection_predicate) = predicate.0.kind() {
-                        let binder = poly_projection_predicate.ty();
-                        let associated_type = binder.skip_binder();
-
+                for &(predicate, _span) in cx.tcx.predicates_of(def_id).predicates {
+                    if let ty::PredicateKind::Projection(projection_predicate) = predicate.ignore_qualifiers().skip_binder().kind() {
                         // walk the associated type and check for Self
-                        if contains_self_ty(associated_type) {
+                        if contains_self_ty(projection_predicate.ty) {
                             return;
                         }
                     }

src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs

@@ -114,12 +114,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
         let preds = traits::elaborate_predicates(cx.tcx, cx.param_env.caller_bounds().iter())
             .filter(|p| !p.is_global())
             .filter_map(|obligation| {
-                if let ty::PredicateKind::Trait(poly_trait_ref, _) = obligation.predicate.kind() {
-                    if poly_trait_ref.def_id() == sized_trait || poly_trait_ref.skip_binder().has_escaping_bound_vars()
-                    {
+                // Note that we do not want to deal with qualified predicates here.
+                if let ty::PredicateKind::Trait(pred, _) = obligation.predicate.kind() {
+                    if pred.def_id() == sized_trait {
                         return None;
                     }
-                    Some(poly_trait_ref)
+                    Some(pred)
                 } else {
                     None
                 }
@@ -159,23 +159,27 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                 }
             }
 
-            //
             // * Exclude a type that is specifically bounded by `Borrow`.
             // * Exclude a type whose reference also fulfills its bound. (e.g., `std::convert::AsRef`,
             //   `serde::Serialize`)
             let (implements_borrow_trait, all_borrowable_trait) = {
                 let preds = preds
                     .iter()
-                    .filter(|t| t.skip_binder().self_ty() == ty)
+                    .filter(|t| t.self_ty() == ty)
                     .collect::<Vec<_>>();
 
                 (
                     preds.iter().any(|t| t.def_id() == borrow_trait),
                     !preds.is_empty() && {
                         let ty_empty_region = cx.tcx.mk_imm_ref(cx.tcx.lifetimes.re_root_empty, ty);
                         preds.iter().all(|t| {
-                            let ty_params = &t.skip_binder().trait_ref.substs.iter().skip(1).collect::<Vec<_>>();
-                            implements_trait(cx, ty_empty_region, t.def_id(), ty_params)
+                            let ty_params = t
+                                .trait_ref
+                                .substs
+                                .iter()
+                                .skip(1)
+                                .collect::<Vec<_>>();
+                            implements_trait(cx, ty_empty_region, t.def_id(), &ty_params)
                         })
                     },
                 )

src/tools/clippy/clippy_lints/src/utils/mod.rs

@@ -1263,8 +1263,8 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::Tuple(ref substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
         ty::Opaque(ref def_id, _) => {
             for (predicate, _) in cx.tcx.predicates_of(*def_id).predicates {
-                if let ty::PredicateKind::Trait(ref poly_trait_predicate, _) = predicate.kind() {
-                    if must_use_attr(&cx.tcx.get_attrs(poly_trait_predicate.skip_binder().trait_ref.def_id)).is_some() {
+                if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.ignore_qualifiers().skip_binder().kind() {
+                    if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
                         return true;
                     }
                 }