fix: idx and type of lifetimes captured by opaque

Author: dfireBird

crates/hir-def/src/hir/generics.rs

@@ -306,7 +306,10 @@ impl GenericParams {
 
     #[inline]
     pub fn len_late_bound_lifetimes(&self) -> usize {
-        self.lifetimes.iter().filter(|(_, p)| p.bound_type == LifetimeBoundType::LateBound).count()
+        self.lifetimes
+            .iter()
+            .filter(|(_, p)| !p.is_opaque_captured && p.bound_type == LifetimeBoundType::LateBound)
+            .count()
     }
 
     #[inline]
@@ -409,18 +412,24 @@ impl GenericParams {
     pub fn late_bound_lifetime_idx(
         &self,
         lifetime_param_id: &LocalLifetimeParamId,
+        is_opaque_lowering: bool,
     ) -> Option<usize> {
         self.iter_late_bound_lt().position(|(id, data)| {
-            data.bound_type == LifetimeBoundType::LateBound && id == *lifetime_param_id
+            !(is_opaque_lowering && data.is_opaque_captured)
+                && data.bound_type == LifetimeBoundType::LateBound
+                && id == *lifetime_param_id
         })
     }
 
     pub fn early_bound_lifetime_idx(
         &self,
         lifetime_param_id: &LocalLifetimeParamId,
+        is_opaque_lowering: bool,
     ) -> Option<usize> {
         self.iter_early_bound_lt().position(|(id, data)| {
-            data.bound_type == LifetimeBoundType::EarlyBound && id == *lifetime_param_id
+            ((is_opaque_lowering && data.is_opaque_captured)
+                || data.bound_type == LifetimeBoundType::EarlyBound)
+                && id == *lifetime_param_id
         })
     }
 }

crates/hir-ty/src/generics.rs

@@ -295,13 +295,19 @@ impl<'db> Generics<'db> {
     }
 
     // Rename this?
-    pub(crate) fn lifetime_param_idx(&self, param: LifetimeParamId) -> (u32, bool) {
+    pub(crate) fn lifetime_param_idx(
+        &self,
+        param: LifetimeParamId,
+        is_opaque_lowering: bool,
+    ) -> (u32, bool) {
         let owner = self.find_owner(param.parent);
-        if let Some(late_bound_idx) = owner.params.late_bound_lifetime_idx(&param.local_id) {
+        if let Some(late_bound_idx) =
+            owner.params.late_bound_lifetime_idx(&param.local_id, is_opaque_lowering)
+        {
             return (late_bound_idx as u32, true);
         }
         let has_trait_self = matches!(owner.def, GenericDefId::TraitId(_));
-        match owner.params.early_bound_lifetime_idx(&param.local_id) {
+        match owner.params.early_bound_lifetime_idx(&param.local_id, is_opaque_lowering) {
             Some(idx) => {
                 (owner.preceding_params_len + u32::from(has_trait_self) + (idx as u32), false)
             }

crates/hir-ty/src/lib.rs

@@ -220,7 +220,7 @@ pub fn type_or_const_param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) ->
 }
 
 pub fn lifetime_param_idx(db: &dyn HirDatabase, id: LifetimeParamId) -> u32 {
-    generics::generics(db, id.parent).lifetime_param_idx(id).0
+    generics::generics(db, id.parent).lifetime_param_idx(id, false).0
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]

crates/hir-ty/src/lower.rs

@@ -238,7 +238,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
         let impl_trait_mode = ImplTraitLoweringState::new(ImplTraitLoweringMode::Disallowed);
         let in_binders = DebruijnIndex::ZERO;
         let interner = DbInterner::new_with(db, resolver.krate());
-        let bound_vars = Vec::from(&[Self::bound_vars(db, interner, generic_def.into())]);
+        let bound_vars = Vec::from(&[Self::bound_vars(db, interner, generic_def)]);
         Self {
             db,
             // Can provide no block since we don't use it for trait solving.
@@ -1195,7 +1195,10 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             Some(resolution) => match resolution {
                 LifetimeNs::Static => Region::new_static(self.interner),
                 LifetimeNs::LifetimeParam(id) => {
-                    let (idx, is_late_bound) = self.generics().lifetime_param_idx(id);
+                    let is_opaque_lowering =
+                        self.impl_trait_mode.mode == ImplTraitLoweringMode::Opaque;
+                    let (idx, is_late_bound) =
+                        self.generics().lifetime_param_idx(id, is_opaque_lowering);
                     self.region_param(id, idx, is_late_bound)
                 }
             },

crates/hir-ty/src/tests/simple.rs

@@ -4305,22 +4305,3 @@ enum Enum {
         "#]],
     );
 }
-
-#[test]
-fn rpit_with_lifetimes() {
-    check_infer(
-        r#"
-struct Event<'a> {};
-struct Range<T> {}
-trait Iterator {
-    type Item;
-}
-
-struct Vec<T> {}
-
-fn foo<'e>(events: &'e mut dyn Iterator<Item = (Event<'e>, Range<usize>)>) -> impl Iterator<Item = Event<'e>> {
-
-}"#,
-        expect![[r#""#]],
-    );
-}

crates/hir-ty/src/tests/traits.rs

@@ -1634,10 +1634,10 @@ fn test<'lifetime>(
 ) {}
 "#,
         expect![[r#"
-            39..40 'a': impl Trait + '?0.0
-            70..71 'b': impl '?0.0
+            39..40 'a': impl Trait + 'lifetime
+            70..71 'b': impl 'lifetime
             93..94 'c': impl Trait
-            114..115 'd': impl '?0.0
+            114..115 'd': impl 'lifetime
             139..140 'e': impl ?Sized
             159..160 'f': impl Trait + ?Sized
             184..186 '{}': ()
@@ -4875,14 +4875,31 @@ fn allowed3(baz: impl Baz<Assoc = Qux<impl Foo>>) {}
             431..433 '{}': ()
             447..450 'baz': impl Baz<Assoc = impl Foo>
             480..482 '{}': ()
-            500..503 'baz': impl Baz<Assoc = &'?0.0 (impl Foo + '?0.0)>
+            500..503 'baz': impl Baz<Assoc = &'a (impl Foo + 'a)>
             544..546 '{}': ()
             560..563 'baz': impl Baz<Assoc = Qux<impl Foo>>
             598..600 '{}': ()
         "#]],
     )
 }
 
+#[test]
+fn rpit_with_lifetimes() {
+    check_no_mismatches(
+        r#"
+struct Event<'a> {};
+struct Range<T> {}
+trait Iterator {
+    type Item;
+}
+
+struct Vec<T> {}
+
+fn foo<'e>(events: &'e mut dyn Iterator<Item = (Event<'e>, Range<usize>)>) -> impl Iterator<Item = Event<'e>> {}
+"#,
+    );
+}
+
 #[test]
 fn recursive_tail_sized() {
     check_infer(