compiler/rustc_infer/src/traits/util.rs

   1 use smallvec::smallvec;
   2
   3 use crate::infer::outlives::components::{push_outlives_components, Component};
   4 use crate::traits::{self, Obligation, ObligationCause, PredicateObligation};
   5 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
   6 use rustc_middle::ty::{self, ToPredicate, TyCtxt};
   7 use rustc_span::symbol::Ident;
   8 use rustc_span::Span;
   9
  10 pub fn anonymize_predicate<'tcx>(
  11     tcx: TyCtxt<'tcx>,
  12     pred: ty::Predicate<'tcx>,
  13 ) -> ty::Predicate<'tcx> {
  14     let new = tcx.anonymize_bound_vars(pred.kind());
  15     tcx.reuse_or_mk_predicate(pred, new)
  16 }
  17
  18 pub struct PredicateSet<'tcx> {
  19     tcx: TyCtxt<'tcx>,
  20     set: FxHashSet<ty::Predicate<'tcx>>,
  21 }
  22
  23 impl<'tcx> PredicateSet<'tcx> {
  24     pub fn new(tcx: TyCtxt<'tcx>) -> Self {
  25         Self { tcx, set: Default::default() }
  26     }
  27
  28     pub fn insert(&mut self, pred: ty::Predicate<'tcx>) -> bool {
  29         // We have to be careful here because we want
  30         //
  31         //    for<'a> Foo<&'a i32>
  32         //
  33         // and
  34         //
  35         //    for<'b> Foo<&'b i32>
  36         //
  37         // to be considered equivalent. So normalize all late-bound
  38         // regions before we throw things into the underlying set.
  39         self.set.insert(anonymize_predicate(self.tcx, pred))
  40     }
  41 }
  42
  43 impl<'tcx> Extend<ty::Predicate<'tcx>> for PredicateSet<'tcx> {
  44     fn extend<I: IntoIterator<Item = ty::Predicate<'tcx>>>(&mut self, iter: I) {
  45         for pred in iter {
  46             self.insert(pred);
  47         }
  48     }
  49
  50     fn extend_one(&mut self, pred: ty::Predicate<'tcx>) {
  51         self.insert(pred);
  52     }
  53
  54     fn extend_reserve(&mut self, additional: usize) {
  55         Extend::<ty::Predicate<'tcx>>::extend_reserve(&mut self.set, additional);
  56     }
  57 }
  58
  59 ///////////////////////////////////////////////////////////////////////////
  60 // `Elaboration` iterator
  61 ///////////////////////////////////////////////////////////////////////////
  62
  63 /// "Elaboration" is the process of identifying all the predicates that
  64 /// are implied by a source predicate. Currently, this basically means
  65 /// walking the "supertraits" and other similar assumptions. For example,
  66 /// if we know that `T: Ord`, the elaborator would deduce that `T: PartialOrd`
  67 /// holds as well. Similarly, if we have `trait Foo: 'static`, and we know that
  68 /// `T: Foo`, then we know that `T: 'static`.
  69 pub struct Elaborator<'tcx> {
  70     stack: Vec<PredicateObligation<'tcx>>,
  71     visited: PredicateSet<'tcx>,
  72 }
  73
  74 pub fn elaborate_trait_ref<'tcx>(
  75     tcx: TyCtxt<'tcx>,
  76     trait_ref: ty::PolyTraitRef<'tcx>,
  77 ) -> Elaborator<'tcx> {
  78     elaborate_predicates(tcx, std::iter::once(trait_ref.without_const().to_predicate(tcx)))
  79 }
  80
  81 pub fn elaborate_trait_refs<'tcx>(
  82     tcx: TyCtxt<'tcx>,
  83     trait_refs: impl Iterator<Item = ty::PolyTraitRef<'tcx>>,
  84 ) -> Elaborator<'tcx> {
  85     let predicates = trait_refs.map(|trait_ref| trait_ref.without_const().to_predicate(tcx));
  86     elaborate_predicates(tcx, predicates)
  87 }
  88
  89 pub fn elaborate_predicates<'tcx>(
  90     tcx: TyCtxt<'tcx>,
  91     predicates: impl Iterator<Item = ty::Predicate<'tcx>>,
  92 ) -> Elaborator<'tcx> {
  93     let obligations = predicates
  94         .map(|predicate| {
  95             predicate_obligation(predicate, ty::ParamEnv::empty(), ObligationCause::dummy())
  96         })
  97         .collect();
  98     elaborate_obligations(tcx, obligations)
  99 }
 100
 101 pub fn elaborate_predicates_with_span<'tcx>(
 102     tcx: TyCtxt<'tcx>,
 103     predicates: impl Iterator<Item = (ty::Predicate<'tcx>, Span)>,
 104 ) -> Elaborator<'tcx> {
 105     let obligations = predicates
 106         .map(|(predicate, span)| {
 107             predicate_obligation(
 108                 predicate,
 109                 ty::ParamEnv::empty(),
 110                 ObligationCause::dummy_with_span(span),
 111             )
 112         })
 113         .collect();
 114     elaborate_obligations(tcx, obligations)
 115 }
 116
 117 pub fn elaborate_obligations<'tcx>(
 118     tcx: TyCtxt<'tcx>,
 119     mut obligations: Vec<PredicateObligation<'tcx>>,
 120 ) -> Elaborator<'tcx> {
 121     let mut visited = PredicateSet::new(tcx);
 122     obligations.retain(|obligation| visited.insert(obligation.predicate));
 123     Elaborator { stack: obligations, visited }
 124 }
 125
 126 fn predicate_obligation<'tcx>(
 127     predicate: ty::Predicate<'tcx>,
 128     param_env: ty::ParamEnv<'tcx>,
 129     cause: ObligationCause<'tcx>,
 130 ) -> PredicateObligation<'tcx> {
 131     Obligation { cause, param_env, recursion_depth: 0, predicate }
 132 }
 133
 134 impl<'tcx> Elaborator<'tcx> {
 135     pub fn filter_to_traits(self) -> FilterToTraits<Self> {
 136         FilterToTraits::new(self)
 137     }
 138
 139     fn elaborate(&mut self, obligation: &PredicateObligation<'tcx>) {
 140         let tcx = self.visited.tcx;
 141
 142         let bound_predicate = obligation.predicate.kind();
 143         match bound_predicate.skip_binder() {
 144             ty::PredicateKind::Clause(ty::Clause::Trait(data)) => {
 145                 // Get predicates declared on the trait.
 146                 let predicates = tcx.super_predicates_of(data.def_id());
 147
 148                 let obligations =
 149                     predicates.predicates.iter().enumerate().map(|(index, &(mut pred, span))| {
 150                         // when parent predicate is non-const, elaborate it to non-const predicates.
 151                         if data.constness == ty::BoundConstness::NotConst {
 152                             pred = pred.without_const(tcx);
 153                         }
 154
 155                         let cause = obligation.cause.clone().derived_cause(
 156                             bound_predicate.rebind(data),
 157                             |derived| {
 158                                 traits::ImplDerivedObligation(Box::new(
 159                                     traits::ImplDerivedObligationCause {
 160                                         derived,
 161                                         impl_def_id: data.def_id(),
 162                                         impl_def_predicate_index: Some(index),
 163                                         span,
 164                                     },
 165                                 ))
 166                             },
 167                         );
 168                         predicate_obligation(
 169                             pred.subst_supertrait(tcx, &bound_predicate.rebind(data.trait_ref)),
 170                             obligation.param_env,
 171                             cause,
 172                         )
 173                     });
 174                 debug!(?data, ?obligations, "super_predicates");
 175
 176                 // Only keep those bounds that we haven't already seen.
 177                 // This is necessary to prevent infinite recursion in some
 178                 // cases. One common case is when people define
 179                 // `trait Sized: Sized { }` rather than `trait Sized { }`.
 180                 let visited = &mut self.visited;
 181                 let obligations = obligations.filter(|o| visited.insert(o.predicate));
 182
 183                 self.stack.extend(obligations);
 184             }
 185             ty::PredicateKind::WellFormed(..) => {
 186                 // Currently, we do not elaborate WF predicates,
 187                 // although we easily could.
 188             }
 189             ty::PredicateKind::ObjectSafe(..) => {
 190                 // Currently, we do not elaborate object-safe
 191                 // predicates.
 192             }
 193             ty::PredicateKind::Subtype(..) => {
 194                 // Currently, we do not "elaborate" predicates like `X <: Y`,
 195                 // though conceivably we might.
 196             }
 197             ty::PredicateKind::Coerce(..) => {
 198                 // Currently, we do not "elaborate" predicates like `X -> Y`,
 199                 // though conceivably we might.
 200             }
 201             ty::PredicateKind::Clause(ty::Clause::Projection(..)) => {
 202                 // Nothing to elaborate in a projection predicate.
 203             }
 204             ty::PredicateKind::ClosureKind(..) => {
 205                 // Nothing to elaborate when waiting for a closure's kind to be inferred.
 206             }
 207             ty::PredicateKind::ConstEvaluatable(..) => {
 208                 // Currently, we do not elaborate const-evaluatable
 209                 // predicates.
 210             }
 211             ty::PredicateKind::ConstEquate(..) => {
 212                 // Currently, we do not elaborate const-equate
 213                 // predicates.
 214             }
 215             ty::PredicateKind::Clause(ty::Clause::RegionOutlives(..)) => {
 216                 // Nothing to elaborate from `'a: 'b`.
 217             }
 218             ty::PredicateKind::Clause(ty::Clause::TypeOutlives(ty::OutlivesPredicate(
 219                 ty_max,
 220                 r_min,
 221             ))) => {
 222                 // We know that `T: 'a` for some type `T`. We can
 223                 // often elaborate this. For example, if we know that
 224                 // `[U]: 'a`, that implies that `U: 'a`. Similarly, if
 225                 // we know `&'a U: 'b`, then we know that `'a: 'b` and
 226                 // `U: 'b`.
 227                 //
 228                 // We can basically ignore bound regions here. So for
 229                 // example `for<'c> Foo<'a,'c>: 'b` can be elaborated to
 230                 // `'a: 'b`.
 231
 232                 // Ignore `for<'a> T: 'a` -- we might in the future
 233                 // consider this as evidence that `T: 'static`, but
 234                 // I'm a bit wary of such constructions and so for now
 235                 // I want to be conservative. --nmatsakis
 236                 if r_min.is_late_bound() {
 237                     return;
 238                 }
 239
 240                 let visited = &mut self.visited;
 241                 let mut components = smallvec![];
 242                 push_outlives_components(tcx, ty_max, &mut components);
 243                 self.stack.extend(
 244                     components
 245                         .into_iter()
 246                         .filter_map(|component| match component {
 247                             Component::Region(r) => {
 248                                 if r.is_late_bound() {
 249                                     None
 250                                 } else {
 251                                     Some(ty::PredicateKind::Clause(ty::Clause::RegionOutlives(
 252                                         ty::OutlivesPredicate(r, r_min),
 253                                     )))
 254                                 }
 255                             }
 256
 257                             Component::Param(p) => {
 258                                 let ty = tcx.mk_ty_param(p.index, p.name);
 259                                 Some(ty::PredicateKind::Clause(ty::Clause::TypeOutlives(
 260                                     ty::OutlivesPredicate(ty, r_min),
 261                                 )))
 262                             }
 263
 264                             Component::UnresolvedInferenceVariable(_) => None,
 265
 266                             Component::Alias(alias_ty) => {
 267                                 // We might end up here if we have `Foo<<Bar as Baz>::Assoc>: 'a`.
 268                                 // With this, we can deduce that `<Bar as Baz>::Assoc: 'a`.
 269                                 Some(ty::PredicateKind::Clause(ty::Clause::TypeOutlives(
 270                                     ty::OutlivesPredicate(alias_ty.to_ty(tcx), r_min),
 271                                 )))
 272                             }
 273
 274                             Component::EscapingAlias(_) => {
 275                                 // We might be able to do more here, but we don't
 276                                 // want to deal with escaping vars right now.
 277                                 None
 278                             }
 279                         })
 280                         .map(|predicate_kind| {
 281                             bound_predicate.rebind(predicate_kind).to_predicate(tcx)
 282                         })
 283                         .filter(|&predicate| visited.insert(predicate))
 284                         .map(|predicate| {
 285                             predicate_obligation(
 286                                 predicate,
 287                                 obligation.param_env,
 288                                 obligation.cause.clone(),
 289                             )
 290                         }),
 291                 );
 292             }
 293             ty::PredicateKind::TypeWellFormedFromEnv(..) => {
 294                 // Nothing to elaborate
 295             }
 296             ty::PredicateKind::Ambiguous => {}
 297         }
 298     }
 299 }
 300
 301 impl<'tcx> Iterator for Elaborator<'tcx> {
 302     type Item = PredicateObligation<'tcx>;
 303
 304     fn size_hint(&self) -> (usize, Option<usize>) {
 305         (self.stack.len(), None)
 306     }
 307
 308     fn next(&mut self) -> Option<Self::Item> {
 309         // Extract next item from top-most stack frame, if any.
 310         if let Some(obligation) = self.stack.pop() {
 311             self.elaborate(&obligation);
 312             Some(obligation)
 313         } else {
 314             None
 315         }
 316     }
 317 }
 318
 319 ///////////////////////////////////////////////////////////////////////////
 320 // Supertrait iterator
 321 ///////////////////////////////////////////////////////////////////////////
 322
 323 pub type Supertraits<'tcx> = FilterToTraits<Elaborator<'tcx>>;
 324
 325 pub fn supertraits<'tcx>(
 326     tcx: TyCtxt<'tcx>,
 327     trait_ref: ty::PolyTraitRef<'tcx>,
 328 ) -> Supertraits<'tcx> {
 329     elaborate_trait_ref(tcx, trait_ref).filter_to_traits()
 330 }
 331
 332 pub fn transitive_bounds<'tcx>(
 333     tcx: TyCtxt<'tcx>,
 334     bounds: impl Iterator<Item = ty::PolyTraitRef<'tcx>>,
 335 ) -> Supertraits<'tcx> {
 336     elaborate_trait_refs(tcx, bounds).filter_to_traits()
 337 }
 338
 339 /// A specialized variant of `elaborate_trait_refs` that only elaborates trait references that may
 340 /// define the given associated type `assoc_name`. It uses the
 341 /// `super_predicates_that_define_assoc_type` query to avoid enumerating super-predicates that
 342 /// aren't related to `assoc_item`. This is used when resolving types like `Self::Item` or
 343 /// `T::Item` and helps to avoid cycle errors (see e.g. #35237).
 344 pub fn transitive_bounds_that_define_assoc_type<'tcx>(
 345     tcx: TyCtxt<'tcx>,
 346     bounds: impl Iterator<Item = ty::PolyTraitRef<'tcx>>,
 347     assoc_name: Ident,
 348 ) -> impl Iterator<Item = ty::PolyTraitRef<'tcx>> {
 349     let mut stack: Vec<_> = bounds.collect();
 350     let mut visited = FxIndexSet::default();
 351
 352     std::iter::from_fn(move || {
 353         while let Some(trait_ref) = stack.pop() {
 354             let anon_trait_ref = tcx.anonymize_bound_vars(trait_ref);
 355             if visited.insert(anon_trait_ref) {
 356                 let super_predicates = tcx.super_predicates_that_define_assoc_type((
 357                     trait_ref.def_id(),
 358                     Some(assoc_name),
 359                 ));
 360                 for (super_predicate, _) in super_predicates.predicates {
 361                     let subst_predicate = super_predicate.subst_supertrait(tcx, &trait_ref);
 362                     if let Some(binder) = subst_predicate.to_opt_poly_trait_pred() {
 363                         stack.push(binder.map_bound(|t| t.trait_ref));
 364                     }
 365                 }
 366
 367                 return Some(trait_ref);
 368             }
 369         }
 370
 371         return None;
 372     })
 373 }
 374
 375 ///////////////////////////////////////////////////////////////////////////
 376 // Other
 377 ///////////////////////////////////////////////////////////////////////////
 378
 379 /// A filter around an iterator of predicates that makes it yield up
 380 /// just trait references.
 381 pub struct FilterToTraits<I> {
 382     base_iterator: I,
 383 }
 384
 385 impl<I> FilterToTraits<I> {
 386     fn new(base: I) -> FilterToTraits<I> {
 387         FilterToTraits { base_iterator: base }
 388     }
 389 }
 390
 391 impl<'tcx, I: Iterator<Item = PredicateObligation<'tcx>>> Iterator for FilterToTraits<I> {
 392     type Item = ty::PolyTraitRef<'tcx>;
 393
 394     fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
 395         while let Some(obligation) = self.base_iterator.next() {
 396             if let Some(data) = obligation.predicate.to_opt_poly_trait_pred() {
 397                 return Some(data.map_bound(|t| t.trait_ref));
 398             }
 399         }
 400         None
 401     }
 402
 403     fn size_hint(&self) -> (usize, Option<usize>) {
 404         let (_, upper) = self.base_iterator.size_hint();
 405         (0, upper)
 406     }
 407 }