Resolve anon const's parent generics to opaque's parent

Author: compiler-errors

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -463,6 +463,8 @@ pub(super) fn explicit_predicates_of<'tcx>(
     } else {
         if matches!(def_kind, DefKind::AnonConst) && tcx.features().generic_const_exprs {
             let hir_id = tcx.local_def_id_to_hir_id(def_id);
+            // FIXME(generic_const_exprs): The parenting of this def id is sketchy.
+            // That should be fixed.
             let parent_def_id = tcx.hir().get_parent_item(hir_id);
 
             if let Some(defaulted_param_def_id) =
@@ -529,14 +531,13 @@ pub(super) fn explicit_predicates_of<'tcx>(
                 //
                 // To fix this, we call `explicit_predicates_of` directly on `foo`, the parent's parent.
 
-                // In the above example this is `foo::{opaque#0}` or `impl Iterator`
-                let parent_hir_id = tcx.local_def_id_to_hir_id(parent_def_id.def_id);
-
-                // In the above example this is the function `foo`
-                let item_def_id = tcx.hir().get_parent_item(parent_hir_id);
+                let (hir::OpaqueTyOrigin::FnReturn(item_owner_def_id)
+                | hir::OpaqueTyOrigin::AsyncFn(item_owner_def_id)
+                | hir::OpaqueTyOrigin::TyAlias { parent: item_owner_def_id, .. }) =
+                    tcx.opaque_type_origin(parent_def_id.def_id);
 
                 // In the above code example we would be calling `explicit_predicates_of(foo)` here
-                return tcx.explicit_predicates_of(item_def_id);
+                return tcx.explicit_predicates_of(item_owner_def_id);
             }
         }
         gather_explicit_predicates_of(tcx, def_id)

tests/crashes/118403.rs

@@ -0,0 +1,13 @@
+//@ check-pass
+
+#![feature(generic_const_exprs)]
+//~^ WARN the feature `generic_const_exprs` is incomplete and may not be safe to use
+
+pub fn y<'a, U: 'a>() -> impl IntoIterator<Item = impl IntoIterator<Item = [u8; { 1 + 2 }]> + 'a> {
+    [[[1, 2, 3]]]
+}
+// Make sure that the `predicates_of` for `{ 1 + 2 }` don't mention the duplicated lifetimes of
+// the *outer* iterator. Whether they should mention the duplicated lifetimes of the *inner*
+// iterator are another question, but not really something we need to answer immediately.
+
+fn main() {}

tests/crashes/121574-2.rs

@@ -0,0 +1,11 @@
+warning: the feature `generic_const_exprs` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/double-opaque-parent-predicates.rs:3:12
+   |
+LL | #![feature(generic_const_exprs)]
+   |            ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #76560 <https://github.com/rust-lang/rust/issues/76560> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: 1 warning emitted
+