fix: consider_late_bound field in Generics for RPITs

Author: dfireBird

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

@@ -43,6 +43,12 @@ pub enum LifetimeBoundType {
     LateBound,
 }
 
+impl LifetimeParamData {
+    pub fn is_late_bound(&self) -> bool {
+        self.bound_type == LifetimeBoundType::LateBound
+    }
+}
+
 /// Data about a generic const parameter (to a function, struct, impl, ...).
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub struct ConstParamData {
@@ -306,10 +312,7 @@ impl GenericParams {
 
     #[inline]
     pub fn len_late_bound_lifetimes(&self) -> usize {
-        self.lifetimes
-            .iter()
-            .filter(|(_, p)| !p.is_opaque_captured && p.bound_type == LifetimeBoundType::LateBound)
-            .count()
+        self.lifetimes.iter().filter(|(_, p)| p.bound_type == LifetimeBoundType::LateBound).count()
     }
 
     #[inline]
@@ -345,16 +348,14 @@ impl GenericParams {
     pub fn iter_lt(
         &self,
     ) -> impl DoubleEndedIterator<Item = (LocalLifetimeParamId, &LifetimeParamData)> {
-        self.iter_early_bound_lt().chain(self.iter_late_bound_lt())
+        self.lifetimes.iter()
     }
 
     #[inline]
     pub fn iter_early_bound_lt(
         &self,
     ) -> impl DoubleEndedIterator<Item = (LocalLifetimeParamId, &LifetimeParamData)> {
-        self.lifetimes
-            .iter()
-            .filter(|(_, p)| p.is_opaque_captured || p.bound_type == LifetimeBoundType::EarlyBound)
+        self.lifetimes.iter().filter(|(_, p)| p.bound_type == LifetimeBoundType::EarlyBound)
     }
 
     #[inline]
@@ -412,24 +413,18 @@ 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)| {
-            !(is_opaque_lowering && data.is_opaque_captured)
-                && data.bound_type == LifetimeBoundType::LateBound
-                && id == *lifetime_param_id
+            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)| {
-            ((is_opaque_lowering && data.is_opaque_captured)
-                || data.bound_type == LifetimeBoundType::EarlyBound)
-                && id == *lifetime_param_id
+            data.bound_type == LifetimeBoundType::EarlyBound && id == *lifetime_param_id
         })
     }
 }

crates/hir-ty/src/builtin_derive.rs

@@ -69,14 +69,16 @@ pub(crate) fn generics_of<'db>(
         | BuiltinDeriveImplTrait::Ord
         | BuiltinDeriveImplTrait::PartialOrd
         | BuiltinDeriveImplTrait::Eq
-        | BuiltinDeriveImplTrait::PartialEq => Generics::from_generic_def(db, loc.adt.into()),
+        | BuiltinDeriveImplTrait::PartialEq => {
+            Generics::from_generic_def(db, loc.adt.into(), false)
+        }
         BuiltinDeriveImplTrait::CoerceUnsized | BuiltinDeriveImplTrait::DispatchFromDyn => {
             let trait_id = loc
                 .trait_
                 .get_id(interner.lang_items())
                 .expect("we don't pass the impl to the solver if we can't resolve the trait");
-            let additional_param = coerce_pointee_new_type_param(trait_id).into();
-            Generics::from_generic_def_plus_one(db, loc.adt.into(), additional_param)
+            let additional_param = coerce_pointee_new_type_param(trait_id);
+            Generics::from_generic_def_plus_one(db, loc.adt.into(), additional_param, false)
         }
     }
 }

crates/hir-ty/src/generics.rs

@@ -83,6 +83,16 @@ impl<'db> SingleGenerics<'db> {
             .map(move |(local_id, data)| (LifetimeParamId { parent, local_id }, data))
     }
 
