@@ -461,83 +461,55 @@ pub(super) fn explicit_predicates_of<'tcx>(
461461 }
462462 }
463463 } else {
464- if matches!(def_kind, DefKind::AnonConst) && tcx.features().generic_const_exprs {
465- let hir_id = tcx.local_def_id_to_hir_id(def_id);
466- let parent_def_id = tcx.hir().get_parent_item(hir_id);
467-
468- if let Some(defaulted_param_def_id) =
469- tcx.hir().opt_const_param_default_param_def_id(hir_id)
470- {
471- // In `generics_of` we set the generics' parent to be our parent's parent which means that
472- // we lose out on the predicates of our actual parent if we dont return those predicates here.
473- // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
474- //
475- // struct Foo<T, const N: usize = { <T as Trait>::ASSOC }>(T) where T: Trait;
476- // ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ the def id we are calling
477- // ^^^ explicit_predicates_of on
478- // parent item we dont have set as the
479- // parent of generics returned by `generics_of`
480- //
481- // In the above code we want the anon const to have predicates in its param env for `T: Trait`
482- // and we would be calling `explicit_predicates_of(Foo)` here
483- let parent_preds = tcx.explicit_predicates_of(parent_def_id);
484-
485- // If we dont filter out `ConstArgHasType` predicates then every single defaulted const parameter
486- // will ICE because of #106994. FIXME(generic_const_exprs): remove this when a more general solution
487- // to #106994 is implemented.
488- let filtered_predicates = parent_preds
489- .predicates
490- .into_iter()
491- .filter(|(pred, _)| {
492- if let ty::ClauseKind::ConstArgHasType(ct, _) = pred.kind().skip_binder() {
493- match ct.kind() {
494- ty::ConstKind::Param(param_const) => {
495- let defaulted_param_idx = tcx
496- .generics_of(parent_def_id)
497- .param_def_id_to_index[&defaulted_param_def_id.to_def_id()];
498- param_const.index < defaulted_param_idx
499- }
500- _ => bug!(
501- "`ConstArgHasType` in `predicates_of`\
502- that isn't a `Param` const"
503- ),
464+ if matches!(def_kind, DefKind::AnonConst)
465+ && tcx.features().generic_const_exprs
466+ && let Some(defaulted_param_def_id) =
467+ tcx.hir().opt_const_param_default_param_def_id(tcx.local_def_id_to_hir_id(def_id))
468+ {
469+ // In `generics_of` we set the generics' parent to be our parent's parent which means that
470+ // we lose out on the predicates of our actual parent if we dont return those predicates here.
471+ // (See comment in `generics_of` for more information on why the parent shenanigans is necessary)
472+ //
473+ // struct Foo<T, const N: usize = { <T as Trait>::ASSOC }>(T) where T: Trait;
474+ // ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ the def id we are calling
475+ // ^^^ explicit_predicates_of on
476+ // parent item we dont have set as the
477+ // parent of generics returned by `generics_of`
478+ //
479+ // In the above code we want the anon const to have predicates in its param env for `T: Trait`
480+ // and we would be calling `explicit_predicates_of(Foo)` here
481+ let parent_def_id = tcx.local_parent(def_id);
482+ let parent_preds = tcx.explicit_predicates_of(parent_def_id);
483+
484+ // If we dont filter out `ConstArgHasType` predicates then every single defaulted const parameter
485+ // will ICE because of #106994. FIXME(generic_const_exprs): remove this when a more general solution
486+ // to #106994 is implemented.
487+ let filtered_predicates = parent_preds
488+ .predicates
489+ .into_iter()
490+ .filter(|(pred, _)| {
491+ if let ty::ClauseKind::ConstArgHasType(ct, _) = pred.kind().skip_binder() {
492+ match ct.kind() {
493+ ty::ConstKind::Param(param_const) => {
494+ let defaulted_param_idx = tcx
495+ .generics_of(parent_def_id)
496+ .param_def_id_to_index[&defaulted_param_def_id.to_def_id()];
497+ param_const.index < defaulted_param_idx
504498 }
505- } else {
506- true
499+ _ => bug!(
500+ "`ConstArgHasType` in `predicates_of`\
501+ that isn't a `Param` const"
502+ ),
507503 }
508- })
509- .cloned();
510- return GenericPredicates {
511- parent: parent_preds.parent,
512- predicates: { tcx.arena.alloc_from_iter(filtered_predicates) },
513- };
514- }
515-
516- let parent_def_kind = tcx.def_kind(parent_def_id);
517- if matches!(parent_def_kind, DefKind::OpaqueTy) {
518- // In `instantiate_identity` we inherit the predicates of our parent.
519- // However, opaque types do not have a parent (see `gather_explicit_predicates_of`), which means
520- // that we lose out on the predicates of our actual parent if we dont return those predicates here.
521- //
522- //
523- // fn foo<T: Trait>() -> impl Iterator<Output = Another<{ <T as Trait>::ASSOC }> > { todo!() }
524- // ^^^^^^^^^^^^^^^^^^^ the def id we are calling
525- // explicit_predicates_of on
526- //
527- // In the above code we want the anon const to have predicates in its param env for `T: Trait`.
528- // However, the anon const cannot inherit predicates from its parent since it's opaque.
529- //
530- // To fix this, we call `explicit_predicates_of` directly on `foo`, the parent's parent.
531-
532- // In the above example this is `foo::{opaque#0}` or `impl Iterator`
533- let parent_hir_id = tcx.local_def_id_to_hir_id(parent_def_id.def_id);
534-
535- // In the above example this is the function `foo`
536- let item_def_id = tcx.hir().get_parent_item(parent_hir_id);
537-
538- // In the above code example we would be calling `explicit_predicates_of(foo)` here
539- return tcx.explicit_predicates_of(item_def_id);
540- }
504+ } else {
505+ true
506+ }
507+ })
508+ .cloned();
509+ return GenericPredicates {
510+ parent: parent_preds.parent,
511+ predicates: { tcx.arena.alloc_from_iter(filtered_predicates) },
512+ };
541513 }
542514 gather_explicit_predicates_of(tcx, def_id)
543515 }
0 commit comments