split ignore_qualifiers

Author: lcnr

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,15 +69,15 @@ 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(),
  region_bound_pairs_map: Default::default(),
  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
  }

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<Item = OutlivesBound<'tcx>> + 'tcx {
  debug!("explicit_outlives_bounds()");

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<Item = ty::Predicate<'tcx>>,
  ) -> impl Iterator<Item = ty::OutlivesPredicate<Ty<'tcx>, 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))
  }

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<Self> {
+ 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<Elaborator<'tcx>>;
 
 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<I> {
  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<I> FilterToTraits<I> {
+ fn new(base: I) -> FilterToTraits<I> {
+ FilterToTraits { base_iterator: base }
  }
 }
 
-impl<'tcx, I: Iterator<Item = PredicateObligation<'tcx>>> Iterator for FilterToTraits<'tcx, I> {
+impl<'tcx, I: Iterator<Item = PredicateObligation<'tcx>>> Iterator for FilterToTraits<I> {
  type Item = ty::PolyTraitRef<'tcx>;
 
  fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
  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);
  }
  }

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<ty::Region<'tcx>> {
  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<ty::Region<'tcx>> {
  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,
  )

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 =

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<Predicate<'tcx>> {
+ pub fn ignore_qualifiers(self) -> Binder<Predicate<'tcx>> {
+ 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<Predicate<'tcx>> {
  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<PolyTraitRef<'tcx>> {
- self.ignore_qualifiers(tcx)
+ pub fn to_opt_poly_trait_ref(self) -> Option<PolyTraitRef<'tcx>> {
+ 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<PolyTypeOutlivesPredicate<'tcx>> {
- self.ignore_qualifiers(tcx)
+ pub fn to_opt_type_outlives(self) -> Option<PolyTypeOutlivesPredicate<'tcx>> {
+ self.ignore_qualifiers()
  .map_bound(|pred| match pred.kind() {
  &PredicateKind::TypeOutlives(data) => Some(data),
  PredicateKind::Trait(..)

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;

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;

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`