From 3ba61922d2500e156df7f76ffeccf022cdeb0f9a Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Wed, 24 Jun 2020 17:40:28 +0200 Subject: [PATCH] this might be unqualified, but at least it's now quantified --- src/librustc_infer/traits/util.rs | 2 +- src/librustc_lint/builtin.rs | 6 +++--- src/librustc_lint/unused.rs | 2 +- src/librustc_middle/ty/mod.rs | 17 ++++++++++------- src/librustc_middle/ty/print/pretty.rs | 2 +- .../borrow_check/diagnostics/region_errors.rs | 2 +- .../transform/qualify_min_const_fn.rs | 2 +- src/librustc_trait_selection/opaque_types.rs | 4 ++-- .../traits/auto_trait.rs | 6 +++--- .../traits/error_reporting/mod.rs | 14 +++++++------- .../traits/error_reporting/suggestions.rs | 2 +- src/librustc_trait_selection/traits/mod.rs | 2 +- .../traits/object_safety.rs | 4 ++-- src/librustc_trait_selection/traits/project.rs | 6 +++--- .../traits/query/type_op/prove_predicate.rs | 2 +- .../traits/select/mod.rs | 6 +++--- src/librustc_trait_selection/traits/wf.rs | 2 +- src/librustc_traits/chalk/lowering.rs | 6 +++--- .../normalize_erasing_regions.rs | 2 +- src/librustc_ty/ty.rs | 4 ++-- src/librustc_typeck/astconv.rs | 2 +- src/librustc_typeck/check/closure.rs | 4 ++-- src/librustc_typeck/check/coercion.rs | 2 +- src/librustc_typeck/check/dropck.rs | 4 ++-- src/librustc_typeck/check/method/confirm.rs | 2 +- src/librustc_typeck/check/method/suggest.rs | 6 +++--- src/librustc_typeck/check/mod.rs | 10 +++++----- src/librustc_typeck/collect.rs | 10 +++++----- .../constrained_generic_params.rs | 2 +- .../impl_wf_check/min_specialization.rs | 6 +++--- src/librustc_typeck/outlives/explicit.rs | 2 +- src/librustc_typeck/outlives/mod.rs | 4 ++-- src/librustdoc/clean/auto_trait.rs | 4 ++-- src/librustdoc/clean/mod.rs | 10 +++++----- src/librustdoc/clean/simplify.rs | 3 ++- .../clippy/clippy_lints/src/future_not_send.rs | 2 +- .../clippy/clippy_lints/src/methods/mod.rs | 2 +- src/tools/clippy/clippy_lints/src/utils/mod.rs | 2 +- 38 files changed, 87 insertions(+), 83 deletions(-) diff --git a/src/librustc_infer/traits/util.rs b/src/librustc_infer/traits/util.rs index 901685d1d84..cb2f2ca0e92 100644 --- a/src/librustc_infer/traits/util.rs +++ b/src/librustc_infer/traits/util.rs @@ -138,7 +138,7 @@ impl Elaborator<'tcx> { fn elaborate(&mut self, obligation: &PredicateObligation<'tcx>) { let tcx = self.visited.tcx; - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => { bug!("unexpected predicate: {:?}", obligation.predicate) } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 9566cdb1643..00d532c7ba0 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -1210,7 +1210,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints { for &(predicate, span) in predicates.predicates { // We don't actually look inside of the predicate, // so it is safe to skip this binder here. - let predicate_kind_name = match predicate.ignore_qualifiers().skip_binder().kind() { + let predicate_kind_name = match predicate.ignore_quantifiers().skip_binder().kind() { Trait(..) => "Trait", TypeOutlives(..) | RegionOutlives(..) => "Lifetime", @@ -1500,7 +1500,7 @@ impl ExplicitOutlivesRequirements { ) -> Vec> { inferred_outlives .iter() - .filter_map(|(pred, _)| match pred.ignore_qualifiers().skip_binder().kind() { + .filter_map(|(pred, _)| match pred.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => match a { ty::ReEarlyBound(ebr) if ebr.index == index => Some(b), _ => None, @@ -1516,7 +1516,7 @@ impl ExplicitOutlivesRequirements { ) -> Vec> { inferred_outlives .iter() - .filter_map(|(pred, _)| match pred.ignore_qualifiers().skip_binder().kind() { + .filter_map(|(pred, _)| match pred.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(a, b)) => { a.is_param(index).then_some(b) } diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index 3f1f397fc8e..8f21cb51695 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -148,7 +148,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults { for (predicate, _) in cx.tcx.predicates_of(def).predicates { // We only look at the `DefId`, so it is safe to skip the binder here. if let ty::PredicateKind::Trait(ref poly_trait_predicate, _) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { let def_id = poly_trait_predicate.trait_ref.def_id; let descr_pre = diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs index 3782f2b8404..dd74fbc9457 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -1050,7 +1050,7 @@ impl<'tcx> Predicate<'tcx> { } /// Skips `PredicateKind::ForAll`. - pub fn ignore_qualifiers(self) -> Binder> { + pub fn ignore_quantifiers(self) -> Binder> { match self.kind() { &PredicateKind::ForAll(binder) => binder, ty::PredicateKind::Projection(..) @@ -1073,7 +1073,10 @@ impl<'tcx> Predicate<'tcx> { /// /// Do not use this method if you may end up just skipping the binder, as this /// would leave the unbound variables at an incorrect binding level. - pub fn ignore_qualifiers_with_unbound_vars(self, tcx: TyCtxt<'tcx>) -> Binder> { + pub fn ignore_quantifiers_with_unbound_vars( + self, + tcx: TyCtxt<'tcx>, + ) -> Binder> { match self.kind() { &PredicateKind::ForAll(binder) => binder, ty::PredicateKind::Projection(..) @@ -1090,7 +1093,7 @@ impl<'tcx> Predicate<'tcx> { } /// Wraps `self` with the given qualifier if this predicate has any unbound variables. - pub fn potentially_qualified( + pub fn potentially_quantified( self, tcx: TyCtxt<'tcx>, qualifier: impl FnOnce(Binder>) -> PredicateKind<'tcx>, @@ -1249,9 +1252,9 @@ impl<'tcx> Predicate<'tcx> { // from the substitution and the value being substituted into, and // this trick achieves that). let substs = trait_ref.skip_binder().substs; - let pred = *self.ignore_qualifiers().skip_binder(); + let pred = *self.ignore_quantifiers().skip_binder(); let new = pred.subst(tcx, substs); - if new != pred { new.potentially_qualified(tcx, PredicateKind::ForAll) } else { self } + if new != pred { new.potentially_quantified(tcx, PredicateKind::ForAll) } else { self } } } @@ -1451,7 +1454,7 @@ impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> { impl<'tcx> Predicate<'tcx> { pub fn to_opt_poly_trait_ref(self) -> Option> { - self.ignore_qualifiers() + self.ignore_quantifiers() .map_bound(|pred| match pred.kind() { &PredicateKind::Trait(ref t, _) => Some(t.trait_ref), PredicateKind::Projection(..) @@ -1469,7 +1472,7 @@ impl<'tcx> Predicate<'tcx> { } pub fn to_opt_type_outlives(self) -> Option> { - self.ignore_qualifiers() + self.ignore_quantifiers() .map_bound(|pred| match pred.kind() { &PredicateKind::TypeOutlives(data) => Some(data), PredicateKind::Trait(..) diff --git a/src/librustc_middle/ty/print/pretty.rs b/src/librustc_middle/ty/print/pretty.rs index 1f9fc481883..d22a0e8c38e 100644 --- a/src/librustc_middle/ty/print/pretty.rs +++ b/src/librustc_middle/ty/print/pretty.rs @@ -577,7 +577,7 @@ pub trait PrettyPrinter<'tcx>: // // FIXME(lcnr): Find out why exactly this is the case :) if let ty::PredicateKind::Trait(pred, _) = predicate - .ignore_qualifiers_with_unbound_vars(self.tcx()) + .ignore_quantifiers_with_unbound_vars(self.tcx()) .skip_binder() .kind() { diff --git a/src/librustc_mir/borrow_check/diagnostics/region_errors.rs b/src/librustc_mir/borrow_check/diagnostics/region_errors.rs index c28f23dc7d6..ffeec8758c4 100644 --- a/src/librustc_mir/borrow_check/diagnostics/region_errors.rs +++ b/src/librustc_mir/borrow_check/diagnostics/region_errors.rs @@ -590,7 +590,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> { let mut found = false; for predicate in bounds.predicates { if let ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(_, r)) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { if let ty::RegionKind::ReStatic = r { found = true; diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index c176fbf90b6..69e8c6b5d2a 100644 --- a/src/librustc_mir/transform/qualify_min_const_fn.rs +++ b/src/librustc_mir/transform/qualify_min_const_fn.rs @@ -24,7 +24,7 @@ pub fn is_min_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId, body: &'a Body<'tcx>) - loop { let predicates = tcx.predicates_of(current); for (predicate, _) in predicates.predicates { - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate), ty::PredicateKind::RegionOutlives(_) | ty::PredicateKind::TypeOutlives(_) diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs index b482f073858..1067ca20a17 100644 --- a/src/librustc_trait_selection/opaque_types.rs +++ b/src/librustc_trait_selection/opaque_types.rs @@ -1155,7 +1155,7 @@ impl<'a, 'tcx> Instantiator<'a, 'tcx> { for predicate in &bounds.predicates { if let ty::PredicateKind::Projection(projection) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { if projection.ty.references_error() { // No point on adding these obligations since there's a type error involved. @@ -1254,7 +1254,7 @@ crate fn required_region_bounds( traits::elaborate_predicates(tcx, predicates) .filter_map(|obligation| { debug!("required_region_bounds(obligation={:?})", obligation); - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Projection(..) | ty::PredicateKind::Trait(..) | ty::PredicateKind::Subtype(..) diff --git a/src/librustc_trait_selection/traits/auto_trait.rs b/src/librustc_trait_selection/traits/auto_trait.rs index 2dbb4036397..b5bea972428 100644 --- a/src/librustc_trait_selection/traits/auto_trait.rs +++ b/src/librustc_trait_selection/traits/auto_trait.rs @@ -418,8 +418,8 @@ impl AutoTraitFinder<'tcx> { ty::PredicateKind::Trait(new_trait, _), ty::PredicateKind::Trait(old_trait, _), ) = ( - new_pred.ignore_qualifiers().skip_binder().kind(), - old_pred.ignore_qualifiers().skip_binder().kind(), + new_pred.ignore_quantifiers().skip_binder().kind(), + old_pred.ignore_quantifiers().skip_binder().kind(), ) { if new_trait.def_id() == old_trait.def_id() { let new_substs = new_trait.trait_ref.substs; @@ -639,7 +639,7 @@ impl AutoTraitFinder<'tcx> { // We check this by calling is_of_param on the relevant types // from the various possible predicates - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(p, _) => { if self.is_param_no_infer(p.trait_ref.substs) && !only_projections diff --git a/src/librustc_trait_selection/traits/error_reporting/mod.rs b/src/librustc_trait_selection/traits/error_reporting/mod.rs index f5717285def..8af4e12bd2b 100644 --- a/src/librustc_trait_selection/traits/error_reporting/mod.rs +++ b/src/librustc_trait_selection/traits/error_reporting/mod.rs @@ -256,7 +256,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { return; } - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => { bug!("unexpected predicate: {:?}", obligation.predicate) } @@ -1091,8 +1091,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { // FIXME: It should be possible to deal with `ForAll` in a cleaner way. let (cond, error) = match ( - cond.ignore_qualifiers().skip_binder().kind(), - error.ignore_qualifiers().skip_binder().kind(), + cond.ignore_quantifiers().skip_binder().kind(), + error.ignore_quantifiers().skip_binder().kind(), ) { (ty::PredicateKind::Trait(..), &ty::PredicateKind::Trait(error, _)) => { (cond, ty::Binder::bind(error)) @@ -1105,7 +1105,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { for obligation in super::elaborate_predicates(self.tcx, std::iter::once(cond)) { if let &ty::PredicateKind::Trait(implication, _) = - obligation.predicate.ignore_qualifiers().skip_binder().kind() + obligation.predicate.ignore_quantifiers().skip_binder().kind() { let error = error.to_poly_trait_ref(); let implication = ty::Binder::bind(implication).to_poly_trait_ref(); @@ -1187,7 +1187,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { // this can fail if the problem was higher-ranked, in which // cause I have no idea for a good error message. if let &ty::PredicateKind::Projection(data) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { let mut selcx = SelectionContext::new(self); let (data, _) = self.replace_bound_vars_with_fresh_vars( @@ -1480,7 +1480,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { return; } - let mut err = match predicate.ignore_qualifiers().skip_binder().kind() { + let mut err = match predicate.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(data, _) => { let trait_ref = ty::Binder::bind(data.trait_ref); let self_ty = trait_ref.skip_binder().self_ty(); @@ -1734,7 +1734,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> { obligation: &PredicateObligation<'tcx>, ) { let (pred, item_def_id, span) = match ( - obligation.predicate.ignore_qualifiers().skip_binder().kind(), + obligation.predicate.ignore_quantifiers().skip_binder().kind(), obligation.cause.code.peel_derives(), ) { ( diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs index 1b618cea600..9180325fb74 100644 --- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs +++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs @@ -1300,7 +1300,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> { // bound was introduced. At least one generator should be present for this diagnostic to be // modified. let (mut trait_ref, mut target_ty) = - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(p, _) => (Some(p.trait_ref), Some(p.self_ty())), _ => (None, None), }; diff --git a/src/librustc_trait_selection/traits/mod.rs b/src/librustc_trait_selection/traits/mod.rs index 54df3559683..bd0ba5570c7 100644 --- a/src/librustc_trait_selection/traits/mod.rs +++ b/src/librustc_trait_selection/traits/mod.rs @@ -328,7 +328,7 @@ pub fn normalize_param_env_or_error<'tcx>( // This works fairly well because trait matching does not actually care about param-env // TypeOutlives predicates - these are normally used by regionck. let outlives_predicates: Vec<_> = predicates - .drain_filter(|predicate| match predicate.ignore_qualifiers().skip_binder().kind() { + .drain_filter(|predicate| match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::TypeOutlives(..) => true, _ => false, }) diff --git a/src/librustc_trait_selection/traits/object_safety.rs b/src/librustc_trait_selection/traits/object_safety.rs index b3525ddeb21..8da5e7318c0 100644 --- a/src/librustc_trait_selection/traits/object_safety.rs +++ b/src/librustc_trait_selection/traits/object_safety.rs @@ -245,7 +245,7 @@ fn predicates_reference_self( .iter() .map(|(predicate, sp)| (predicate.subst_supertrait(tcx, &trait_ref), sp)) .filter_map(|(predicate, &sp)| { - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(ref data, _) => { // In the case of a trait predicate, we can skip the "self" type. if data.trait_ref.substs[1..].iter().any(has_self_ty) { Some(sp) } else { None } @@ -299,7 +299,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool { let predicates = tcx.predicates_of(def_id); let predicates = predicates.instantiate_identity(tcx).predicates; elaborate_predicates(tcx, predicates.into_iter()).any(|obligation| { - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(ref trait_pred, _) => { trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0) } diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs index a5199b7fbef..c12f9eb112f 100644 --- a/src/librustc_trait_selection/traits/project.rs +++ b/src/librustc_trait_selection/traits/project.rs @@ -665,7 +665,7 @@ fn prune_cache_value_obligations<'a, 'tcx>( .obligations .iter() .filter(|obligation| { - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { // We found a `T: Foo` predicate, let's check // if `U` references any unresolved type // variables. In principle, we only care if this @@ -934,7 +934,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>( for predicate in env_predicates { debug!("assemble_candidates_from_predicates: predicate={:?}", predicate); if let &ty::PredicateKind::Projection(data) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { let data = ty::Binder::bind(data); let same_def_id = data.projection_def_id() == obligation.predicate.item_def_id; @@ -1228,7 +1228,7 @@ fn confirm_object_candidate<'cx, 'tcx>( // item with the correct name let env_predicates = env_predicates.filter_map(|o| { - match o.predicate.ignore_qualifiers().skip_binder().kind() { + match o.predicate.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Projection(data) if data.projection_ty.item_def_id == obligation.predicate.item_def_id => { diff --git a/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs b/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs index 76154adb175..24551299df2 100644 --- a/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs +++ b/src/librustc_trait_selection/traits/query/type_op/prove_predicate.rs @@ -16,7 +16,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> { // we have to prove. No need to canonicalize and all that for // such cases. if let ty::PredicateKind::Trait(trait_ref, _) = - key.value.predicate.ignore_qualifiers().skip_binder().kind() + key.value.predicate.ignore_quantifiers().skip_binder().kind() { if let Some(sized_def_id) = tcx.lang_items().sized_trait() { if trait_ref.def_id() == sized_def_id { diff --git a/src/librustc_trait_selection/traits/select/mod.rs b/src/librustc_trait_selection/traits/select/mod.rs index f8b2e092581..4b1e2013fef 100644 --- a/src/librustc_trait_selection/traits/select/mod.rs +++ b/src/librustc_trait_selection/traits/select/mod.rs @@ -408,7 +408,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { None => self.check_recursion_limit(&obligation, &obligation)?, } - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => { bug!("unexpected predicate: {:?}", obligation.predicate) } @@ -792,7 +792,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { } fn coinductive_predicate(&self, predicate: ty::Predicate<'tcx>) -> bool { - let result = match predicate.ignore_qualifiers().skip_binder().kind() { + let result = match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(ref data, _) => self.tcx().trait_is_auto(data.def_id()), _ => false, }; @@ -1302,7 +1302,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { let matching_bound = predicates.iter().find_map(|bound| { if let ty::PredicateKind::Trait(pred, _) = - bound.ignore_qualifiers().skip_binder().kind() + bound.ignore_quantifiers().skip_binder().kind() { let bound = ty::Binder::bind(pred.trait_ref); if self.infcx.probe(|_| { diff --git a/src/librustc_trait_selection/traits/wf.rs b/src/librustc_trait_selection/traits/wf.rs index fd762f9d571..ffafbabddfc 100644 --- a/src/librustc_trait_selection/traits/wf.rs +++ b/src/librustc_trait_selection/traits/wf.rs @@ -196,7 +196,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>( }; // It is fine to skip the binder as we don't care about regions here. - match pred.ignore_qualifiers().skip_binder().kind() { + match pred.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Projection(proj) => { // The obligation comes not from the current `impl` nor the `trait` being implemented, // but rather from a "second order" obligation, where an associated type has a diff --git a/src/librustc_traits/chalk/lowering.rs b/src/librustc_traits/chalk/lowering.rs index 7857b19bd90..b781c2e2a6e 100644 --- a/src/librustc_traits/chalk/lowering.rs +++ b/src/librustc_traits/chalk/lowering.rs @@ -80,7 +80,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment { // FIXME(chalk): forall match predicate - .ignore_qualifiers_with_unbound_vars(interner.tcx) + .ignore_quantifiers_with_unbound_vars(interner.tcx) .skip_binder() .kind() { @@ -191,7 +191,7 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment LowerInto<'tcx, chalk_ir::GoalData>> for ty::Predicate<'tcx> { fn lower_into(self, interner: &RustInterner<'tcx>) -> chalk_ir::GoalData> { // FIXME(chalk): forall - match self.ignore_qualifiers_with_unbound_vars(interner.tcx).skip_binder().kind() { + match self.ignore_quantifiers_with_unbound_vars(interner.tcx).skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", self), &ty::PredicateKind::Trait(predicate, _) => { ty::Binder::bind(predicate).lower_into(interner) @@ -561,7 +561,7 @@ impl<'tcx> LowerInto<'tcx, Option, ) -> Option>> { // FIXME(chalk): forall - match self.ignore_qualifiers_with_unbound_vars(interner.tcx).skip_binder().kind() { + match self.ignore_quantifiers_with_unbound_vars(interner.tcx).skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", self), &ty::PredicateKind::Trait(predicate, _) => { let predicate = ty::Binder::bind(predicate); diff --git a/src/librustc_traits/normalize_erasing_regions.rs b/src/librustc_traits/normalize_erasing_regions.rs index cdc22b987a7..cefc2097214 100644 --- a/src/librustc_traits/normalize_erasing_regions.rs +++ b/src/librustc_traits/normalize_erasing_regions.rs @@ -40,7 +40,7 @@ fn normalize_generic_arg_after_erasing_regions<'tcx>( } fn not_outlives_predicate(p: &ty::Predicate<'tcx>) -> bool { - match p.ignore_qualifiers().skip_binder().kind() { + match p.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::RegionOutlives(..) | ty::PredicateKind::TypeOutlives(..) => false, ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", p), ty::PredicateKind::Trait(..) diff --git a/src/librustc_ty/ty.rs b/src/librustc_ty/ty.rs index 9daf665dd41..48802893926 100644 --- a/src/librustc_ty/ty.rs +++ b/src/librustc_ty/ty.rs @@ -392,7 +392,7 @@ fn associated_type_projection_predicates( let predicates = item_predicates.filter_map(|obligation| { let pred = obligation.predicate; - match pred.ignore_qualifiers().skip_binder().kind() { + match pred.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(tr, _) => { if let ty::Projection(p) = tr.self_ty().kind { if p == assoc_item_ty { @@ -443,7 +443,7 @@ fn opaque_type_projection_predicates( let filtered_predicates = predicates.filter_map(|obligation| { let pred = obligation.predicate; - match pred.ignore_qualifiers().skip_binder().kind() { + match pred.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(tr, _) => { if let ty::Opaque(opaque_def_id, opaque_substs) = tr.self_ty().kind { if opaque_def_id == def_id && opaque_substs == substs { diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index 01d48ece663..841bfbfba70 100644 --- a/src/librustc_typeck/astconv.rs +++ b/src/librustc_typeck/astconv.rs @@ -1706,7 +1706,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { obligation.predicate ); - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(pred, _) => { let pred = ty::Binder::bind(pred); associated_types.entry(span).or_default().extend( diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index 3918eac23ea..6b7848c2eb9 100644 --- a/src/librustc_typeck/check/closure.rs +++ b/src/librustc_typeck/check/closure.rs @@ -207,7 +207,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ); if let &ty::PredicateKind::Projection(proj_predicate) = - obligation.predicate.ignore_qualifiers().skip_binder().kind() + obligation.predicate.ignore_quantifiers().skip_binder().kind() { // Given a Projection predicate, we can potentially infer // the complete signature. @@ -632,7 +632,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // will be our output. let output_ty = self.obligations_for_self_ty(ret_vid).find_map(|(_, obligation)| { if let &ty::PredicateKind::Projection(proj_predicate) = - obligation.predicate.ignore_qualifiers().skip_binder().kind() + obligation.predicate.ignore_quantifiers().skip_binder().kind() { self.deduce_future_output_from_projection( obligation.cause.span, diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 4df39971afa..2b6362230f8 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -582,7 +582,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> { while !queue.is_empty() { let obligation = queue.remove(0); debug!("coerce_unsized resolve step: {:?}", obligation); - let trait_pred = match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + let trait_pred = match obligation.predicate.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(trait_pred, _) if traits.contains(&trait_pred.def_id()) => { diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index c06bbc3d015..4bbdb2a5ad3 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -227,8 +227,8 @@ fn ensure_drop_predicates_are_implied_by_item_defn<'tcx>( let predicate_matches_closure = |p: Predicate<'tcx>| { let mut relator: SimpleEqRelation<'tcx> = SimpleEqRelation::new(tcx, self_param_env); match ( - predicate.ignore_qualifiers().skip_binder().kind(), - p.ignore_qualifiers().skip_binder().kind(), + predicate.ignore_quantifiers().skip_binder().kind(), + p.ignore_quantifiers().skip_binder().kind(), ) { (&ty::PredicateKind::Trait(a, _), &ty::PredicateKind::Trait(b, _)) => { relator.relate(ty::Binder::bind(a), ty::Binder::bind(b)).is_ok() diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 645862fa924..b97dd8bf348 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -449,7 +449,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> { traits::elaborate_predicates(self.tcx, predicates.predicates.iter().copied()) // We don't care about regions here. .filter_map(|obligation| { - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(trait_pred, _) if trait_pred.def_id() == sized_def_id => { diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index 0900bc583ae..cedd7926290 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -578,7 +578,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // We don't care about regions here, so it's fine to skip the binder here. if let (ty::Param(_), ty::PredicateKind::Trait(p, _)) = ( &self_ty.kind, - parent_pred.ignore_qualifiers().skip_binder().kind(), + parent_pred.ignore_quantifiers().skip_binder().kind(), ) { if let ty::Adt(def, _) = p.trait_ref.self_ty().kind { let node = def.did.as_local().map(|def_id| { @@ -631,7 +631,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } }; let mut format_pred = |pred: ty::Predicate<'tcx>| { - match pred.ignore_qualifiers().skip_binder().kind() { + match pred.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Projection(pred) => { let pred = ty::Binder::bind(pred); // `::Item = String`. @@ -959,7 +959,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // implementing a trait would be legal but is rejected // here). unsatisfied_predicates.iter().all(|(p, _)| { - match p.ignore_qualifiers().skip_binder().kind() { + match p.ignore_quantifiers().skip_binder().kind() { // Hide traits if they are present in predicates as they can be fixed without // having to implement them. ty::PredicateKind::Trait(t, _) => t.def_id() == info.def_id, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 0cb0c7d0e30..f54a5948665 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -2400,7 +2400,7 @@ fn bounds_from_generic_predicates<'tcx>( let mut projections = vec![]; for (predicate, _) in predicates.predicates { debug!("predicate {:?}", predicate); - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(trait_predicate, _) => { let entry = types.entry(trait_predicate.self_ty()).or_default(); let def_id = trait_predicate.def_id(); @@ -3894,7 +3894,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .pending_obligations() .into_iter() .filter_map(move |obligation| { - match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + match obligation.predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => { bug!("unexpected predicate: {:?}", obligation.predicate) } @@ -4250,7 +4250,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } if let ty::PredicateKind::Trait(predicate, _) = - error.obligation.predicate.ignore_qualifiers().skip_binder().kind() + error.obligation.predicate.ignore_quantifiers().skip_binder().kind() { // Collect the argument position for all arguments that could have caused this // `FulfillmentError`. @@ -4299,7 +4299,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let hir::QPath::Resolved(_, path) = &qpath { for error in errors { if let ty::PredicateKind::Trait(predicate, _) = - error.obligation.predicate.ignore_qualifiers().skip_binder().kind() + error.obligation.predicate.ignore_quantifiers().skip_binder().kind() { // If any of the type arguments in this path segment caused the // `FullfillmentError`, point at its span (#61860). @@ -5377,7 +5377,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { ty: expected, }) .to_predicate(self.tcx) - .potentially_qualified(self.tcx, ty::PredicateKind::ForAll); + .potentially_quantified(self.tcx, ty::PredicateKind::ForAll); let obligation = traits::Obligation::new(self.misc(sp), self.param_env, predicate); debug!("suggest_missing_await: trying obligation {:?}", obligation); diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 636c178d348..e5d2c569004 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -552,7 +552,7 @@ fn type_param_predicates( let extra_predicates = extend.into_iter().chain( icx.type_parameter_bounds_in_generics(ast_generics, param_id, ty, OnlySelfBounds(true)) .into_iter() - .filter(|(predicate, _)| match predicate.ignore_qualifiers().skip_binder().kind() { + .filter(|(predicate, _)| match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(data, _) => data.self_ty().is_param(index), _ => false, }), @@ -1004,7 +1004,7 @@ fn super_predicates_of(tcx: TyCtxt<'_>, trait_def_id: DefId) -> ty::GenericPredi // which will, in turn, reach indirect supertraits. for &(pred, span) in superbounds { debug!("superbound: {:?}", pred); - if let ty::PredicateKind::Trait(bound, _) = pred.ignore_qualifiers().skip_binder().kind() { + if let ty::PredicateKind::Trait(bound, _) = pred.ignore_quantifiers().skip_binder().kind() { tcx.at(span).super_predicates_of(bound.def_id()); } } @@ -1962,7 +1962,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat predicates.push(( ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty, region)) .to_predicate(tcx) - .potentially_qualified(tcx, ty::PredicateKind::ForAll), + .potentially_quantified(tcx, ty::PredicateKind::ForAll), lifetime.span, )) } @@ -1982,7 +1982,7 @@ fn explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicat let pred = ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(r1, r2)) .to_predicate(icx.tcx); - (pred.potentially_qualified(icx.tcx, ty::PredicateKind::ForAll), span) + (pred.potentially_quantified(icx.tcx, ty::PredicateKind::ForAll), span) })) } @@ -2112,7 +2112,7 @@ fn predicates_from_bound<'tcx>( let region = astconv.ast_region_to_region(lifetime, None); let pred = ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(param_ty, region)) .to_predicate(astconv.tcx()) - .potentially_qualified(astconv.tcx(), ty::PredicateKind::ForAll); + .potentially_quantified(astconv.tcx(), ty::PredicateKind::ForAll); vec![(pred, lifetime.span)] } } diff --git a/src/librustc_typeck/constrained_generic_params.rs b/src/librustc_typeck/constrained_generic_params.rs index 85fe2dba250..7936d003f54 100644 --- a/src/librustc_typeck/constrained_generic_params.rs +++ b/src/librustc_typeck/constrained_generic_params.rs @@ -183,7 +183,7 @@ pub fn setup_constraining_predicates<'tcx>( // Note that we don't have to care about binders here, // as the impl trait ref never contains any late-bound regions. if let ty::PredicateKind::Projection(projection) = - predicates[j].0.ignore_qualifiers().skip_binder().kind() + predicates[j].0.ignore_quantifiers().skip_binder().kind() { // Special case: watch out for some kind of sneaky attempt // to project out an associated type defined by this very diff --git a/src/librustc_typeck/impl_wf_check/min_specialization.rs b/src/librustc_typeck/impl_wf_check/min_specialization.rs index 50312a99175..0cc99a7a54e 100644 --- a/src/librustc_typeck/impl_wf_check/min_specialization.rs +++ b/src/librustc_typeck/impl_wf_check/min_specialization.rs @@ -199,7 +199,7 @@ fn unconstrained_parent_impl_substs<'tcx>( // unconstrained parameters. for (predicate, _) in impl_generic_predicates.predicates.iter() { if let ty::PredicateKind::Projection(proj) = - predicate.ignore_qualifiers().skip_binder().kind() + predicate.ignore_quantifiers().skip_binder().kind() { let projection_ty = proj.projection_ty; let projected_ty = proj.ty; @@ -361,7 +361,7 @@ fn check_predicates<'tcx>( fn check_specialization_on<'tcx>(tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tcx>, span: Span) { debug!("can_specialize_on(predicate = {:?})", predicate); - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { // Global predicates are either always true or always false, so we // are fine to specialize on. _ if predicate.is_global() => (), @@ -394,7 +394,7 @@ fn trait_predicate_kind<'tcx>( tcx: TyCtxt<'tcx>, predicate: ty::Predicate<'tcx>, ) -> Option { - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate), ty::PredicateKind::Trait(pred, hir::Constness::NotConst) => { Some(tcx.trait_def(pred.def_id()).specialization_kind) diff --git a/src/librustc_typeck/outlives/explicit.rs b/src/librustc_typeck/outlives/explicit.rs index ac2f8ae36c3..bbde0b63cbb 100644 --- a/src/librustc_typeck/outlives/explicit.rs +++ b/src/librustc_typeck/outlives/explicit.rs @@ -29,7 +29,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> { // process predicates and convert to `RequiredPredicates` entry, see below for &(predicate, span) in predicates.predicates { - match predicate.ignore_qualifiers().skip_binder().kind() { + match predicate.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unepected predicate: {:?}", predicate), ty::PredicateKind::TypeOutlives(OutlivesPredicate(ref ty, ref reg)) => { diff --git a/src/librustc_typeck/outlives/mod.rs b/src/librustc_typeck/outlives/mod.rs index d450a27941f..56badb324c7 100644 --- a/src/librustc_typeck/outlives/mod.rs +++ b/src/librustc_typeck/outlives/mod.rs @@ -87,7 +87,7 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CratePredica GenericArgKind::Type(ty1) => Some(( ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty1, region2)) .to_predicate(tcx) - .potentially_qualified(tcx, ty::PredicateKind::ForAll), + .potentially_quantified(tcx, ty::PredicateKind::ForAll), span, )), GenericArgKind::Lifetime(region1) => Some(( @@ -95,7 +95,7 @@ fn inferred_outlives_crate(tcx: TyCtxt<'_>, crate_num: CrateNum) -> CratePredica region1, region2, )) .to_predicate(tcx) - .potentially_qualified(tcx, ty::PredicateKind::ForAll), + .potentially_quantified(tcx, ty::PredicateKind::ForAll), span, )), GenericArgKind::Const(_) => { diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs index d49afb551bd..498fa25836c 100644 --- a/src/librustdoc/clean/auto_trait.rs +++ b/src/librustdoc/clean/auto_trait.rs @@ -315,7 +315,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { tcx: TyCtxt<'tcx>, pred: ty::Predicate<'tcx>, ) -> FxHashSet { - let regions = match pred.ignore_qualifiers().skip_binder().kind() { + let regions = match pred.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(poly_trait_pred, _) => { tcx.collect_referenced_late_bound_regions(&ty::Binder::bind(poly_trait_pred)) } @@ -465,7 +465,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> { .iter() .filter(|p| { !orig_bounds.contains(p) - || match p.ignore_qualifiers().skip_binder().kind() { + || match p.ignore_quantifiers().skip_binder().kind() { ty::PredicateKind::Trait(pred, _) => pred.def_id() == sized_trait, _ => false, } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 23defc51a37..a86ee12fa99 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -480,7 +480,7 @@ impl Clean for hir::WherePredicate<'_> { impl<'a> Clean> for ty::Predicate<'a> { fn clean(&self, cx: &DocContext<'_>) -> Option { - match self.ignore_qualifiers().skip_binder().kind() { + match self.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(pred, _) => Some(ty::Binder::bind(pred).clean(cx)), &ty::PredicateKind::Subtype(pred) => Some(ty::Binder::bind(pred).clean(cx)), &ty::PredicateKind::RegionOutlives(pred) => ty::Binder::bind(pred).clean(cx), @@ -755,7 +755,7 @@ impl<'a, 'tcx> Clean for (&'a ty::Generics, ty::GenericPredicates<'tcx .flat_map(|(p, _)| { let mut projection = None; let param_idx = (|| { - match p.ignore_qualifiers().skip_binder().kind() { + match p.ignore_quantifiers().skip_binder().kind() { &ty::PredicateKind::Trait(pred, _constness) => { if let ty::Param(param) = pred.self_ty().kind { return Some(param.index); @@ -1662,9 +1662,9 @@ impl<'tcx> Clean for Ty<'tcx> { .iter() .filter_map(|predicate| { // Note: The substs of opaque types can contain unbound variables, - // meaning that we have to use `ignore_qualifiers_with_unbound_vars` here. + // meaning that we have to use `ignore_quantifiers_with_unbound_vars` here. let trait_ref = match predicate - .ignore_qualifiers_with_unbound_vars(cx.tcx) + .ignore_quantifiers_with_unbound_vars(cx.tcx) .skip_binder() .kind() { @@ -1692,7 +1692,7 @@ impl<'tcx> Clean for Ty<'tcx> { .iter() .filter_map(|pred| { if let ty::PredicateKind::Projection(proj) = pred - .ignore_qualifiers_with_unbound_vars(cx.tcx) + .ignore_quantifiers_with_unbound_vars(cx.tcx) .skip_binder() .kind() { diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs index 75c5fb4c9f8..98e461fe695 100644 --- a/src/librustdoc/clean/simplify.rs +++ b/src/librustdoc/clean/simplify.rs @@ -141,7 +141,8 @@ fn trait_is_same_or_supertrait(cx: &DocContext<'_>, child: DefId, trait_: DefId) .predicates .iter() .filter_map(|(pred, _)| { - if let ty::PredicateKind::Trait(pred, _) = pred.ignore_qualifiers().skip_binder().kind() + if let ty::PredicateKind::Trait(pred, _) = + pred.ignore_quantifiers().skip_binder().kind() { if pred.trait_ref.self_ty() == self_ty { Some(pred.def_id()) } else { None } } else { diff --git a/src/tools/clippy/clippy_lints/src/future_not_send.rs b/src/tools/clippy/clippy_lints/src/future_not_send.rs index ae28015b4c9..7eeb6a75ea7 100644 --- a/src/tools/clippy/clippy_lints/src/future_not_send.rs +++ b/src/tools/clippy/clippy_lints/src/future_not_send.rs @@ -91,7 +91,7 @@ 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.ignore_qualifiers().skip_binder().kind() { + if let Trait(trait_pred, _) = obligation.predicate.ignore_quantifiers().skip_binder().kind() { db.note(&format!( "`{}` doesn't implement `{}`", trait_pred.self_ty(), diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs index c3cdaeedd19..a450d5f16f8 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mod.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs @@ -1559,7 +1559,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { if let ty::Opaque(def_id, _) = ret_ty.kind { // one of the associated types must be Self for &(predicate, _span) in cx.tcx.predicates_of(def_id).predicates { - if let ty::PredicateKind::Projection(projection_predicate) = predicate.ignore_qualifiers().skip_binder().kind() { + if let ty::PredicateKind::Projection(projection_predicate) = predicate.ignore_quantifiers().skip_binder().kind() { // walk the associated type and check for Self if contains_self_ty(projection_predicate.ty) { return; diff --git a/src/tools/clippy/clippy_lints/src/utils/mod.rs b/src/tools/clippy/clippy_lints/src/utils/mod.rs index 426772f3e9a..c4603418ee3 100644 --- a/src/tools/clippy/clippy_lints/src/utils/mod.rs +++ b/src/tools/clippy/clippy_lints/src/utils/mod.rs @@ -1263,7 +1263,7 @@ 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(trait_predicate, _) = predicate.ignore_qualifiers().skip_binder().kind() { + if let ty::PredicateKind::Trait(trait_predicate, _) = predicate.ignore_quantifiers().skip_binder().kind() { if must_use_attr(&cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() { return true; }