compiler/rustc_hir_analysis/src/collect/predicates_of.rs

   1 use crate::astconv::AstConv;
   2 use crate::bounds::Bounds;
   3 use crate::collect::ItemCtxt;
   4 use crate::constrained_generic_params as cgp;
   5 use hir::{HirId, Node};
   6 use rustc_data_structures::fx::FxIndexSet;
   7 use rustc_hir as hir;
   8 use rustc_hir::def::DefKind;
   9 use rustc_hir::def_id::{DefId, LocalDefId};
  10 use rustc_hir::intravisit::{self, Visitor};
  11 use rustc_middle::ty::subst::InternalSubsts;
  12 use rustc_middle::ty::ToPredicate;
  13 use rustc_middle::ty::{self, Ty, TyCtxt};
  14 use rustc_span::symbol::{sym, Ident};
  15 use rustc_span::{Span, DUMMY_SP};
  16
  17 #[derive(Debug)]
  18 struct OnlySelfBounds(bool);
  19
  20 /// Returns a list of all type predicates (explicit and implicit) for the definition with
  21 /// ID `def_id`. This includes all predicates returned by `predicates_defined_on`, plus
  22 /// `Self: Trait` predicates for traits.
  23 pub(super) fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
  24     let mut result = tcx.predicates_defined_on(def_id);
  25
  26     if tcx.is_trait(def_id) {
  27         // For traits, add `Self: Trait` predicate. This is
  28         // not part of the predicates that a user writes, but it
  29         // is something that one must prove in order to invoke a
  30         // method or project an associated type.
  31         //
  32         // In the chalk setup, this predicate is not part of the
  33         // "predicates" for a trait item. But it is useful in
  34         // rustc because if you directly (e.g.) invoke a trait
  35         // method like `Trait::method(...)`, you must naturally
  36         // prove that the trait applies to the types that were
  37         // used, and adding the predicate into this list ensures
  38         // that this is done.
  39         //
  40         // We use a DUMMY_SP here as a way to signal trait bounds that come
  41         // from the trait itself that *shouldn't* be shown as the source of
  42         // an obligation and instead be skipped. Otherwise we'd use
  43         // `tcx.def_span(def_id);`
  44
  45         let constness = if tcx.has_attr(def_id, sym::const_trait) {
  46             ty::BoundConstness::ConstIfConst
  47         } else {
  48             ty::BoundConstness::NotConst
  49         };
  50
  51         let span = rustc_span::DUMMY_SP;
  52         result.predicates =
  53             tcx.arena.alloc_from_iter(result.predicates.iter().copied().chain(std::iter::once((
  54                 ty::TraitRef::identity(tcx, def_id).with_constness(constness).to_predicate(tcx),
  55                 span,
  56             ))));
  57     }
  58     debug!("predicates_of(def_id={:?}) = {:?}", def_id, result);
  59     result
  60 }
  61
  62 /// Returns a list of user-specified type predicates for the definition with ID `def_id`.
  63 /// N.B., this does not include any implied/inferred constraints.
  64 #[instrument(level = "trace", skip(tcx), ret)]
  65 fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
  66     use rustc_hir::*;
  67
  68     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
  69     let node = tcx.hir().get(hir_id);
  70
  71     let mut is_trait = None;
  72     let mut is_default_impl_trait = None;
  73
  74     let icx = ItemCtxt::new(tcx, def_id);
  75
  76     const NO_GENERICS: &hir::Generics<'_> = hir::Generics::empty();
  77
  78     // We use an `IndexSet` to preserve order of insertion.
  79     // Preserving the order of insertion is important here so as not to break UI tests.
  80     let mut predicates: FxIndexSet<(ty::Predicate<'_>, Span)> = FxIndexSet::default();
  81
  82     let ast_generics = match node {
  83         Node::TraitItem(item) => item.generics,
  84
  85         Node::ImplItem(item) => item.generics,
  86
  87         Node::Item(item) => match item.kind {
  88             ItemKind::Impl(ref impl_) => {
  89                 if impl_.defaultness.is_default() {
  90                     is_default_impl_trait = tcx.impl_trait_ref(def_id).map(ty::Binder::dummy);
  91                 }
  92                 &impl_.generics
  93             }
  94             ItemKind::Fn(.., ref generics, _)
  95             | ItemKind::TyAlias(_, ref generics)
  96             | ItemKind::Enum(_, ref generics)
  97             | ItemKind::Struct(_, ref generics)
  98             | ItemKind::Union(_, ref generics) => *generics,
  99
 100             ItemKind::Trait(_, _, ref generics, ..) | ItemKind::TraitAlias(ref generics, _) => {
 101                 is_trait = Some(ty::TraitRef::identity(tcx, def_id));
 102                 *generics
 103             }
 104             ItemKind::OpaqueTy(OpaqueTy { ref generics, .. }) => generics,
 105             _ => NO_GENERICS,
 106         },
 107
 108         Node::ForeignItem(item) => match item.kind {
 109             ForeignItemKind::Static(..) => NO_GENERICS,
 110             ForeignItemKind::Fn(_, _, ref generics) => *generics,
 111             ForeignItemKind::Type => NO_GENERICS,
 112         },
 113
 114         _ => NO_GENERICS,
 115     };
 116
 117     let generics = tcx.generics_of(def_id);
 118     let parent_count = generics.parent_count as u32;
 119     let has_own_self = generics.has_self && parent_count == 0;
 120
 121     // Below we'll consider the bounds on the type parameters (including `Self`)
 122     // and the explicit where-clauses, but to get the full set of predicates
 123     // on a trait we need to add in the supertrait bounds and bounds found on
 124     // associated types.
 125     if let Some(_trait_ref) = is_trait {
 126         predicates.extend(tcx.super_predicates_of(def_id).predicates.iter().cloned());
 127     }
 128
 129     // In default impls, we can assume that the self type implements
 130     // the trait. So in:
 131     //
 132     //     default impl Foo for Bar { .. }
 133     //
 134     // we add a default where clause `Foo: Bar`. We do a similar thing for traits
 135     // (see below). Recall that a default impl is not itself an impl, but rather a
 136     // set of defaults that can be incorporated into another impl.
 137     if let Some(trait_ref) = is_default_impl_trait {
 138         predicates.insert((trait_ref.without_const().to_predicate(tcx), tcx.def_span(def_id)));
 139     }
 140
 141     // Collect the region predicates that were declared inline as
 142     // well. In the case of parameters declared on a fn or method, we
 143     // have to be careful to only iterate over early-bound regions.
 144     let mut index = parent_count
 145         + has_own_self as u32
 146         + super::early_bound_lifetimes_from_generics(tcx, ast_generics).count() as u32;
 147
 148     trace!(?predicates);
 149     trace!(?ast_generics);
 150     trace!(?generics);
 151
 152     // Collect the predicates that were written inline by the user on each
 153     // type parameter (e.g., `<T: Foo>`).
 154     for param in ast_generics.params {
 155         match param.kind {
 156             // We already dealt with early bound lifetimes above.
 157             GenericParamKind::Lifetime { .. } => (),
 158             GenericParamKind::Type { .. } => {
 159                 let name = param.name.ident().name;
 160                 let param_ty = ty::ParamTy::new(index, name).to_ty(tcx);
 161                 index += 1;
 162
 163                 let mut bounds = Bounds::default();
 164                 // Params are implicitly sized unless a `?Sized` bound is found
 165                 <dyn AstConv<'_>>::add_implicitly_sized(
 166                     &icx,
 167                     &mut bounds,
 168                     param_ty,
 169                     &[],
 170                     Some((param.def_id, ast_generics.predicates)),
 171                     param.span,
 172                 );
 173                 trace!(?bounds);
 174                 predicates.extend(bounds.predicates());
 175                 trace!(?predicates);
 176             }
 177             GenericParamKind::Const { .. } => {
 178                 // Bounds on const parameters are currently not possible.
 179                 index += 1;
 180             }
 181         }
 182     }
 183
 184     trace!(?predicates);
 185     // Add in the bounds that appear in the where-clause.
 186     for predicate in ast_generics.predicates {
 187         match predicate {
 188             hir::WherePredicate::BoundPredicate(bound_pred) => {
 189                 let ty = icx.to_ty(bound_pred.bounded_ty);
 190                 let bound_vars = icx.tcx.late_bound_vars(bound_pred.hir_id);
 191
 192                 // Keep the type around in a dummy predicate, in case of no bounds.
 193                 // That way, `where Ty:` is not a complete noop (see #53696) and `Ty`
 194                 // is still checked for WF.
 195                 if bound_pred.bounds.is_empty() {
 196                     if let ty::Param(_) = ty.kind() {
 197                         // This is a `where T:`, which can be in the HIR from the
 198                         // transformation that moves `?Sized` to `T`'s declaration.
 199                         // We can skip the predicate because type parameters are
 200                         // trivially WF, but also we *should*, to avoid exposing
 201                         // users who never wrote `where Type:,` themselves, to
 202                         // compiler/tooling bugs from not handling WF predicates.
 203                     } else {
 204                         let span = bound_pred.bounded_ty.span;
 205                         let predicate = ty::Binder::bind_with_vars(
 206                             ty::PredicateKind::WellFormed(ty.into()),
 207                             bound_vars,
 208                         );
 209                         predicates.insert((predicate.to_predicate(tcx), span));
 210                     }
 211                 }
 212
 213                 let mut bounds = Bounds::default();
 214                 <dyn AstConv<'_>>::add_bounds(
 215                     &icx,
 216                     ty,
 217                     bound_pred.bounds.iter(),
 218                     &mut bounds,
 219                     bound_vars,
 220                 );
 221                 predicates.extend(bounds.predicates());
 222             }
 223
 224             hir::WherePredicate::RegionPredicate(region_pred) => {
 225                 let r1 = <dyn AstConv<'_>>::ast_region_to_region(&icx, &region_pred.lifetime, None);
 226                 predicates.extend(region_pred.bounds.iter().map(|bound| {
 227                     let (r2, span) = match bound {
 228                         hir::GenericBound::Outlives(lt) => {
 229                             (<dyn AstConv<'_>>::ast_region_to_region(&icx, lt, None), lt.ident.span)
 230                         }
 231                         _ => bug!(),
 232                     };
 233                     let pred = ty::Binder::dummy(ty::PredicateKind::Clause(
 234                         ty::Clause::RegionOutlives(ty::OutlivesPredicate(r1, r2)),
 235                     ))
 236                     .to_predicate(icx.tcx);
 237
 238                     (pred, span)
 239                 }))
 240             }
 241
 242             hir::WherePredicate::EqPredicate(..) => {
 243                 // FIXME(#20041)
 244             }
 245         }
 246     }
 247
 248     if tcx.features().generic_const_exprs {
 249         predicates.extend(const_evaluatable_predicates_of(tcx, def_id.expect_local()));
 250     }
 251
 252     let mut predicates: Vec<_> = predicates.into_iter().collect();
 253
 254     // Subtle: before we store the predicates into the tcx, we
 255     // sort them so that predicates like `T: Foo<Item=U>` come
 256     // before uses of `U`.  This avoids false ambiguity errors
 257     // in trait checking. See `setup_constraining_predicates`
 258     // for details.
 259     if let Node::Item(&Item { kind: ItemKind::Impl { .. }, .. }) = node {
 260         let self_ty = tcx.type_of(def_id);
 261         let trait_ref = tcx.impl_trait_ref(def_id);
 262         cgp::setup_constraining_predicates(
 263             tcx,
 264             &mut predicates,
 265             trait_ref,
 266             &mut cgp::parameters_for_impl(self_ty, trait_ref),
 267         );
 268     }
 269
 270     // Opaque types duplicate some of their generic parameters.
 271     // We create bi-directional Outlives predicates between the original
 272     // and the duplicated parameter, to ensure that they do not get out of sync.
 273     if let Node::Item(&Item { kind: ItemKind::OpaqueTy(..), .. }) = node {
 274         let opaque_ty_id = tcx.hir().parent_id(hir_id);
 275         let opaque_ty_node = tcx.hir().get(opaque_ty_id);
 276         let Node::Ty(&Ty { kind: TyKind::OpaqueDef(_, lifetimes, _), .. }) = opaque_ty_node else {
 277             bug!("unexpected {opaque_ty_node:?}")
 278         };
 279         debug!(?lifetimes);
 280         for (arg, duplicate) in std::iter::zip(lifetimes, ast_generics.params) {
 281             let hir::GenericArg::Lifetime(arg) = arg else { bug!() };
 282             let orig_region = <dyn AstConv<'_>>::ast_region_to_region(&icx, &arg, None);
 283             if !matches!(orig_region.kind(), ty::ReEarlyBound(..)) {
 284                 // Only early-bound regions can point to the original generic parameter.
 285                 continue;
 286             }
 287
 288             let hir::GenericParamKind::Lifetime { .. } = duplicate.kind else { continue };
 289             let dup_def = tcx.hir().local_def_id(duplicate.hir_id).to_def_id();
 290
 291             let Some(dup_index) = generics.param_def_id_to_index(tcx, dup_def) else { bug!() };
 292
 293             let dup_region = tcx.mk_region(ty::ReEarlyBound(ty::EarlyBoundRegion {
 294                 def_id: dup_def,
 295                 index: dup_index,
 296                 name: duplicate.name.ident().name,
 297             }));
 298             predicates.push((
 299                 ty::Binder::dummy(ty::PredicateKind::Clause(ty::Clause::RegionOutlives(
 300                     ty::OutlivesPredicate(orig_region, dup_region),
 301                 )))
 302                 .to_predicate(icx.tcx),
 303                 duplicate.span,
 304             ));
 305             predicates.push((
 306                 ty::Binder::dummy(ty::PredicateKind::Clause(ty::Clause::RegionOutlives(
 307                     ty::OutlivesPredicate(dup_region, orig_region),
 308                 )))
 309                 .to_predicate(icx.tcx),
 310                 duplicate.span,
 311             ));
 312         }
 313         debug!(?predicates);
 314     }
 315
 316     ty::GenericPredicates {
 317         parent: generics.parent,
 318         predicates: tcx.arena.alloc_from_iter(predicates),
 319     }
 320 }
 321
 322 fn const_evaluatable_predicates_of(
 323     tcx: TyCtxt<'_>,
 324     def_id: LocalDefId,
 325 ) -> FxIndexSet<(ty::Predicate<'_>, Span)> {
 326     struct ConstCollector<'tcx> {
 327         tcx: TyCtxt<'tcx>,
 328         preds: FxIndexSet<(ty::Predicate<'tcx>, Span)>,
 329     }
 330
 331     impl<'tcx> intravisit::Visitor<'tcx> for ConstCollector<'tcx> {
 332         fn visit_anon_const(&mut self, c: &'tcx hir::AnonConst) {
 333             let ct = ty::Const::from_anon_const(self.tcx, c.def_id);
 334             if let ty::ConstKind::Unevaluated(_) = ct.kind() {
 335                 let span = self.tcx.def_span(c.def_id);
 336                 self.preds.insert((
 337                     ty::Binder::dummy(ty::PredicateKind::ConstEvaluatable(ct))
 338                         .to_predicate(self.tcx),
 339                     span,
 340                 ));
 341             }
 342         }
 343
 344         fn visit_const_param_default(&mut self, _param: HirId, _ct: &'tcx hir::AnonConst) {
 345             // Do not look into const param defaults,
 346             // these get checked when they are actually instantiated.
 347             //
 348             // We do not want the following to error:
 349             //
 350             //     struct Foo<const N: usize, const M: usize = { N + 1 }>;
 351             //     struct Bar<const N: usize>(Foo<N, 3>);
 352         }
 353     }
 354
 355     let hir_id = tcx.hir().local_def_id_to_hir_id(def_id);
 356     let node = tcx.hir().get(hir_id);
 357
 358     let mut collector = ConstCollector { tcx, preds: FxIndexSet::default() };
 359     if let hir::Node::Item(item) = node && let hir::ItemKind::Impl(ref impl_) = item.kind {
 360         if let Some(of_trait) = &impl_.of_trait {
 361             debug!("const_evaluatable_predicates_of({:?}): visit impl trait_ref", def_id);
 362             collector.visit_trait_ref(of_trait);
 363         }
 364
 365         debug!("const_evaluatable_predicates_of({:?}): visit_self_ty", def_id);
 366         collector.visit_ty(impl_.self_ty);
 367     }
 368
 369     if let Some(generics) = node.generics() {
 370         debug!("const_evaluatable_predicates_of({:?}): visit_generics", def_id);
 371         collector.visit_generics(generics);
 372     }
 373
 374     if let Some(fn_sig) = tcx.hir().fn_sig_by_hir_id(hir_id) {
 375         debug!("const_evaluatable_predicates_of({:?}): visit_fn_decl", def_id);
 376         collector.visit_fn_decl(fn_sig.decl);
 377     }
 378     debug!("const_evaluatable_predicates_of({:?}) = {:?}", def_id, collector.preds);
 379
 380     collector.preds
 381 }
 382
 383 pub(super) fn trait_explicit_predicates_and_bounds(
 384     tcx: TyCtxt<'_>,
 385     def_id: LocalDefId,
 386 ) -> ty::GenericPredicates<'_> {
 387     assert_eq!(tcx.def_kind(def_id), DefKind::Trait);
 388     gather_explicit_predicates_of(tcx, def_id.to_def_id())
 389 }
 390
 391 pub(super) fn explicit_predicates_of<'tcx>(
 392     tcx: TyCtxt<'tcx>,
 393     def_id: DefId,
 394 ) -> ty::GenericPredicates<'tcx> {
 395     let def_kind = tcx.def_kind(def_id);
 396     if let DefKind::Trait = def_kind {
 397         // Remove bounds on associated types from the predicates, they will be
 398         // returned by `explicit_item_bounds`.
 399         let predicates_and_bounds = tcx.trait_explicit_predicates_and_bounds(def_id.expect_local());
 400         let trait_identity_substs = InternalSubsts::identity_for_item(tcx, def_id);
 401
 402         let is_assoc_item_ty = |ty: Ty<'tcx>| {
 403             // For a predicate from a where clause to become a bound on an
 404             // associated type:
 405             // * It must use the identity substs of the item.
 406             //   * We're in the scope of the trait, so we can't name any
 407             //     parameters of the GAT. That means that all we need to
 408             //     check are that the substs of the projection are the
 409             //     identity substs of the trait.
 410             // * It must be an associated type for this trait (*not* a
 411             //   supertrait).
 412             if let ty::Alias(ty::Projection, projection) = ty.kind() {
 413                 projection.substs == trait_identity_substs
 414                     && tcx.associated_item(projection.def_id).container_id(tcx) == def_id
 415             } else {
 416                 false
 417             }
 418         };
 419
 420         let predicates: Vec<_> = predicates_and_bounds
 421             .predicates
 422             .iter()
 423             .copied()
 424             .filter(|(pred, _)| match pred.kind().skip_binder() {
 425                 ty::PredicateKind::Clause(ty::Clause::Trait(tr)) => !is_assoc_item_ty(tr.self_ty()),
 426                 ty::PredicateKind::Clause(ty::Clause::Projection(proj)) => {
 427                     !is_assoc_item_ty(proj.projection_ty.self_ty())
 428                 }
 429                 ty::PredicateKind::Clause(ty::Clause::TypeOutlives(outlives)) => {
 430                     !is_assoc_item_ty(outlives.0)
 431                 }
 432                 _ => true,
 433             })
 434             .collect();
 435         if predicates.len() == predicates_and_bounds.predicates.len() {
 436             predicates_and_bounds
 437         } else {
 438             ty::GenericPredicates {
 439                 parent: predicates_and_bounds.parent,
 440                 predicates: tcx.arena.alloc_slice(&predicates),
 441             }
 442         }
 443     } else {
 444         if matches!(def_kind, DefKind::AnonConst) && tcx.lazy_normalization() {
 445             let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
 446             let parent_def_id = tcx.hir().get_parent_item(hir_id);
 447
 448             if tcx.hir().opt_const_param_default_param_def_id(hir_id).is_some() {
 449                 // In `generics_of` we set the generics' parent to be our parent's parent which means that
 450                 // we lose out on the predicates of our actual parent if we dont return those predicates here.
 451                 // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
 452                 //
 453                 // struct Foo<T, const N: usize = { <T as Trait>::ASSOC }>(T) where T: Trait;
 454                 //        ^^^                     ^^^^^^^^^^^^^^^^^^^^^^^ the def id we are calling
 455                 //        ^^^                                             explicit_predicates_of on
 456                 //        parent item we dont have set as the
 457                 //        parent of generics returned by `generics_of`
 458                 //
 459                 // In the above code we want the anon const to have predicates in its param env for `T: Trait`
 460                 // and we would be calling `explicit_predicates_of(Foo)` here
 461                 return tcx.explicit_predicates_of(parent_def_id);
 462             }
 463
 464             let parent_def_kind = tcx.def_kind(parent_def_id);
 465             if matches!(parent_def_kind, DefKind::OpaqueTy) {
 466                 // In `instantiate_identity` we inherit the predicates of our parent.
 467                 // However, opaque types do not have a parent (see `gather_explicit_predicates_of`), which means
 468                 // that we lose out on the predicates of our actual parent if we dont return those predicates here.
 469                 //
 470                 //
 471                 // fn foo<T: Trait>() -> impl Iterator<Output = Another<{ <T as Trait>::ASSOC }> > { todo!() }
 472                 //                                                        ^^^^^^^^^^^^^^^^^^^ the def id we are calling
 473                 //                                                                            explicit_predicates_of on
 474                 //
 475                 // In the above code we want the anon const to have predicates in its param env for `T: Trait`.
 476                 // However, the anon const cannot inherit predicates from its parent since it's opaque.
 477                 //
 478                 // To fix this, we call `explicit_predicates_of` directly on `foo`, the parent's parent.
 479
 480                 // In the above example this is `foo::{opaque#0}` or `impl Iterator`
 481                 let parent_hir_id = tcx.hir().local_def_id_to_hir_id(parent_def_id.def_id);
 482
 483                 // In the above example this is the function `foo`
 484                 let item_def_id = tcx.hir().get_parent_item(parent_hir_id);
 485
 486                 // In the above code example we would be calling `explicit_predicates_of(foo)` here
 487                 return tcx.explicit_predicates_of(item_def_id);
 488             }
 489         }
 490         gather_explicit_predicates_of(tcx, def_id)
 491     }
 492 }
 493
 494 /// Ensures that the super-predicates of the trait with a `DefId`
 495 /// of `trait_def_id` are converted and stored. This also ensures that
 496 /// the transitive super-predicates are converted.
 497 pub(super) fn super_predicates_of(
 498     tcx: TyCtxt<'_>,
 499     trait_def_id: DefId,
 500 ) -> ty::GenericPredicates<'_> {
 501     tcx.super_predicates_that_define_assoc_type((trait_def_id, None))
 502 }
 503
 504 /// Ensures that the super-predicates of the trait with a `DefId`
 505 /// of `trait_def_id` are converted and stored. This also ensures that
 506 /// the transitive super-predicates are converted.
 507 pub(super) fn super_predicates_that_define_assoc_type(
 508     tcx: TyCtxt<'_>,
 509     (trait_def_id, assoc_name): (DefId, Option<Ident>),
 510 ) -> ty::GenericPredicates<'_> {
 511     if trait_def_id.is_local() {
 512         debug!("local trait");
 513         let trait_hir_id = tcx.hir().local_def_id_to_hir_id(trait_def_id.expect_local());
 514
 515         let Node::Item(item) = tcx.hir().get(trait_hir_id) else {
 516             bug!("trait_node_id {} is not an item", trait_hir_id);
 517         };
 518
 519         let (generics, bounds) = match item.kind {
 520             hir::ItemKind::Trait(.., ref generics, ref supertraits, _) => (generics, supertraits),
 521             hir::ItemKind::TraitAlias(ref generics, ref supertraits) => (generics, supertraits),
 522             _ => span_bug!(item.span, "super_predicates invoked on non-trait"),
 523         };
 524
 525         let icx = ItemCtxt::new(tcx, trait_def_id);
 526
 527         // Convert the bounds that follow the colon, e.g., `Bar + Zed` in `trait Foo: Bar + Zed`.
 528         let self_param_ty = tcx.types.self_param;
 529         let superbounds1 = if let Some(assoc_name) = assoc_name {
 530             <dyn AstConv<'_>>::compute_bounds_that_match_assoc_type(
 531                 &icx,
 532                 self_param_ty,
 533                 bounds,
 534                 assoc_name,
 535             )
 536         } else {
 537             <dyn AstConv<'_>>::compute_bounds(&icx, self_param_ty, bounds)
 538         };
 539
 540         let superbounds1 = superbounds1.predicates();
 541
 542         // Convert any explicit superbounds in the where-clause,
 543         // e.g., `trait Foo where Self: Bar`.
 544         // In the case of trait aliases, however, we include all bounds in the where-clause,
 545         // so e.g., `trait Foo = where u32: PartialEq<Self>` would include `u32: PartialEq<Self>`
 546         // as one of its "superpredicates".
 547         let is_trait_alias = tcx.is_trait_alias(trait_def_id);
 548         let superbounds2 = icx.type_parameter_bounds_in_generics(
 549             generics,
 550             item.owner_id.def_id,
 551             self_param_ty,
 552             OnlySelfBounds(!is_trait_alias),
 553             assoc_name,
 554         );
 555
 556         // Combine the two lists to form the complete set of superbounds:
 557         let superbounds = &*tcx.arena.alloc_from_iter(superbounds1.into_iter().chain(superbounds2));
 558         debug!(?superbounds);
 559
 560         // Now require that immediate supertraits are converted,
 561         // which will, in turn, reach indirect supertraits.
 562         if assoc_name.is_none() {
 563             // Now require that immediate supertraits are converted,
 564             // which will, in turn, reach indirect supertraits.
 565             for &(pred, span) in superbounds {
 566                 debug!("superbound: {:?}", pred);
 567                 if let ty::PredicateKind::Clause(ty::Clause::Trait(bound)) =
 568                     pred.kind().skip_binder()
 569                 {
 570                     tcx.at(span).super_predicates_of(bound.def_id());
 571                 }
 572             }
 573         }
 574
 575         ty::GenericPredicates { parent: None, predicates: superbounds }
 576     } else {
 577         // if `assoc_name` is None, then the query should've been redirected to an
 578         // external provider
 579         assert!(assoc_name.is_some());
 580         tcx.super_predicates_of(trait_def_id)
 581     }
 582 }
 583
 584 /// Returns the predicates defined on `item_def_id` of the form
 585 /// `X: Foo` where `X` is the type parameter `def_id`.
 586 #[instrument(level = "trace", skip(tcx))]
 587 pub(super) fn type_param_predicates(
 588     tcx: TyCtxt<'_>,
 589     (item_def_id, def_id, assoc_name): (DefId, LocalDefId, Ident),
 590 ) -> ty::GenericPredicates<'_> {
 591     use rustc_hir::*;
 592
 593     // In the AST, bounds can derive from two places. Either
 594     // written inline like `<T: Foo>` or in a where-clause like
 595     // `where T: Foo`.
 596
 597     let param_id = tcx.hir().local_def_id_to_hir_id(def_id);
 598     let param_owner = tcx.hir().ty_param_owner(def_id);
 599     let generics = tcx.generics_of(param_owner);
 600     let index = generics.param_def_id_to_index[&def_id.to_def_id()];
 601     let ty = tcx.mk_ty_param(index, tcx.hir().ty_param_name(def_id));
 602
 603     // Don't look for bounds where the type parameter isn't in scope.
 604     let parent = if item_def_id == param_owner.to_def_id() {
 605         None
 606     } else {
 607         tcx.generics_of(item_def_id).parent
 608     };
 609
 610     let mut result = parent
 611         .map(|parent| {
 612             let icx = ItemCtxt::new(tcx, parent);
 613             icx.get_type_parameter_bounds(DUMMY_SP, def_id.to_def_id(), assoc_name)
 614         })
 615         .unwrap_or_default();
 616     let mut extend = None;
 617
 618     let item_hir_id = tcx.hir().local_def_id_to_hir_id(item_def_id.expect_local());
 619     let ast_generics = match tcx.hir().get(item_hir_id) {
 620         Node::TraitItem(item) => &item.generics,
 621
 622         Node::ImplItem(item) => &item.generics,
 623
 624         Node::Item(item) => {
 625             match item.kind {
 626                 ItemKind::Fn(.., ref generics, _)
 627                 | ItemKind::Impl(hir::Impl { ref generics, .. })
 628                 | ItemKind::TyAlias(_, ref generics)
 629                 | ItemKind::OpaqueTy(OpaqueTy {
 630                     ref generics,
 631                     origin: hir::OpaqueTyOrigin::TyAlias,
 632                     ..
 633                 })
 634                 | ItemKind::Enum(_, ref generics)
 635                 | ItemKind::Struct(_, ref generics)
 636                 | ItemKind::Union(_, ref generics) => generics,
 637                 ItemKind::Trait(_, _, ref generics, ..) => {
 638                     // Implied `Self: Trait` and supertrait bounds.
 639                     if param_id == item_hir_id {
 640                         let identity_trait_ref = ty::TraitRef::identity(tcx, item_def_id);
 641                         extend =
 642                             Some((identity_trait_ref.without_const().to_predicate(tcx), item.span));
 643                     }
 644                     generics
 645                 }
 646                 _ => return result,
 647             }
 648         }
 649
 650         Node::ForeignItem(item) => match item.kind {
 651             ForeignItemKind::Fn(_, _, ref generics) => generics,
 652             _ => return result,
 653         },
 654
 655         _ => return result,
 656     };
 657
 658     let icx = ItemCtxt::new(tcx, item_def_id);
 659     let extra_predicates = extend.into_iter().chain(
 660         icx.type_parameter_bounds_in_generics(
 661             ast_generics,
 662             def_id,
 663             ty,
 664             OnlySelfBounds(true),
 665             Some(assoc_name),
 666         )
 667         .into_iter()
 668         .filter(|(predicate, _)| match predicate.kind().skip_binder() {
 669             ty::PredicateKind::Clause(ty::Clause::Trait(data)) => data.self_ty().is_param(index),
 670             _ => false,
 671         }),
 672     );
 673     result.predicates =
 674         tcx.arena.alloc_from_iter(result.predicates.iter().copied().chain(extra_predicates));
 675     result
 676 }
 677
 678 impl<'tcx> ItemCtxt<'tcx> {
 679     /// Finds bounds from `hir::Generics`. This requires scanning through the
 680     /// AST. We do this to avoid having to convert *all* the bounds, which
 681     /// would create artificial cycles. Instead, we can only convert the
 682     /// bounds for a type parameter `X` if `X::Foo` is used.
 683     #[instrument(level = "trace", skip(self, ast_generics))]
 684     fn type_parameter_bounds_in_generics(
 685         &self,
 686         ast_generics: &'tcx hir::Generics<'tcx>,
 687         param_def_id: LocalDefId,
 688         ty: Ty<'tcx>,
 689         only_self_bounds: OnlySelfBounds,
 690         assoc_name: Option<Ident>,
 691     ) -> Vec<(ty::Predicate<'tcx>, Span)> {
 692         ast_generics
 693             .predicates
 694             .iter()
 695             .filter_map(|wp| match *wp {
 696                 hir::WherePredicate::BoundPredicate(ref bp) => Some(bp),
 697                 _ => None,
 698             })
 699             .flat_map(|bp| {
 700                 let bt = if bp.is_param_bound(param_def_id.to_def_id()) {
 701                     Some(ty)
 702                 } else if !only_self_bounds.0 {
 703                     Some(self.to_ty(bp.bounded_ty))
 704                 } else {
 705                     None
 706                 };
 707                 let bvars = self.tcx.late_bound_vars(bp.hir_id);
 708
 709                 bp.bounds.iter().filter_map(move |b| bt.map(|bt| (bt, b, bvars))).filter(
 710                     |(_, b, _)| match assoc_name {
 711                         Some(assoc_name) => self.bound_defines_assoc_item(b, assoc_name),
 712                         None => true,
 713                     },
 714                 )
 715             })
 716             .flat_map(|(bt, b, bvars)| predicates_from_bound(self, bt, b, bvars))
 717             .collect()
 718     }
 719
 720     #[instrument(level = "trace", skip(self))]
 721     fn bound_defines_assoc_item(&self, b: &hir::GenericBound<'_>, assoc_name: Ident) -> bool {
 722         match b {
 723             hir::GenericBound::Trait(poly_trait_ref, _) => {
 724                 let trait_ref = &poly_trait_ref.trait_ref;
 725                 if let Some(trait_did) = trait_ref.trait_def_id() {
 726                     self.tcx.trait_may_define_assoc_type(trait_did, assoc_name)
 727                 } else {
 728                     false
 729                 }
 730             }
 731             _ => false,
 732         }
 733     }
 734 }
 735
 736 /// Converts a specific `GenericBound` from the AST into a set of
 737 /// predicates that apply to the self type. A vector is returned
 738 /// because this can be anywhere from zero predicates (`T: ?Sized` adds no
 739 /// predicates) to one (`T: Foo`) to many (`T: Bar<X = i32>` adds `T: Bar`
 740 /// and `<T as Bar>::X == i32`).
 741 fn predicates_from_bound<'tcx>(
 742     astconv: &dyn AstConv<'tcx>,
 743     param_ty: Ty<'tcx>,
 744     bound: &'tcx hir::GenericBound<'tcx>,
 745     bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
 746 ) -> Vec<(ty::Predicate<'tcx>, Span)> {
 747     let mut bounds = Bounds::default();
 748     astconv.add_bounds(param_ty, [bound].into_iter(), &mut bounds, bound_vars);
 749     bounds.predicates().collect()
 750 }