fix: early/late bound idx and opaque captured lifetimes

Author: dfireBird

crates/hir-def/src/expr_store/lower.rs

@@ -559,13 +559,15 @@ pub struct NamedLifetimeStore {
     lifetimes_in_where_clause: FxIndexSet<Name>,
     lifetimes_constraint_by_input: FxIndexSet<Name>,
     lifetimes_in_output: FxIndexSet<Name>,
+    opaque_captured_lifetimes: FxIndexSet<Name>,
 }
 
 #[derive(Debug)]
 enum LifetimeBoundScope {
     Argument,
     Return,
     WhereClause,
+    ImplTrait(bool),
 }
 
 impl NamedLifetimeStore {
@@ -574,13 +576,23 @@ impl NamedLifetimeStore {
     pub(crate) fn push_named_lifetime(&mut self, lifetime: Name) {
         match self.lifetime_bound_scope {
             Some(LifetimeBoundScope::Argument) => {
-                self.lifetimes_constraint_by_input.insert(lifetime)
+                self.lifetimes_constraint_by_input.insert(lifetime);
+            }
+            Some(LifetimeBoundScope::Return) => {
+                self.lifetimes_in_output.insert(lifetime);
             }
-            Some(LifetimeBoundScope::Return) => self.lifetimes_in_output.insert(lifetime),
             Some(LifetimeBoundScope::WhereClause) => {
-                self.lifetimes_in_where_clause.insert(lifetime)
+                self.lifetimes_in_where_clause.insert(lifetime);
+            }
+            Some(LifetimeBoundScope::ImplTrait(is_argument_scope)) => {
+                if is_argument_scope {
+                    self.lifetimes_in_where_clause.insert(lifetime);
+                } else {
+                    self.opaque_captured_lifetimes.insert(lifetime.clone());
+                    self.lifetimes_in_output.insert(lifetime);
+                }
             }
-            _ => false,
+            _ => (),
         };
     }
 }
@@ -751,8 +763,16 @@ impl<'db> ExprCollector<'db> {
                     TypeRef::Error
                 } else {
                     return self.with_outer_impl_trait_scope(true, |this| {
-                        let type_bounds =
-                            this.type_bounds_from_ast(inner.type_bound_list(), impl_trait_lower_fn);
+                        let is_argument_lt_bound_scope = this.is_argument_lt_bound_scope();
+                        let type_bounds = this.with_lifetime_bound_scope(
+                            LifetimeBoundScope::ImplTrait(is_argument_lt_bound_scope),
+                            |this| {
+                                this.type_bounds_from_ast(
+                                    inner.type_bound_list(),
+                                    impl_trait_lower_fn,
+                                )
+                            },
+                        );
                         impl_trait_lower_fn(this, AstPtr::new(&node), type_bounds)
                     });
                 }

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

@@ -143,6 +143,7 @@ impl GenericParamsCollector {
                         let param = LifetimeParamData {
                             name: name.clone(),
                             bound_type: LifetimeBoundType::EarlyBound,
+                            is_opaque_captured: false,
                         };
                         let _idx = self.lifetimes.alloc(param);
                         ec.with_lifetime_bound_scope(LifetimeBoundScope::WhereClause, |ec| {
@@ -291,6 +292,10 @@ impl GenericParamsCollector {
     ) {
         for (_param_id, lifetime) in self.lifetimes.iter_mut() {
             let lifetime_name = &lifetime.name;
+            if named_lifetime_store.opaque_captured_lifetimes.contains(lifetime_name) {
+                lifetime.is_opaque_captured = true;
+            }
+
             if named_lifetime_store.lifetimes_in_where_clause.contains(lifetime_name) {
                 continue;
             }

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

@@ -34,6 +34,7 @@ pub struct TypeParamData {
 pub struct LifetimeParamData {
     pub name: Name,
     pub bound_type: LifetimeBoundType,
+    pub is_opaque_captured: bool,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -348,7 +349,9 @@ impl GenericParams {
     pub fn iter_early_bound_lt(
         &self,
     ) -> impl DoubleEndedIterator<Item = (LocalLifetimeParamId, &LifetimeParamData)> {
-        self.lifetimes.iter().filter(|(_, p)| p.bound_type == LifetimeBoundType::EarlyBound)
+        self.lifetimes
+            .iter()
+            .filter(|(_, p)| p.is_opaque_captured || p.bound_type == LifetimeBoundType::EarlyBound)
     }
 
     #[inline]
@@ -411,4 +414,13 @@ impl GenericParams {
             data.bound_type == LifetimeBoundType::LateBound && id == *lifetime_param_id
         })
     }
+
+    pub fn early_bound_lifetime_idx(
+        &self,
+        lifetime_param_id: &LocalLifetimeParamId,
+    ) -> Option<usize> {
+        self.iter_early_bound_lt().position(|(id, data)| {
+            data.bound_type == LifetimeBoundType::EarlyBound && id == *lifetime_param_id
+        })
+    }
 }

crates/hir-ty/src/generics.rs

@@ -301,12 +301,12 @@ impl<'db> Generics<'db> {
             return (late_bound_idx as u32, true);
         }
         let has_trait_self = matches!(owner.def, GenericDefId::TraitId(_));
-        (
-            owner.preceding_params_len
-                + u32::from(has_trait_self)
-                + param.local_id.into_raw().into_u32(),
-            false,
-        )
+        match owner.params.early_bound_lifetime_idx(&param.local_id) {
+            Some(idx) => {
+                (owner.preceding_params_len + u32::from(has_trait_self) + (idx as u32), false)
+            }
+            _ => unreachable!(),
+        }
     }
 
     #[deprecated = "don't use this; it's easy to expose an erroneous `Generics` with this"]

crates/hir-ty/src/infer/closure.rs

@@ -304,7 +304,7 @@ impl<'db> InferenceContext<'_, 'db> {
         };
 
         // Now go through the argument patterns
-        for (arg_pat, arg_ty) in args.iter().zip(bound_sig.skip_binder().inputs()) {
+        for (arg_pat, arg_ty) in args.iter().zip(liberated_sig.inputs()) {
             self.infer_top_pat(*arg_pat, *arg_ty, PatOrigin::Param);
         }
 
@@ -1148,8 +1148,9 @@ impl<'db> InferenceContext<'_, 'db> {
     }
 
     fn closure_sigs(&self, bound_sig: PolyFnSig<'db>) -> ClosureSignatures<'db> {
-        let liberated_sig = bound_sig.skip_binder();
-        // FIXME: When we lower HRTB we'll need to actually liberate regions here.
+        // TODO: def id needs to be changed?
+        let liberated_sig =
+            self.interner().liberate_late_bound_regions(self.owner.into(), bound_sig);
         ClosureSignatures { bound_sig, liberated_sig }
     }
 }

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

@@ -4305,3 +4305,22 @@ 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#""#]],
+    );
+}