+    fn iter_late_bound_lifetimes(
+        &self,
+        consider_late_bound: bool,
+    ) -> impl Iterator<Item = (LifetimeParamId, &'db LifetimeParamData)> {
+        let parent = self.def;
+        self.params.iter_late_bound_lt().filter_map(move |(local_id, data)| {
+            consider_late_bound.then_some((LifetimeParamId { parent, local_id }, data))
+        })
+    }
+
     pub(crate) fn iter_type_or_consts(
         &self,
     ) -> impl Iterator<Item = (TypeOrConstParamId, &'db TypeOrConstParamData)> {
@@ -118,23 +128,33 @@ impl<'db> SingleGenerics<'db> {
         (trait_self, iter)
     }
 
-    pub(crate) fn iter(&self) -> impl Iterator<Item = (GenericParamId, GenericParamDataRef<'db>)> {
-        let lifetimes = self.iter_lifetimes().map(|(id, data)| {
+    pub(crate) fn iter(
+        &self,
+        consider_late_bound: bool,
+    ) -> impl Iterator<Item = (GenericParamId, GenericParamDataRef<'db>)> {
+        let lifetime_map = |(id, data)| {
             (GenericParamId::LifetimeParamId(id), GenericParamDataRef::LifetimeParamData(data))
-        });
+        };
+        let lifetimes = self.iter_lifetimes().map(lifetime_map);
+        let late_bound_lifetimes =
+            self.iter_late_bound_lifetimes(consider_late_bound).map(lifetime_map);
+
         let (trait_self, type_and_consts) = self.trait_self_and_others();
-        trait_self.into_iter().chain(lifetimes).chain(type_and_consts)
+        trait_self.into_iter().chain(lifetimes).chain(type_and_consts).chain(late_bound_lifetimes)
     }
 
     pub(crate) fn iter_with_idx(
         &self,
     ) -> impl Iterator<Item = (u32, GenericParamId, GenericParamDataRef<'db>)> {
-        std::iter::zip(self.preceding_params_len.., self.iter())
+        std::iter::zip(self.preceding_params_len.., self.iter(false))
             .map(|(index, (id, data))| (index, id, data))
     }
 
-    pub(crate) fn iter_id(&self) -> impl Iterator<Item = GenericParamId> {
-        self.iter().map(|(id, _)| id)
+    pub(crate) fn iter_id(
+        &self,
+        consider_late_bound: bool,
+    ) -> impl Iterator<Item = GenericParamId> {
+        self.iter(consider_late_bound).map(|(id, _)| id)
     }
 
     pub(crate) fn iter_late_bound(
@@ -149,6 +169,18 @@ impl<'db> SingleGenerics<'db> {
             )
         })
     }
+
+    pub(crate) fn type_or_const_param(&self, param_id: TypeParamId) -> GenericParamDataRef<'db> {
+        let data = &self.params[param_id.local_id()];
+        match data {
+            TypeOrConstParamData::TypeParamData(type_param_data) => {
+                GenericParamDataRef::TypeParamData(type_param_data)
+            }
+            TypeOrConstParamData::ConstParamData(const_param_data) => {
+                GenericParamDataRef::ConstParamData(const_param_data)
+            }
+        }
+    }
 }
 
 impl<'db> Generics<'db> {
@@ -182,7 +214,7 @@ impl<'db> Generics<'db> {
     pub(crate) fn iter_self(
         &self,
     ) -> impl Iterator<Item = (GenericParamId, GenericParamDataRef<'db>)> {
-        self.owner().iter()
+        self.owner().iter(false)
     }
 
     pub(crate) fn iter_self_with_idx(
@@ -198,7 +230,7 @@ impl<'db> Generics<'db> {
     }
 
     pub(crate) fn iter_parent_id(&self) -> impl Iterator<Item = GenericParamId> {
-        self.parent().into_iter().flat_map(|parent| parent.iter_id())
+        self.parent().into_iter().flat_map(move |parent| parent.iter_id(false))
     }
 
     pub(crate) fn iter_self_type_or_consts(
@@ -208,13 +240,18 @@ impl<'db> Generics<'db> {
     }
 
     /// Iterate over the parent params followed by self params.
-    #[cfg(test)]
-    pub(crate) fn iter(&self) -> impl Iterator<Item = (GenericParamId, GenericParamDataRef<'_>)> {
-        self.iter_owners().flat_map(|owner| owner.iter())
+    pub(crate) fn iter(
+        &self,
+        consider_late_bound: bool,
+    ) -> impl Iterator<Item = (GenericParamId, GenericParamDataRef<'db>)> {
+        self.iter_owners().flat_map(move |owner| owner.iter(consider_late_bound))
     }
 
-    pub(crate) fn iter_id(&self) -> impl Iterator<Item = GenericParamId> {
-        self.iter_owners().flat_map(|owner| owner.iter_id())
+    pub(crate) fn iter_id(
+        &self,
+        consider_late_bound: bool,
+    ) -> impl Iterator<Item = GenericParamId> {
+        self.iter_owners().flat_map(move |owner| owner.iter_id(consider_late_bound))
     }
 
     /// Returns total number of generic parameters in scope, including those from parent.
@@ -298,16 +335,19 @@ impl<'db> Generics<'db> {
     pub(crate) fn lifetime_param_idx(
         &self,
         param: LifetimeParamId,
-        is_opaque_lowering: bool,
+        is_lowering_impl_trait_bounds: 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, is_opaque_lowering)
-        {
+        if is_lowering_impl_trait_bounds {
+            let idx = self.opaque_lifetime_idx(param);
+            return (owner.preceding_params_len + (idx as u32), false);
+        }
+
+        if let Some(late_bound_idx) = owner.params.late_bound_lifetime_idx(&param.local_id) {
             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, is_opaque_lowering) {
+        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)
             }
@@ -326,6 +366,22 @@ impl<'db> Generics<'db> {
         });
         Generics { chain }
     }
+
+    pub(crate) fn type_or_const_param(&self, param_id: TypeParamId) -> GenericParamDataRef<'db> {
+        self.find_owner(param_id.parent()).type_or_const_param(param_id)
+    }
+
+    fn opaque_lifetime_idx(&self, param: LifetimeParamId) -> usize {
+        self.find_owner(param.parent)
+            .iter_id(true)
+            .position(|id| {
+                let GenericParamId::LifetimeParamId(id) = id else {
+                    return false;
+                };
+                param == id
+            })
+            .unwrap()
+    }
 }
 
 pub(crate) struct ProvenanceSplit {

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

@@ -333,7 +333,7 @@ impl<'a, 'db> InferenceContext<'a, 'db> {
                 let args = GenericArgs::for_item(
                     self.interner(),
                     trait_did.into(),
-                    |param_idx, param_id, _| match param_id {
+                    |param_idx, (param_id, _), _| match param_id {
                         GenericParamId::LifetimeParamId(_) | GenericParamId::ConstParamId(_) => {
                             unreachable!("did not expect operand trait to have lifetime/const args")
                         }

crates/hir-ty/src/lower.rs

@@ -67,7 +67,7 @@ use crate::{
         FnSigKind, FxIndexMap, GenericArg, GenericArgs, ParamConst, ParamEnv, Pattern, PolyFnSig,
         Predicate, Region, StoredClauses, StoredEarlyBinder, StoredGenericArg, StoredGenericArgs,
         StoredPolyFnSig, StoredTraitRef, StoredTy, TraitPredicate, TraitRef, Ty, Tys, Unnormalized,
-        abi::Safety, util::BottomUpFolder,
+        abi::Safety, mk_param, util::BottomUpFolder,
     },
 };
 
@@ -220,6 +220,7 @@ pub struct TyLoweringContext<'db, 'a> {
     forbid_params_after_reason: ForbidParamsAfterReason,
     pub(crate) defined_anon_consts: ThinVec<AnonConstId>,
     infer_vars: Option<&'a mut dyn TyLoweringInferVarsCtx<'db>>,
+    is_lowering_impl_trait_bounds: bool,
     bound_vars: Vec<BoundVarKinds<'db>>, // FIXME: HRTB and other for lifetime doesn't change it now
     lifetime_lowering_mode: LifetimeLoweringMode,
 }
@@ -259,6 +260,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             forbid_params_after_reason: ForbidParamsAfterReason::AnonConst,
             defined_anon_consts: ThinVec::new(),
             infer_vars: None,
+            is_lowering_impl_trait_bounds: false,
             bound_vars,
             lifetime_lowering_mode,
         }
@@ -585,8 +587,41 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                             });
                         self.impl_trait_mode.opaque_type_data[idx] = actual_opaque_type_data;
 
-                        let args =
-                            GenericArgs::identity_for_item(self.interner, opaque_ty_id.into());
+                        let mut late_bound_index = 0;
+                        let args = GenericArgs::for_item(
+                            self.interner,
+                            opaque_ty_id.into(),
+                            |index, param @ (id, data), _| {
+                                if let GenericParamDataRef::LifetimeParamData(lt) = data
+                                    && lt.is_late_bound()
+                                {
+                                    let GenericParamId::LifetimeParamId(id) = id else {
+                                        unreachable!()
+                                    };
+                                    let bound_region_kind =
+                                        BoundRegionKind::Named(id.parent.into());
+                                    let region = match self.lifetime_lowering_mode {
+                                        LifetimeLoweringMode::Bound => Region::new_bound(
+                                            interner,
+                                            self.in_binders,
+                                            BoundRegion {
+                                                var: BoundVar::from_u32(late_bound_index),
+                                                kind: bound_region_kind,
+                                            },
+                                        ),
+                                        LifetimeLoweringMode::LateParam => Region::new_late_param(
+                                            interner,
+                                            self.generic_def.into(),
+                                            bound_region_kind,
+                                        ),
+                                    };
+                                    late_bound_index += 1;
+                                    return region.into();
+                                }
+
+                                mk_param(interner, index - late_bound_index, param)
+                            },
+                        );
                         Ty::new_alias(
                             self.interner,
                             AliasTy::new_from_args(
@@ -819,7 +854,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                             Binder::bind_with_vars(
                                 rustc_type_ir::PredicateKind::Clause(
                                     rustc_type_ir::ClauseKind::Trait(TraitPredicate {
-                                        trait_ref,
+                                        trait_ref: trait_ref,
                                         polarity: rustc_type_ir::PredicatePolarity::Positive,
                                     }),
                                 ),
@@ -1145,6 +1180,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             self.interner,
             AliasTy::new_from_args(interner, rustc_type_ir::Opaque { def_id: def_id.into() }, args),
         );
+        let prev_is_lowering_impl_trait_bounds =
+            mem::replace(&mut self.is_lowering_impl_trait_bounds, true);
         let (predicates, assoc_ty_bounds_start) =
             self.with_shifted_in(DebruijnIndex::from_u32(1), |ctx| {
                 let mut predicates = Vec::new();
@@ -1166,14 +1203,18 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                             trait_id.into(),
                             GenericArgs::new_from_slice(&[self_ty.into()]),
                         );
+                        let binder = BoundVarKinds::new_from_slice(ctx.bound_vars.last().unwrap());
                         Clause(Predicate::new(
                             interner,
-                            Binder::dummy(rustc_type_ir::PredicateKind::Clause(
-                                rustc_type_ir::ClauseKind::Trait(TraitPredicate {
-                                    trait_ref,
-                                    polarity: rustc_type_ir::PredicatePolarity::Positive,
-                                }),
-                            )),
+                            Binder::bind_with_vars(
+                                rustc_type_ir::PredicateKind::Clause(
+                                    rustc_type_ir::ClauseKind::Trait(TraitPredicate {
+                                        trait_ref,
+                                        polarity: rustc_type_ir::PredicatePolarity::Positive,
+                                    }),
+                                ),
+                                binder,
+                            ),
                         ))
                     });
                     predicates.extend(sized_clause);
@@ -1184,6 +1225,7 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
                 (predicates, assoc_ty_bounds_start)
             });
 
+        self.is_lowering_impl_trait_bounds = prev_is_lowering_impl_trait_bounds;
         ImplTrait {
             predicates: Clauses::new_from_slice(&predicates).store(),
             assoc_ty_bounds_start,
@@ -1195,10 +1237,8 @@ impl<'db, 'a> TyLoweringContext<'db, 'a> {
             Some(resolution) => match resolution {
                 LifetimeNs::Static => Region::new_static(self.interner),
                 LifetimeNs::LifetimeParam(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.generics().lifetime_param_idx(id, self.is_lowering_impl_trait_bounds);
                     self.region_param(id, idx, is_late_bound)
                 }
             },