From 1151d6204919202340e22cef15ca69aa183b41d1 Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Sun, 21 Jun 2020 12:26:17 +0200 Subject: [PATCH] split ignore_qualifiers --- src/librustc_infer/infer/outlives/env.rs | 6 +-- src/librustc_infer/infer/outlives/mod.rs | 3 +- src/librustc_infer/infer/outlives/verify.rs | 3 +- src/librustc_infer/traits/util.rs | 21 ++++---- src/librustc_lint/builtin.rs | 24 +++------- src/librustc_lint/unused.rs | 2 +- src/librustc_middle/ty/mod.rs | 38 +++++++++++---- src/librustc_middle/ty/print/pretty.rs | 11 ++++- .../borrow_check/diagnostics/region_errors.rs | 2 +- .../type_check/free_region_relations.rs | 2 +- .../transform/qualify_min_const_fn.rs | 2 +- src/librustc_privacy/lib.rs | 48 ++++++++++--------- 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 | 4 +- .../traits/object_safety.rs | 6 +-- .../traits/project.rs | 6 +-- .../traits/query/type_op/prove_predicate.rs | 2 +- .../traits/select/candidate_assembly.rs | 3 +- .../traits/select/mod.rs | 10 ++-- .../traits/specialize/mod.rs | 2 +- src/librustc_trait_selection/traits/util.rs | 5 +- src/librustc_trait_selection/traits/wf.rs | 4 +- src/librustc_traits/chalk/lowering.rs | 29 ++++++----- .../normalize_erasing_regions.rs | 8 ++-- src/librustc_ty/ty.rs | 17 ++++--- src/librustc_typeck/astconv.rs | 4 +- src/librustc_typeck/check/closure.rs | 4 +- src/librustc_typeck/check/coercion.rs | 33 +++++++------ src/librustc_typeck/check/dropck.rs | 6 +-- src/librustc_typeck/check/method/confirm.rs | 2 +- src/librustc_typeck/check/method/probe.rs | 1 - src/librustc_typeck/check/method/suggest.rs | 6 +-- src/librustc_typeck/check/mod.rs | 14 ++---- src/librustc_typeck/check/regionck.rs | 2 +- src/librustc_typeck/coherence/builtin.rs | 4 +- src/librustc_typeck/collect.rs | 5 +- .../constrained_generic_params.rs | 2 +- .../impl_wf_check/min_specialization.rs | 8 ++-- src/librustc_typeck/outlives/explicit.rs | 2 +- 42 files changed, 196 insertions(+), 181 deletions(-) diff --git a/src/librustc_infer/infer/outlives/env.rs b/src/librustc_infer/infer/outlives/env.rs index 59f3d01777c7..1a9e20e79fe1 100644 --- a/src/librustc_infer/infer/outlives/env.rs +++ b/src/librustc_infer/infer/outlives/env.rs @@ -3,7 +3,7 @@ use crate::infer::{GenericKind, InferCtxt}; use crate::traits::query::OutlivesBound; use rustc_data_structures::fx::FxHashMap; use rustc_hir as hir; -use rustc_middle::ty::{self, TyCtxt}; +use rustc_middle::ty; use super::explicit_outlives_bounds; @@ -69,7 +69,7 @@ pub struct OutlivesEnvironment<'tcx> { pub type RegionBoundPairs<'tcx> = Vec<(ty::Region<'tcx>, GenericKind<'tcx>)>; impl<'a, 'tcx> OutlivesEnvironment<'tcx> { - pub fn new(tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> Self { + pub fn new(param_env: ty::ParamEnv<'tcx>) -> Self { let mut env = OutlivesEnvironment { param_env, free_region_map: Default::default(), @@ -77,7 +77,7 @@ impl<'a, 'tcx> OutlivesEnvironment<'tcx> { region_bound_pairs_accum: vec![], }; - env.add_outlives_bounds(None, explicit_outlives_bounds(tcx, param_env)); + env.add_outlives_bounds(None, explicit_outlives_bounds(param_env)); env } diff --git a/src/librustc_infer/infer/outlives/mod.rs b/src/librustc_infer/infer/outlives/mod.rs index ad1579083b64..541a2f18045c 100644 --- a/src/librustc_infer/infer/outlives/mod.rs +++ b/src/librustc_infer/infer/outlives/mod.rs @@ -5,10 +5,9 @@ pub mod obligations; pub mod verify; use rustc_middle::traits::query::OutlivesBound; -use rustc_middle::ty::{self, TyCtxt}; +use rustc_middle::ty; pub fn explicit_outlives_bounds<'tcx>( - tcx: TyCtxt<'tcx>, param_env: ty::ParamEnv<'tcx>, ) -> impl Iterator> + 'tcx { debug!("explicit_outlives_bounds()"); diff --git a/src/librustc_infer/infer/outlives/verify.rs b/src/librustc_infer/infer/outlives/verify.rs index 27d21dd0b70e..8f20b5743df4 100644 --- a/src/librustc_infer/infer/outlives/verify.rs +++ b/src/librustc_infer/infer/outlives/verify.rs @@ -331,9 +331,8 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> { compare_ty: impl Fn(Ty<'tcx>) -> bool, predicates: impl Iterator>, ) -> impl Iterator, ty::Region<'tcx>>> { - let tcx = self.tcx; predicates - .filter_map(move |p| p.to_opt_type_outlives(tcx)) + .filter_map(|p| p.to_opt_type_outlives()) .filter_map(|p| p.no_bound_vars()) .filter(move |p| compare_ty(p.0)) } diff --git a/src/librustc_infer/traits/util.rs b/src/librustc_infer/traits/util.rs index a1944781df28..901685d1d844 100644 --- a/src/librustc_infer/traits/util.rs +++ b/src/librustc_infer/traits/util.rs @@ -131,14 +131,14 @@ fn predicate_obligation<'tcx>( } impl Elaborator<'tcx> { - pub fn filter_to_traits(self) -> FilterToTraits<'tcx, Self> { - FilterToTraits::new(self.visited.tcx, self) + pub fn filter_to_traits(self) -> FilterToTraits { + FilterToTraits::new(self) } fn elaborate(&mut self, obligation: &PredicateObligation<'tcx>) { let tcx = self.visited.tcx; - match obligation.predicate.ignore_qualifiers(tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => { bug!("unexpected predicate: {:?}", obligation.predicate) } @@ -275,7 +275,7 @@ impl Iterator for Elaborator<'tcx> { // Supertrait iterator /////////////////////////////////////////////////////////////////////////// -pub type Supertraits<'tcx> = FilterToTraits<'tcx, Elaborator<'tcx>>; +pub type Supertraits<'tcx> = FilterToTraits>; pub fn supertraits<'tcx>( tcx: TyCtxt<'tcx>, @@ -297,23 +297,22 @@ pub fn transitive_bounds<'tcx>( /// A filter around an iterator of predicates that makes it yield up /// just trait references. -pub struct FilterToTraits<'tcx, I> { - tcx: TyCtxt<'tcx>, +pub struct FilterToTraits { base_iterator: I, } -impl<'tcx, I> FilterToTraits<'tcx, I> { - fn new(tcx: TyCtxt<'tcx>, base: I) -> FilterToTraits<'tcx, I> { - FilterToTraits { tcx, base_iterator: base } +impl FilterToTraits { + fn new(base: I) -> FilterToTraits { + FilterToTraits { base_iterator: base } } } -impl<'tcx, I: Iterator>> Iterator for FilterToTraits<'tcx, I> { +impl<'tcx, I: Iterator>> Iterator for FilterToTraits { type Item = ty::PolyTraitRef<'tcx>; fn next(&mut self) -> Option> { while let Some(obligation) = self.base_iterator.next() { - if let Some(data) = obligation.predicate.to_opt_poly_trait_ref(self.tcx) { + if let Some(data) = obligation.predicate.to_opt_poly_trait_ref() { return Some(data); } } diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index cedf742b9a94..9566cdb16435 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(cx.tcx).skip_binder().kind() { + let predicate_kind_name = match predicate.ignore_qualifiers().skip_binder().kind() { Trait(..) => "Trait", TypeOutlives(..) | RegionOutlives(..) => "Lifetime", @@ -1495,13 +1495,12 @@ declare_lint_pass!(ExplicitOutlivesRequirements => [EXPLICIT_OUTLIVES_REQUIREMEN impl ExplicitOutlivesRequirements { fn lifetimes_outliving_lifetime<'tcx>( - tcx: TyCtxt<'tcx>, inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)], index: u32, ) -> Vec> { inferred_outlives .iter() - .filter_map(|(pred, _)| match pred.ignore_qualifiers(tcx).skip_binder().kind() { + .filter_map(|(pred, _)| match pred.ignore_qualifiers().skip_binder().kind() { &ty::PredicateKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => match a { ty::ReEarlyBound(ebr) if ebr.index == index => Some(b), _ => None, @@ -1512,13 +1511,12 @@ impl ExplicitOutlivesRequirements { } fn lifetimes_outliving_type<'tcx>( - tcx: TyCtxt<'tcx>, inferred_outlives: &'tcx [(ty::Predicate<'tcx>, Span)], index: u32, ) -> Vec> { inferred_outlives .iter() - .filter_map(|(pred, _)| match pred.ignore_qualifiers(tcx).skip_binder().kind() { + .filter_map(|(pred, _)| match pred.ignore_qualifiers().skip_binder().kind() { &ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(a, b)) => { a.is_param(index).then_some(b) } @@ -1539,10 +1537,10 @@ impl ExplicitOutlivesRequirements { match param.kind { hir::GenericParamKind::Lifetime { .. } => { - Self::lifetimes_outliving_lifetime(tcx, inferred_outlives, index) + Self::lifetimes_outliving_lifetime(inferred_outlives, index) } hir::GenericParamKind::Type { .. } => { - Self::lifetimes_outliving_type(tcx, inferred_outlives, index) + Self::lifetimes_outliving_type(inferred_outlives, index) } hir::GenericParamKind::Const { .. } => Vec::new(), } @@ -1694,11 +1692,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements { cx.tcx.named_region(predicate.lifetime.hir_id) { ( - Self::lifetimes_outliving_lifetime( - cx.tcx, - inferred_outlives, - index, - ), + Self::lifetimes_outliving_lifetime(inferred_outlives, index), &predicate.bounds, predicate.span, ) @@ -1714,11 +1708,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements { if let Res::Def(DefKind::TyParam, def_id) = path.res { let index = ty_generics.param_def_id_to_index[&def_id]; ( - Self::lifetimes_outliving_type( - cx.tcx, - inferred_outlives, - index, - ), + Self::lifetimes_outliving_type(inferred_outlives, index), &predicate.bounds, predicate.span, ) diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index 1430b799afce..3f1f397fc8e5 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(cx.tcx).skip_binder().kind() + predicate.ignore_qualifiers().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 5b5996e84ee7..3782f2b84048 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -1050,7 +1050,30 @@ impl<'tcx> Predicate<'tcx> { } /// Skips `PredicateKind::ForAll`. - pub fn ignore_qualifiers(self, tcx: TyCtxt<'tcx>) -> Binder> { + pub fn ignore_qualifiers(self) -> Binder> { + match self.kind() { + &PredicateKind::ForAll(binder) => binder, + ty::PredicateKind::Projection(..) + | ty::PredicateKind::Trait(..) + | ty::PredicateKind::Subtype(..) + | ty::PredicateKind::WellFormed(..) + | ty::PredicateKind::ObjectSafe(..) + | ty::PredicateKind::ClosureKind(..) + | ty::PredicateKind::TypeOutlives(..) + | ty::PredicateKind::ConstEvaluatable(..) + | ty::PredicateKind::ConstEquate(..) + | ty::PredicateKind::RegionOutlives(..) => Binder::dummy(self), + } + } + + /// Skips `PredicateKind::ForAll`, while allowing for unbound variables. + /// + /// This method requires the `TyCtxt` as it has to shift the unbound variables + /// outwards. + /// + /// 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> { match self.kind() { &PredicateKind::ForAll(binder) => binder, ty::PredicateKind::Projection(..) @@ -1226,7 +1249,7 @@ 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(tcx).skip_binder(); + let pred = *self.ignore_qualifiers().skip_binder(); let new = pred.subst(tcx, substs); if new != pred { new.potentially_qualified(tcx, PredicateKind::ForAll) } else { self } } @@ -1427,8 +1450,8 @@ impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> { } impl<'tcx> Predicate<'tcx> { - pub fn to_opt_poly_trait_ref(self, tcx: TyCtxt<'tcx>) -> Option> { - self.ignore_qualifiers(tcx) + pub fn to_opt_poly_trait_ref(self) -> Option> { + self.ignore_qualifiers() .map_bound(|pred| match pred.kind() { &PredicateKind::Trait(ref t, _) => Some(t.trait_ref), PredicateKind::Projection(..) @@ -1445,11 +1468,8 @@ impl<'tcx> Predicate<'tcx> { .transpose() } - pub fn to_opt_type_outlives( - self, - tcx: TyCtxt<'tcx>, - ) -> Option> { - self.ignore_qualifiers(tcx) + pub fn to_opt_type_outlives(self) -> Option> { + self.ignore_qualifiers() .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 1fdd7d4c8247..1f9fc4818839 100644 --- a/src/librustc_middle/ty/print/pretty.rs +++ b/src/librustc_middle/ty/print/pretty.rs @@ -572,7 +572,16 @@ pub trait PrettyPrinter<'tcx>: let mut is_sized = false; p!(write("impl")); for predicate in bounds.predicates { - if let Some(trait_ref) = predicate.to_opt_poly_trait_ref(self.tcx()) { + // Note: We can't use `to_opt_poly_trait_ref` here as `predicate` + // may contain unbound variables. We therefore do this manually. + // + // FIXME(lcnr): Find out why exactly this is the case :) + if let ty::PredicateKind::Trait(pred, _) = predicate + .ignore_qualifiers_with_unbound_vars(self.tcx()) + .skip_binder() + .kind() + { + let trait_ref = ty::Binder::bind(pred.trait_ref); // Don't print +Sized, but rather +?Sized if absent. if Some(trait_ref.def_id()) == self.tcx().lang_items().sized_trait() { is_sized = true; diff --git a/src/librustc_mir/borrow_check/diagnostics/region_errors.rs b/src/librustc_mir/borrow_check/diagnostics/region_errors.rs index 4daebcec6ffe..c28f23dc7d61 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(self.infcx.tcx).skip_binder().kind() + predicate.ignore_qualifiers().skip_binder().kind() { if let ty::RegionKind::ReStatic = r { found = true; diff --git a/src/librustc_mir/borrow_check/type_check/free_region_relations.rs b/src/librustc_mir/borrow_check/type_check/free_region_relations.rs index fe8d924debe7..beee31812563 100644 --- a/src/librustc_mir/borrow_check/type_check/free_region_relations.rs +++ b/src/librustc_mir/borrow_check/type_check/free_region_relations.rs @@ -274,7 +274,7 @@ impl UniversalRegionRelationsBuilder<'cx, 'tcx> { // Insert the facts we know from the predicates. Why? Why not. let param_env = self.param_env; - self.add_outlives_bounds(outlives::explicit_outlives_bounds(self.infcx.tcx, param_env)); + self.add_outlives_bounds(outlives::explicit_outlives_bounds(param_env)); // Finally: // - outlives is reflexive, so `'r: 'r` for every region `'r` diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index f4bfc7d4b987..c176fbf90b63 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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate), ty::PredicateKind::RegionOutlives(_) | ty::PredicateKind::TypeOutlives(_) diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 74f0e669ef3c..3591a707ac03 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -84,31 +84,33 @@ where || (!self.def_id_visitor.shallow() && substs.visit_with(self)) } + fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> bool { + match predicate.kind() { + &ty::PredicateKind::ForAll(pred) => { + // This visitor does not care about bound regions as we only + // look at `DefId`s. + self.visit_predicate(*pred.skip_binder()) + } + &ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref }, _) => { + self.visit_trait(trait_ref) + } + &ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, ty }) => { + ty.visit_with(self) + || self.visit_trait(projection_ty.trait_ref(self.def_id_visitor.tcx())) + } + &ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty, _region)) => { + ty.visit_with(self) + } + ty::PredicateKind::RegionOutlives(..) => false, + _ => bug!("unexpected predicate: {:?}", predicate), + } + } + fn visit_predicates(&mut self, predicates: ty::GenericPredicates<'tcx>) -> bool { let ty::GenericPredicates { parent: _, predicates } = predicates; - for (predicate, _span) in predicates { - // This visitor does not care about bound regions. - match predicate.ignore_qualifiers(self.def_id_visitor.tcx()).skip_binder().kind() { - &ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref }, _) => { - if self.visit_trait(trait_ref) { - return true; - } - } - &ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, ty }) => { - if ty.visit_with(self) { - return true; - } - if self.visit_trait(projection_ty.trait_ref(self.def_id_visitor.tcx())) { - return true; - } - } - &ty::PredicateKind::TypeOutlives(ty::OutlivesPredicate(ty, _region)) => { - if ty.visit_with(self) { - return true; - } - } - ty::PredicateKind::RegionOutlives(..) => {} - _ => bug!("unexpected predicate: {:?}", predicate), + for &(predicate, _span) in predicates { + if self.visit_predicate(predicate) { + return true; } } false diff --git a/src/librustc_trait_selection/opaque_types.rs b/src/librustc_trait_selection/opaque_types.rs index 3c42400fbbc1..b482f073858b 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(tcx).skip_binder().kind() + predicate.ignore_qualifiers().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(tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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 aebe96f7ddc7..2dbb40363971 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(self.tcx).skip_binder().kind(), - old_pred.ignore_qualifiers(self.tcx).skip_binder().kind(), + new_pred.ignore_qualifiers().skip_binder().kind(), + old_pred.ignore_qualifiers().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(self.tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().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 75fe9b7701e0..f5717285defb 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(tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind(), - error.ignore_qualifiers(self.tcx).skip_binder().kind(), + cond.ignore_qualifiers().skip_binder().kind(), + error.ignore_qualifiers().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(self.tcx).skip_binder().kind() + obligation.predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind() + predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind() { + let mut err = match predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind(), + obligation.predicate.ignore_qualifiers().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 7e3d4908f9af..1b618cea6008 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(self.tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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 da17d89b8c13..54df3559683f 100644 --- a/src/librustc_trait_selection/traits/mod.rs +++ b/src/librustc_trait_selection/traits/mod.rs @@ -237,7 +237,7 @@ fn do_normalize_predicates<'tcx>( // We can use the `elaborated_env` here; the region code only // cares about declarations like `'a: 'b`. - let outlives_env = OutlivesEnvironment::new(tcx, elaborated_env); + let outlives_env = OutlivesEnvironment::new(elaborated_env); infcx.resolve_regions_and_report_errors( region_context, @@ -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(tcx).skip_binder().kind() { + .drain_filter(|predicate| match predicate.ignore_qualifiers().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 5ad43084e7f1..b3525ddeb214 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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().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(tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(ref trait_pred, _) => { trait_pred.def_id() == sized_def_id && trait_pred.self_ty().is_param(0) } @@ -400,7 +400,7 @@ fn virtual_call_violation_for_method<'tcx>( // A trait object can't claim to live more than the concrete type, // so outlives predicates will always hold. .cloned() - .filter(|(p, _)| p.to_opt_type_outlives(tcx).is_none()) + .filter(|(p, _)| p.to_opt_type_outlives().is_none()) .collect::>() // Do a shallow visit so that `contains_illegal_self_type_reference` // may apply it's custom visiting. diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs index c2ae26d9d25a..a5199b7fbefa 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(infcx.tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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(infcx.tcx).skip_binder().kind() + predicate.ignore_qualifiers().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(selcx.tcx()).skip_binder().kind() { + match o.predicate.ignore_qualifiers().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 f2a6677e2f62..76154adb1751 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(tcx).skip_binder().kind() + key.value.predicate.ignore_qualifiers().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/candidate_assembly.rs b/src/librustc_trait_selection/traits/select/candidate_assembly.rs index 7b654856ddea..1d5441b8eff8 100644 --- a/src/librustc_trait_selection/traits/select/candidate_assembly.rs +++ b/src/librustc_trait_selection/traits/select/candidate_assembly.rs @@ -181,7 +181,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { stack: &TraitObligationStack<'o, 'tcx>, candidates: &mut SelectionCandidateSet<'tcx>, ) -> Result<(), SelectionError<'tcx>> { - let tcx = self.tcx(); debug!("assemble_candidates_from_caller_bounds({:?})", stack.obligation); let all_bounds = stack @@ -189,7 +188,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .param_env .caller_bounds() .iter() - .filter_map(move |o| o.to_opt_poly_trait_ref(tcx)); + .filter_map(|o| o.to_opt_poly_trait_ref()); // Micro-optimization: filter out predicates relating to different traits. let matching_bounds = diff --git a/src/librustc_trait_selection/traits/select/mod.rs b/src/librustc_trait_selection/traits/select/mod.rs index 1bc53f0c5c53..f8b2e0925819 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(self.tcx()).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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(self.tcx()).skip_binder().kind() { + let result = match predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(ref data, _) => self.tcx().trait_is_auto(data.def_id()), _ => false, }; @@ -1301,8 +1301,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }; let matching_bound = predicates.iter().find_map(|bound| { - if let ty::PredicateKind::Trait(bound, _) = bound.kind() { - let bound = bound.to_poly_trait_ref(); + if let ty::PredicateKind::Trait(pred, _) = + bound.ignore_qualifiers().skip_binder().kind() + { + let bound = ty::Binder::bind(pred.trait_ref); if self.infcx.probe(|_| { self.match_projection(obligation, bound, placeholder_trait_predicate.trait_ref) }) { diff --git a/src/librustc_trait_selection/traits/specialize/mod.rs b/src/librustc_trait_selection/traits/specialize/mod.rs index dda2e03d7793..9b737d464174 100644 --- a/src/librustc_trait_selection/traits/specialize/mod.rs +++ b/src/librustc_trait_selection/traits/specialize/mod.rs @@ -497,7 +497,7 @@ fn to_pretty_impl_header(tcx: TyCtxt<'_>, impl_def_id: DefId) -> Option Vec::with_capacity(predicates.len() + types_without_default_bounds.len()); for (p, _) in predicates { - if let Some(poly_trait_ref) = p.to_opt_poly_trait_ref(tcx) { + if let Some(poly_trait_ref) = p.to_opt_poly_trait_ref() { if Some(poly_trait_ref.def_id()) == sized_trait { types_without_default_bounds.remove(poly_trait_ref.self_ty().skip_binder()); continue; diff --git a/src/librustc_trait_selection/traits/util.rs b/src/librustc_trait_selection/traits/util.rs index d2fdfb45617c..cc8997078e0f 100644 --- a/src/librustc_trait_selection/traits/util.rs +++ b/src/librustc_trait_selection/traits/util.rs @@ -120,7 +120,7 @@ impl<'tcx> TraitAliasExpander<'tcx> { let items = predicates.predicates.iter().rev().filter_map(|(pred, span)| { pred.subst_supertrait(tcx, &trait_ref) - .to_opt_poly_trait_ref(tcx) + .to_opt_poly_trait_ref() .map(|trait_ref| item.clone_and_push(trait_ref, *span)) }); debug!("expand_trait_aliases: items={:?}", items.clone()); @@ -170,7 +170,6 @@ impl Iterator for SupertraitDefIds<'tcx> { type Item = DefId; fn next(&mut self) -> Option { - let tcx = self.tcx; let def_id = self.stack.pop()?; let predicates = self.tcx.super_predicates_of(def_id); let visited = &mut self.visited; @@ -178,7 +177,7 @@ impl Iterator for SupertraitDefIds<'tcx> { predicates .predicates .iter() - .filter_map(move |(pred, _)| pred.to_opt_poly_trait_ref(tcx)) + .filter_map(|(pred, _)| pred.to_opt_poly_trait_ref()) .map(|trait_ref| trait_ref.def_id()) .filter(|&super_def_id| visited.insert(super_def_id)), ); diff --git a/src/librustc_trait_selection/traits/wf.rs b/src/librustc_trait_selection/traits/wf.rs index da1a34871d02..fd762f9d5715 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(tcx).skip_binder().kind() { + match pred.ignore_qualifiers().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 @@ -269,7 +269,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> { let extend = |obligation: traits::PredicateObligation<'tcx>| { let mut cause = cause.clone(); - if let Some(parent_trait_ref) = obligation.predicate.to_opt_poly_trait_ref(tcx) { + if let Some(parent_trait_ref) = obligation.predicate.to_opt_poly_trait_ref() { let derived_cause = traits::DerivedObligationCause { parent_trait_ref, parent_code: Rc::new(obligation.cause.code.clone()), diff --git a/src/librustc_traits/chalk/lowering.rs b/src/librustc_traits/chalk/lowering.rs index 7154b3fb3784..7857b19bd90b 100644 --- a/src/librustc_traits/chalk/lowering.rs +++ b/src/librustc_traits/chalk/lowering.rs @@ -79,7 +79,11 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment { // FIXME(chalk): forall - match predicate.ignore_qualifiers(interner.tcx).skip_binder().kind() { + match predicate + .ignore_qualifiers_with_unbound_vars(interner.tcx) + .skip_binder() + .kind() + { ty::PredicateKind::ForAll(_) => bug!("unexpected predicate: {:?}", predicate), &ty::PredicateKind::Trait(predicate, _) => { let predicate = ty::Binder::bind(predicate); @@ -102,9 +106,10 @@ impl<'tcx> LowerInto<'tcx, chalk_ir::InEnvironment { + &ty::PredicateKind::RegionOutlives(predicate) => { + let predicate = ty::Binder::bind(predicate); let (predicate, binders, _named_regions) = - collect_bound_vars(interner, interner.tcx, predicate); + collect_bound_vars(interner, interner.tcx, &predicate); Some( chalk_ir::ProgramClauseData(chalk_ir::Binders::new( @@ -186,14 +191,15 @@ 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(interner.tcx).skip_binder().kind() { + match self.ignore_qualifiers_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) } - ty::PredicateKind::RegionOutlives(predicate) => { + &ty::PredicateKind::RegionOutlives(predicate) => { + let predicate = ty::Binder::bind(predicate); let (predicate, binders, _named_regions) = - collect_bound_vars(interner, interner.tcx, predicate); + collect_bound_vars(interner, interner.tcx, &predicate); chalk_ir::GoalData::Quantified( chalk_ir::QuantifierKind::ForAll, @@ -555,21 +561,22 @@ impl<'tcx> LowerInto<'tcx, Option, ) -> Option>> { // FIXME(chalk): forall - match self.ignore_qualifiers(interner.tcx).skip_binder().kind() { + match self.ignore_qualifiers_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); + let predicate = ty::Binder::bind(predicate); let (predicate, binders, _named_regions) = - collect_bound_vars(interner, interner.tcx, predicate); + collect_bound_vars(interner, interner.tcx, &predicate); Some(chalk_ir::Binders::new( binders, chalk_ir::WhereClause::Implemented(predicate.trait_ref.lower_into(interner)), )) } - ty::PredicateKind::RegionOutlives(predicate) => { + &ty::PredicateKind::RegionOutlives(predicate) => { + let predicate = ty::Binder::bind(predicate); let (predicate, binders, _named_regions) = - collect_bound_vars(interner, interner.tcx, predicate); + collect_bound_vars(interner, interner.tcx, &predicate); Some(chalk_ir::Binders::new( binders, diff --git a/src/librustc_traits/normalize_erasing_regions.rs b/src/librustc_traits/normalize_erasing_regions.rs index 8415690d41f6..cdc22b987a79 100644 --- a/src/librustc_traits/normalize_erasing_regions.rs +++ b/src/librustc_traits/normalize_erasing_regions.rs @@ -27,9 +27,7 @@ fn normalize_generic_arg_after_erasing_regions<'tcx>( // always only region relations, and we are about to // erase those anyway: debug_assert_eq!( - normalized_obligations - .iter() - .find(|p| not_outlives_predicate(tcx, &p.predicate)), + normalized_obligations.iter().find(|p| not_outlives_predicate(&p.predicate)), None, ); @@ -41,8 +39,8 @@ fn normalize_generic_arg_after_erasing_regions<'tcx>( }) } -fn not_outlives_predicate(tcx: TyCtxt<'tcx>, p: &ty::Predicate<'tcx>) -> bool { - match p.ignore_qualifiers(tcx).skip_binder().kind() { +fn not_outlives_predicate(p: &ty::Predicate<'tcx>) -> bool { + match p.ignore_qualifiers().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 c99bc8a47e33..9daf665dd41a 100644 --- a/src/librustc_ty/ty.rs +++ b/src/librustc_ty/ty.rs @@ -392,23 +392,23 @@ fn associated_type_projection_predicates( let predicates = item_predicates.filter_map(|obligation| { let pred = obligation.predicate; - match pred.kind() { + match pred.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(tr, _) => { - if let ty::Projection(p) = tr.skip_binder().self_ty().kind { + if let ty::Projection(p) = tr.self_ty().kind { if p == assoc_item_ty { return Some(pred); } } } ty::PredicateKind::Projection(proj) => { - if let ty::Projection(p) = proj.skip_binder().projection_ty.self_ty().kind { + if let ty::Projection(p) = proj.projection_ty.self_ty().kind { if p == assoc_item_ty { return Some(pred); } } } ty::PredicateKind::TypeOutlives(outlives) => { - if let ty::Projection(p) = outlives.skip_binder().0.kind { + if let ty::Projection(p) = outlives.0.kind { if p == assoc_item_ty { return Some(pred); } @@ -443,17 +443,16 @@ fn opaque_type_projection_predicates( let filtered_predicates = predicates.filter_map(|obligation| { let pred = obligation.predicate; - match pred.kind() { + match pred.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(tr, _) => { - if let ty::Opaque(opaque_def_id, opaque_substs) = tr.skip_binder().self_ty().kind { + if let ty::Opaque(opaque_def_id, opaque_substs) = tr.self_ty().kind { if opaque_def_id == def_id && opaque_substs == substs { return Some(pred); } } } ty::PredicateKind::Projection(proj) => { - if let ty::Opaque(opaque_def_id, opaque_substs) = - proj.skip_binder().projection_ty.self_ty().kind + if let ty::Opaque(opaque_def_id, opaque_substs) = proj.projection_ty.self_ty().kind { if opaque_def_id == def_id && opaque_substs == substs { return Some(pred); @@ -461,7 +460,7 @@ fn opaque_type_projection_predicates( } } ty::PredicateKind::TypeOutlives(outlives) => { - if let ty::Opaque(opaque_def_id, opaque_substs) = outlives.skip_binder().0.kind { + if let ty::Opaque(opaque_def_id, opaque_substs) = outlives.0.kind { if opaque_def_id == def_id && opaque_substs == substs { return Some(pred); } diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs index c028597ccd29..01d48ece663f 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(tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().skip_binder().kind() { &ty::PredicateKind::Trait(pred, _) => { let pred = ty::Binder::bind(pred); associated_types.entry(span).or_default().extend( @@ -2097,7 +2097,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { || { traits::transitive_bounds( tcx, - predicates.iter().filter_map(move |(p, _)| p.to_opt_poly_trait_ref(tcx)), + predicates.iter().filter_map(|(p, _)| p.to_opt_poly_trait_ref()), ) }, || param_name.to_string(), diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs index 9d88a35901e4..3918eac23eaf 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(self.tcx).skip_binder().kind() + obligation.predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind() + obligation.predicate.ignore_qualifiers().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 6b3d986e7b1b..4df39971afa0 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -582,25 +582,24 @@ 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(self.tcx).skip_binder().kind() { - &ty::PredicateKind::Trait(trait_pred, _) - if traits.contains(&trait_pred.def_id()) => - { - if unsize_did == trait_pred.def_id() { - let unsize_ty = trait_pred.trait_ref.substs[1].expect_ty(); - if let ty::Tuple(..) = unsize_ty.kind { - debug!("coerce_unsized: found unsized tuple coercion"); - has_unsized_tuple_coercion = true; - } + let trait_pred = match obligation.predicate.ignore_qualifiers().skip_binder().kind() { + &ty::PredicateKind::Trait(trait_pred, _) + if traits.contains(&trait_pred.def_id()) => + { + if unsize_did == trait_pred.def_id() { + let unsize_ty = trait_pred.trait_ref.substs[1].expect_ty(); + if let ty::Tuple(..) = unsize_ty.kind { + debug!("coerce_unsized: found unsized tuple coercion"); + has_unsized_tuple_coercion = true; } - ty::Binder::bind(trait_pred) } - _ => { - coercion.obligations.push(obligation); - continue; - } - }; + ty::Binder::bind(trait_pred) + } + _ => { + coercion.obligations.push(obligation); + continue; + } + }; match selcx.select(&obligation.with(trait_pred)) { // Uncertain or unimplemented. Ok(None) => { diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs index ae288ef6af78..c06bbc3d015c 100644 --- a/src/librustc_typeck/check/dropck.rs +++ b/src/librustc_typeck/check/dropck.rs @@ -127,7 +127,7 @@ fn ensure_drop_params_and_item_params_correspond<'tcx>( // it did the wrong thing, so I chose to preserve existing // behavior, since it ought to be simply more // conservative. -nmatsakis - let outlives_env = OutlivesEnvironment::new(infcx.tcx, ty::ParamEnv::empty()); + let outlives_env = OutlivesEnvironment::new(ty::ParamEnv::empty()); infcx.resolve_regions_and_report_errors( drop_impl_did.to_def_id(), @@ -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(tcx).skip_binder().kind(), - p.ignore_qualifiers(tcx).skip_binder().kind(), + predicate.ignore_qualifiers().skip_binder().kind(), + p.ignore_qualifiers().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 a9f663fff48a..645862fa924d 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(self.tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(trait_pred, _) if trait_pred.def_id() == sized_def_id => { diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index 90ebce8dc188..9c5e3cbc9384 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -795,7 +795,6 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> { } fn assemble_inherent_candidates_from_param(&mut self, param_ty: ty::ParamTy) { - let tcx = self.tcx; // FIXME: do we want to commit to this behavior for param bounds? debug!("assemble_inherent_candidates_from_param(param_ty={:?})", param_ty); diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index ddf539277b94..0900bc583ae1 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(tcx).skip_binder().kind(), + parent_pred.ignore_qualifiers().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(tcx).skip_binder().kind() { + match pred.ignore_qualifiers().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(self.tcx).skip_binder().kind() { + match p.ignore_qualifiers().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 201288022edb..0cb0c7d0e304 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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind() { + match obligation.predicate.ignore_qualifiers().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(self.tcx).skip_binder().kind() + error.obligation.predicate.ignore_qualifiers().skip_binder().kind() { // Collect the argument position for all arguments that could have caused this // `FulfillmentError`. @@ -4298,12 +4298,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let hir::ExprKind::Path(qpath) = &path.kind { if let hir::QPath::Resolved(_, path) = &qpath { for error in errors { - if let ty::PredicateKind::Trait(predicate, _) = error - .obligation - .predicate - .ignore_qualifiers(self.tcx) - .skip_binder() - .kind() + if let ty::PredicateKind::Trait(predicate, _) = + error.obligation.predicate.ignore_qualifiers().skip_binder().kind() { // If any of the type arguments in this path segment caused the // `FullfillmentError`, point at its span (#61860). diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 71187244601e..221e5f72dc97 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -194,7 +194,7 @@ impl<'a, 'tcx> RegionCtxt<'a, 'tcx> { param_env: ty::ParamEnv<'tcx>, ) -> RegionCtxt<'a, 'tcx> { let region_scope_tree = fcx.tcx.region_scope_tree(subject); - let outlives_environment = OutlivesEnvironment::new(fcx.tcx, param_env); + let outlives_environment = OutlivesEnvironment::new(param_env); RegionCtxt { fcx, region_scope_tree, diff --git a/src/librustc_typeck/coherence/builtin.rs b/src/librustc_typeck/coherence/builtin.rs index d40abf1f54ed..8c6161a62647 100644 --- a/src/librustc_typeck/coherence/builtin.rs +++ b/src/librustc_typeck/coherence/builtin.rs @@ -292,7 +292,7 @@ fn visit_implementation_of_dispatch_from_dyn(tcx: TyCtxt<'_>, impl_did: LocalDef } // Finally, resolve all regions. - let outlives_env = OutlivesEnvironment::new(tcx, param_env); + let outlives_env = OutlivesEnvironment::new(param_env); infcx.resolve_regions_and_report_errors( impl_did.to_def_id(), &outlives_env, @@ -549,7 +549,7 @@ pub fn coerce_unsized_info(tcx: TyCtxt<'tcx>, impl_did: DefId) -> CoerceUnsizedI } // Finally, resolve all regions. - let outlives_env = OutlivesEnvironment::new(tcx, param_env); + let outlives_env = OutlivesEnvironment::new(param_env); infcx.resolve_regions_and_report_errors(impl_did, &outlives_env, RegionckMode::default()); CoerceUnsizedInfo { custom_kind: kind } diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 23cf639f3c8c..636c178d3487 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(tcx).skip_binder().kind() { + .filter(|(predicate, _)| match predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::Trait(data, _) => data.self_ty().is_param(index), _ => false, }), @@ -1004,8 +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(tcx).skip_binder().kind() - { + if let ty::PredicateKind::Trait(bound, _) = pred.ignore_qualifiers().skip_binder().kind() { tcx.at(span).super_predicates_of(bound.def_id()); } } diff --git a/src/librustc_typeck/constrained_generic_params.rs b/src/librustc_typeck/constrained_generic_params.rs index 8d469d0e4298..85fe2dba2502 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(tcx).skip_binder().kind() + predicates[j].0.ignore_qualifiers().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 c1c8e73358bc..50312a99175d 100644 --- a/src/librustc_typeck/impl_wf_check/min_specialization.rs +++ b/src/librustc_typeck/impl_wf_check/min_specialization.rs @@ -163,7 +163,7 @@ fn get_impl_substs<'tcx>( let impl2_substs = translate_substs(infcx, param_env, impl1_def_id, impl1_substs, impl2_node); // Conservatively use an empty `ParamEnv`. - let outlives_env = OutlivesEnvironment::new(tcx, ty::ParamEnv::empty()); + let outlives_env = OutlivesEnvironment::new(ty::ParamEnv::empty()); infcx.resolve_regions_and_report_errors(impl1_def_id, &outlives_env, RegionckMode::default()); let impl2_substs = match infcx.fully_resolve(&impl2_substs) { Ok(s) => s, @@ -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(tcx).skip_binder().kind() + predicate.ignore_qualifiers().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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().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 d6551a5a3871..ac2f8ae36c3d 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(tcx).skip_binder().kind() { + match predicate.ignore_qualifiers().skip_binder().kind() { ty::PredicateKind::ForAll(_) => bug!("unepected predicate: {:?}", predicate), ty::PredicateKind::TypeOutlives(OutlivesPredicate(ref ty, ref reg)) => {