half work

Author: ChayimFriedman2

crates/hir-ty/src/display.rs

@@ -684,7 +684,8 @@ impl HirDisplay for ProjectionTy {
                         ),
                         &assoc_type
                             .bounds
-                            .skip_binders()
+                            .clone()
+                            .substitute(Interner, &self.substitution)
                             .iter()
                             .map(|bound| {
                                 // We ignore `Self` anyway when formatting, so it's fine put an error type in it.

crates/hir-ty/src/lower.rs

@@ -52,7 +52,7 @@ use crate::{
     FnSubst, ImplTrait, ImplTraitId, ImplTraits, Interner, Lifetime, LifetimeData,
     LifetimeOutlives, PlaceholderIndex, PolyFnSig, ProgramClause, ProjectionTy,
     QuantifiedWhereClause, QuantifiedWhereClauses, Substitution, TraitEnvironment, TraitRef,
-    TraitRefExt, Ty, TyBuilder, TyKind, VariableKind, VariableKinds, WhereClause, all_super_traits,
+    TraitRefExt, Ty, TyBuilder, TyKind, VariableKinds, WhereClause, all_super_traits,
     chalk_db::generic_predicate_to_inline_bound,
     consteval::{intern_const_ref, path_to_const, unknown_const, unknown_const_as_generic},
     db::HirDatabase,
@@ -519,15 +519,7 @@ impl<'a> TyLoweringContext<'a> {
 
         let assoc_type_binders = VariableKinds::from_iter(
             Interner,
-            method_generics.iter_id().map(|param_id| match param_id {
-                GenericParamId::TypeParamId(_) => {
-                    VariableKind::Ty(chalk_ir::TyVariableKind::General)
-                }
-                GenericParamId::ConstParamId(param_id) => {
-                    VariableKind::Const(self.db.const_param_ty(param_id))
-                }
-                GenericParamId::LifetimeParamId(_) => VariableKind::Lifetime,
-            }),
+            variable_kinds_from_generics(self.db, method_generics.iter_id()),
         );
 
         let returned_subst = self.subst_for_generics();

crates/hir-ty/src/rpitit.rs

@@ -5,23 +5,27 @@ use std::{iter, sync::Arc};
 use base_db::impl_intern_key_ref;
 use chalk_ir::{
     BoundVar, DebruijnIndex,
+    cast::Cast,
     fold::{TypeFoldable, TypeFolder, TypeSuperFoldable},
 };
 use chalk_solve::rust_ir::AssociatedTyValueBound;
 use hir_def::{
-    AssocItemId, FunctionId, GenericDefId, ImplId, TraitId,
+    AssocItemId, FunctionId, GenericDefId, GenericParamId, ImplId, TraitId,
     hir::generics::{GenericParams, TypeOrConstParamData},
+    resolver::HasResolver,
 };
 use rustc_hash::FxHashMap;
+use thin_vec::ThinVec;
 
 use crate::{
     AliasTy, AnyTraitAssocType, Binders, Const, ConstData, ConstValue, DomainGoal, Goal, GoalData,
-    InferenceTable, Interner, Lifetime, LifetimeData, PlaceholderIndex, ProjectionTy, Substitution,
-    Ty, TyKind, VariableKinds,
+    ImplTraitLoweringMode, InferenceTable, Interner, Lifetime, LifetimeData, LifetimeElisionKind,
+    ParamLoweringMode, PlaceholderIndex, ProjectionTy, Substitution, TraitRef, Ty, TyKind,
+    TyLoweringContext, VariableKinds,
     chalk_db::{AssociatedTyValue, inline_bound_to_generic_predicate},
     db::HirDatabase,
     from_assoc_type_id, from_placeholder_idx,
-    generics::generics,
+    generics::{Generics, generics},
     lt_from_placeholder_idx,
     mapping::{ToChalk, to_assoc_type_id_rpitit},
     variable_kinds_from_generics,
@@ -58,15 +62,14 @@ impl_intern_key_ref!(RpititImplAssocTyId, RpititImplAssocTy);
 #[salsa_macros::tracked(return_ref)]
 pub(crate) fn impl_method_rpitit_values(
     db: &dyn HirDatabase,
-    impl_id: hir_def::ImplId,
+    impl_id: ImplId,
     trait_method_id: FunctionId,
 ) -> Box<[Arc<AssociatedTyValue>]> {
     let impl_items = db.impl_items(impl_id);
     let trait_method_generics = generics(db, trait_method_id.into());
-    let impl_datum =
-        db.impl_datum(impl_id.loc(db).container.krate(), hir_def::ImplId::to_chalk(impl_id, db));
     let trait_method = db.function_signature(trait_method_id);
-    let Some(impl_method) = impl_items.items.iter().find_map(|(name, id)| {
+    let impl_trait_ref = db.impl_trait(impl_id).expect("invalid impl passed to Chalk");
+    let impl_method = impl_items.items.iter().find_map(|(name, id)| {
         if *name == trait_method.name {
             match *id {
                 AssocItemId::FunctionId(it) => Some(it),
@@ -75,9 +78,19 @@ pub(crate) fn impl_method_rpitit_values(
         } else {
             None
         }
-    }) else {
-        // FIXME: Handle defaulted methods.
-        return Box::default();
+    });
+    let impl_method = match impl_method {
+        Some(impl_method) => impl_method,
+        None => {
+            // Method not in the impl, so it is defaulted.
+            return defaulted_impl_method_rpitit_values(
+                db,
+                impl_id,
+                trait_method_id,
+                impl_trait_ref,
+                &trait_method_generics,
+            );
+        }
     };
 
     let impl_method_generics = generics(db, impl_method.into());
@@ -107,11 +120,7 @@ pub(crate) fn impl_method_rpitit_values(
     let trait_ref_placeholder_subst =
         &impl_method_placeholder_subst.as_slice(Interner)[..impl_method_generics.len_parent()];
     // We want to substitute the TraitRef with placeholders, but placeholders from the method, not the impl.
-    let impl_trait_ref = impl_datum
-        .binders
-        .as_ref()
-        .map(|it| it.trait_ref.clone())
-        .substitute(Interner, trait_ref_placeholder_subst);
+    let impl_trait_ref = impl_trait_ref.substitute(Interner, trait_ref_placeholder_subst);
     let trait_to_impl_args = Substitution::from_iter(
         Interner,
         impl_trait_ref.substitution.as_slice(Interner).iter().chain(
@@ -139,7 +148,7 @@ pub(crate) fn impl_method_rpitit_values(
     table.unify(&trait_method_ret, &impl_method_ret);
     table.resolve_obligations_as_possible();
 
-    return trait_rpitit_to_infer_var
+    trait_rpitit_to_infer_var
         .into_iter()
         .map(|(trait_assoc_id, infer_var)| {
             let impl_rpitit = table.resolve_completely(infer_var);
@@ -148,6 +157,11 @@ pub(crate) fn impl_method_rpitit_values(
                     db,
                     method: impl_method.into(),
                     method_generics: impl_method_generics.self_params(),
+                    parent: impl_id.into(),
+                    parent_generics: impl_method_generics
+                        .parent_generics()
+                        .expect("parent should be an impl")
+                        .self_params(),
                 },
                 DebruijnIndex::INNERMOST,
             );
@@ -169,146 +183,142 @@ pub(crate) fn impl_method_rpitit_values(
                 value: impl_rpitit,
             })
         })
-        .collect();
-
-    #[derive(chalk_derive::FallibleTypeFolder)]
-    #[has_interner(Interner)]
-    struct RpititToInferVarFolder<'a, 'b> {
-        db: &'a dyn HirDatabase,
-        table: &'a mut InferenceTable<'b>,
-        trait_rpitit_to_infer_var: FxHashMap<RpititTraitAssocTyId, Ty>,
-        trait_method_id: FunctionId,
-    }
-    impl TypeFolder<Interner> for RpititToInferVarFolder<'_, '_> {
-        fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
-            self
-        }
-
-        fn interner(&self) -> Interner {
-            Interner
-        }
+        .collect()
+}
 
-        fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Ty {
-            let result = match ty.kind(Interner) {
-                TyKind::Alias(AliasTy::Projection(ProjectionTy {
-                    associated_ty_id,
-                    substitution,
-                }))
-                | TyKind::AssociatedType(associated_ty_id, substitution) => {
-                    if let AnyTraitAssocType::Rpitit(assoc_id) =
-                        from_assoc_type_id(self.db, *associated_ty_id)
-                    {
-                        let assoc = assoc_id.loc(self.db);
-                        if assoc.synthesized_from_method == self.trait_method_id {
-                            if let Some(ty) = self.trait_rpitit_to_infer_var.get(&assoc_id) {
-                                return ty.clone();
-                            }
-
-                            // Replace with new infer var.
-                            // This needs to come before we fold the bounds, because they also contain this associated type.
-                            let var = self.table.new_type_var();
-                            self.trait_rpitit_to_infer_var.insert(assoc_id, var.clone());
-
-                            // Recurse into bounds, so that nested RPITITs will be handled correctly.
-                            for bound in assoc.bounds.clone().substitute(Interner, substitution) {
-                                let bound = inline_bound_to_generic_predicate(&bound, var.clone());
-                                let bound = bound.fold_with(self, outer_binder);
-                                let bound = self.table.normalize_associated_types_in(bound);
-                                self.table.register_obligation(Goal::new(
-                                    Interner,
-                                    GoalData::Quantified(
-                                        chalk_ir::QuantifierKind::ForAll,
-                                        bound.map(|bound| {
-                                            Goal::new(
-                                                Interner,
-                                                GoalData::DomainGoal(DomainGoal::Holds(bound)),
-                                            )
-                                        }),
-                                    ),
-                                ));
-                            }
-
-                            return var;
-                        }
-                    }
-                    ty.clone()
-                }
-                _ => ty.clone(),
-            };
-            result.super_fold_with(self, outer_binder)
-        }
-    }
+fn defaulted_impl_method_rpitit_values(
+    db: &dyn HirDatabase,
+    impl_id: ImplId,
+    trait_method_id: FunctionId,
+    impl_trait_ref: Binders<TraitRef>,
+    trait_method_generics: &Generics,
+) -> Box<[Arc<AssociatedTyValue>]> {
+    let defaulted_rpitit_values = defaulted_trait_method_rpitit_values(db, trait_method_id);
+    let impl_generics = generics(db, impl_id.into());
+    // The associated type generics as the same as the trait method's, but we take the impl as
+    // the parent instead of the trait.
+    // The impl generics need to be shifted to account for the associated type generics.
+    let trait_method_subst = trait_method_generics.bound_vars_subst(db, DebruijnIndex::INNERMOST);
+    let impl_subst = Substitution::from_iter(
+        Interner,
+        impl_generics.iter_id().enumerate().map(|(idx, id)| match id {
+            GenericParamId::ConstParamId(id) => {
+                BoundVar::new(DebruijnIndex::INNERMOST, idx + trait_method_generics.len_self())
+                    .to_const(Interner, db.const_param_ty(id))
+                    .cast(Interner)
+            }
+            GenericParamId::TypeParamId(_) => {
+                BoundVar::new(DebruijnIndex::INNERMOST, idx + trait_method_generics.len_self())
+                    .to_ty(Interner)
+                    .cast(Interner)
+            }
+            GenericParamId::LifetimeParamId(_) => {
+                BoundVar::new(DebruijnIndex::INNERMOST, idx + trait_method_generics.len_self())
+                    .to_lifetime(Interner)
+                    .cast(Interner)
+            }
+        }),
+    );
+    let impl_trait_ref = impl_trait_ref.substitute(Interner, &impl_subst);
+    let impl_rpitit_subst = Substitution::from_iter(
+        Interner,
+        trait_method_subst.as_slice(Interner)[..trait_method_generics.len_self()]
+            .iter()
+            .chain(impl_trait_ref.substitution.as_slice(Interner)),
+    );
+    let binders = VariableKinds::from_iter(
+        Interner,
+        variable_kinds_from_generics(
+            db,
+            trait_method_generics.iter_self_id().chain(impl_generics.iter_id()),
+        ),
+    );
+    defaulted_rpitit_values
+        .iter()
+        .map(|(trait_assoc, trait_rpitit)| {
+            let impl_rpitit = trait_rpitit.clone().substitute(Interner, &impl_rpitit_subst);
+            Arc::new(AssociatedTyValue {
+                associated_ty_id: to_assoc_type_id_rpitit(*trait_assoc),
+                impl_id: ImplId::to_chalk(impl_id, db),
+                value: Binders::new(binders.clone(), AssociatedTyValueBound { ty: impl_rpitit }),
+            })
+        })
+        .collect()
+}
 
-    #[derive(chalk_derive::FallibleTypeFolder)]
-    #[has_interner(Interner)]
-    struct PlaceholderToBoundVarFolder<'a> {
-        db: &'a dyn HirDatabase,
-        method: GenericDefId,
-        method_generics: &'a GenericParams,
-    }
-    impl TypeFolder<Interner> for PlaceholderToBoundVarFolder<'_> {
-        fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
-            self
-        }
+/// This is called only for defaulted trait methods, as there the value of the RPITIT associated
+/// items on an impl (if the method body is left defaulted) is the same as with the trait method.
+// This returns an `EmptyOptimizedThinVec` and not `Box<[]>` because this is called from inference,
+// and most methods don't have RPITITs.
+#[salsa_macros::tracked(return_ref)]
+pub(crate) fn defaulted_trait_method_rpitit_values(
+    db: &dyn HirDatabase,
+    method_id: FunctionId,
+) -> ThinVec<(RpititTraitAssocTyId, Binders<Ty>)> {
+    let method_generics = generics(db, method_id.into());
+    let mut table = InferenceTable::new(db, db.trait_environment(method_id.into()));
 
-        fn interner(&self) -> Interner {
-            Interner
-        }
+    let data = db.function_signature(method_id);
+    let resolver = method_id.resolver(db);
+    let mut ctx_ret = TyLoweringContext::new(
+        db,
+        &resolver,
+        &data.store,
+        method_id.into(),
+        LifetimeElisionKind::Infer,
+    )
+    .with_impl_trait_mode(ImplTraitLoweringMode::Opaque)
+    .with_type_param_mode(ParamLoweringMode::Placeholder);
+    // This is the return type of the method, with RPITIT lowered as opaques. In other words, like if it was written
+    // in an impl.
+    let method_opaques_ret = match data.ret_type {
+        Some(ret_type) => ctx_ret.lower_ty(ret_type),
+        None => TyKind::Tuple(0, Substitution::empty(Interner)).intern(Interner),
+    };
+    let method_opaques_ret = table.normalize_associated_types_in(method_opaques_ret);
 
-        fn fold_free_placeholder_ty(
-            &mut self,
-            universe: PlaceholderIndex,
-            _outer_binder: DebruijnIndex,
-        ) -> Ty {
-            let placeholder = from_placeholder_idx(self.db, universe);
-            if placeholder.parent == self.method {
-                BoundVar::new(
-                    DebruijnIndex::INNERMOST,
-                    placeholder.local_id.into_raw().into_u32() as usize
-                        + self.method_generics.len_lifetimes(),
-                )
-                .to_ty(Interner)
-            } else {
-                TyKind::Placeholder(universe).intern(Interner)
-            }
-        }
+    // This is the return type of the method, with RPITITs lowered as associated types. In other words, like in its
+    // signature.
+    let method_assocs_ret = db
+        .callable_item_signature(method_id.into())
+        .substitute(Interner, &method_generics.placeholder_subst(db))
+        .ret()
+        .clone();
+    let mut rpitit_to_infer_var_folder = RpititToInferVarFolder {
+        db,
+        table: &mut table,
+        trait_method_id: method_id,
+        trait_rpitit_to_infer_var: FxHashMap::default(),
+    };
+    let method_assocs_ret =
+        method_assocs_ret.fold_with(&mut rpitit_to_infer_var_folder, DebruijnIndex::INNERMOST);
+    let trait_rpitit_to_infer_var = rpitit_to_infer_var_folder.trait_rpitit_to_infer_var;
+    let method_assocs_ret = table.normalize_associated_types_in(method_assocs_ret);
 
-        fn fold_free_placeholder_const(
-            &mut self,
-            ty: Ty,
-            universe: PlaceholderIndex,
-            _outer_binder: DebruijnIndex,
-        ) -> Const {
-            let placeholder = from_placeholder_idx(self.db, universe);
-            if placeholder.parent == self.method {
-                BoundVar::new(
-                    DebruijnIndex::INNERMOST,
-                    placeholder.local_id.into_raw().into_u32() as usize
-                        + self.method_generics.len_lifetimes(),
-                )
-                .to_const(Interner, ty)
-            } else {
-                Const::new(Interner, ConstData { ty, value: ConstValue::Placeholder(universe) })
-            }
-        }
+    table.resolve_obligations_as_possible();
+    // Even if unification fails, we want to continue. We will fill the RPITITs with error types.
+    table.unify(&method_assocs_ret, &method_opaques_ret);
+    table.resolve_obligations_as_possible();
 
-        fn fold_free_placeholder_lifetime(
-            &mut self,
-            universe: PlaceholderIndex,
-            _outer_binder: DebruijnIndex,
-        ) -> Lifetime {
-            let placeholder = lt_from_placeholder_idx(self.db, universe);
-            if placeholder.parent == self.method {
-                BoundVar::new(
-                    DebruijnIndex::INNERMOST,
-                    placeholder.local_id.into_raw().into_u32() as usize,
-                )
-                .to_lifetime(Interner)
-            } else {
-                Lifetime::new(Interner, LifetimeData::Placeholder(universe))
-            }
-        }
-    }
+    ThinVec::from_iter(trait_rpitit_to_infer_var.into_iter().map(|(trait_assoc_id, infer_var)| {
+        let trait_assoc = trait_assoc_id.loc(db);
+        let rpitit = table.resolve_completely(infer_var);
+        let rpitit = rpitit.fold_with(
+            &mut PlaceholderToBoundVarFolder {
+                db,
+                method: method_id.into(),
+                method_generics: method_generics.self_params(),
+                parent: trait_assoc.trait_id.into(),
+                parent_generics: method_generics
+                    .parent_generics()
+                    .expect("method should be inside trait")
+                    .self_params(),
+            },
+            DebruijnIndex::INNERMOST,
+        );
+        let impl_rpitit = trait_assoc.bounds.as_ref().map(|_| rpitit);
+        (trait_assoc_id, impl_rpitit)
+    }))
 }
 
 fn check_method_generics_are_structurally_compatible(
@@ -333,3 +343,164 @@ fn check_method_generics_are_structurally_compatible(
 
     true
 }
+
+#[derive(chalk_derive::FallibleTypeFolder)]
+#[has_interner(Interner)]
+struct RpititToInferVarFolder<'a, 'b> {
+    db: &'a dyn HirDatabase,
+    table: &'a mut InferenceTable<'b>,
+    trait_rpitit_to_infer_var: FxHashMap<RpititTraitAssocTyId, Ty>,
+    trait_method_id: FunctionId,
+}
+impl TypeFolder<Interner> for RpititToInferVarFolder<'_, '_> {
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
+        self
+    }
+
+    fn interner(&self) -> Interner {
+        Interner
+    }
+
+    fn fold_ty(&mut self, ty: Ty, outer_binder: DebruijnIndex) -> Ty {
+        let result = match ty.kind(Interner) {
+            TyKind::Alias(AliasTy::Projection(ProjectionTy { associated_ty_id, substitution }))
+            | TyKind::AssociatedType(associated_ty_id, substitution) => {
+                if let AnyTraitAssocType::Rpitit(assoc_id) =
+                    from_assoc_type_id(self.db, *associated_ty_id)
+                {
+                    let assoc = assoc_id.loc(self.db);
+                    if assoc.synthesized_from_method == self.trait_method_id {
+                        if let Some(ty) = self.trait_rpitit_to_infer_var.get(&assoc_id) {
+                            return ty.clone();
+                        }
+
+                        // Replace with new infer var.
+                        // This needs to come before we fold the bounds, because they also contain this associated type.
+                        let var = self.table.new_type_var();
+                        self.trait_rpitit_to_infer_var.insert(assoc_id, var.clone());
+
+                        // Recurse into bounds, so that nested RPITITs will be handled correctly.
+                        for bound in assoc.bounds.clone().substitute(Interner, substitution) {
+                            let bound = inline_bound_to_generic_predicate(&bound, var.clone());
+                            // This is an unrelated binder, therefore `DebruijnIndex::INNERMOST`.
+                            let bound = bound.fold_with(self, DebruijnIndex::INNERMOST);
+                            let bound = self.table.normalize_associated_types_in(bound);
+                            self.table.register_obligation(Goal::new(
+                                Interner,
+                                GoalData::Quantified(
+                                    chalk_ir::QuantifierKind::ForAll,
+                                    bound.map(|bound| {
+                                        Goal::new(
+                                            Interner,
+                                            GoalData::DomainGoal(DomainGoal::Holds(bound)),
+                                        )
+                                    }),
+                                ),
+                            ));
+                        }
+
+                        return var;
+                    }
+                }
+                ty.clone()
+            }
+            _ => ty.clone(),
+        };
+        result.super_fold_with(self, outer_binder)
+    }
+}
+
+#[derive(chalk_derive::FallibleTypeFolder)]
+#[has_interner(Interner)]
+struct PlaceholderToBoundVarFolder<'a> {
+    db: &'a dyn HirDatabase,
+    method: GenericDefId,
+    method_generics: &'a GenericParams,
+    parent: GenericDefId,
+    parent_generics: &'a GenericParams,
+}
+impl TypeFolder<Interner> for PlaceholderToBoundVarFolder<'_> {
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<Interner> {
+        self
+    }
+
+    fn interner(&self) -> Interner {
+        Interner
+    }
+
+    fn fold_free_placeholder_ty(
+        &mut self,
+        universe: PlaceholderIndex,
+        _outer_binder: DebruijnIndex,
+    ) -> Ty {
+        let placeholder = from_placeholder_idx(self.db, universe);
+        if placeholder.parent == self.method {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize
+                    + self.method_generics.len_lifetimes(),
+            )
+            .to_ty(Interner)
+        } else if placeholder.parent == self.parent {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize
+                    + self.method_generics.len()
+                    + self.parent_generics.len_lifetimes(),
+            )
+            .to_ty(Interner)
+        } else {
+            TyKind::Placeholder(universe).intern(Interner)
+        }
+    }
+
+    fn fold_free_placeholder_const(
+        &mut self,
+        ty: Ty,
+        universe: PlaceholderIndex,
+        _outer_binder: DebruijnIndex,
+    ) -> Const {
+        let placeholder = from_placeholder_idx(self.db, universe);
+        if placeholder.parent == self.method {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize
+                    + self.method_generics.len_lifetimes(),
+            )
+            .to_const(Interner, ty)
+        } else if placeholder.parent == self.parent {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize
+                    + self.method_generics.len()
+                    + self.parent_generics.len_lifetimes(),
+            )
+            .to_const(Interner, ty)
+        } else {
+            Const::new(Interner, ConstData { ty, value: ConstValue::Placeholder(universe) })
+        }
+    }
+
+    fn fold_free_placeholder_lifetime(
+        &mut self,
+        universe: PlaceholderIndex,
+        _outer_binder: DebruijnIndex,
+    ) -> Lifetime {
+        let placeholder = lt_from_placeholder_idx(self.db, universe);
+        if placeholder.parent == self.method {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize,
+            )
+            .to_lifetime(Interner)
+        } else if placeholder.parent == self.parent {
+            BoundVar::new(
+                DebruijnIndex::INNERMOST,
+                placeholder.local_id.into_raw().into_u32() as usize + self.method_generics.len(),
+            )
+            .to_lifetime(Interner)
+        } else {
+            Lifetime::new(Interner, LifetimeData::Placeholder(universe))
+        }
+    }
+}

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

@@ -4937,13 +4937,15 @@ fn bar<'a, 'b, T, const N: usize, U, const M: usize, Ty: Trait<'a, T, N>>(v: &Ty
 }
     "#,
         // The `{unknown}` is not related to RPITIT, see https://github.com/rust-lang/rust-analyzer/issues/19392.
+        // The ordering (lifetimes before `Self`) is not representative of what happens;
+        // it's just that our display infra shows lifetimes first.
         expect![[r#"
             72..76 'self': &'? Self
             183..184 'v': &'? Ty
             191..227 '{     ...>(); }': ()
-            201..202 '_': (Trait::__foo_rpitit<'b, U, M, Ty, '?, {unknown}, _>,)
+            201..202 '_': (Trait::__foo_rpitit<'?, {unknown}, _, 'b, U, M, Ty>,)
             205..206 'v': &'? Ty
-            205..224 'v.foo:..., M>()': (Trait::__foo_rpitit<'b, U, M, Ty, '?, {unknown}, _>,)
+            205..224 'v.foo:..., M>()': (Trait::__foo_rpitit<'?, {unknown}, _, 'b, U, M, Ty>,)
         "#]],
     );
 }
@@ -5074,14 +5076,14 @@ impl<T> Trait for Foo<T> {
     "#,
         expect![[r#"
             type __foo_rpitit: T1;
-            type __foo_rpitit: T2<?1.2> + T2<i32> + ?Sized;
-            type __bar_rpitit: T2<bool> + T3<?1.0, ?1.0, 123> + Trait;
+            type __foo_rpitit: T2<?1.0> + T2<i32> + ?Sized;
+            type __bar_rpitit: T2<bool> + T3<?1.1, ?1.1, 123> + Trait;
             type __baz_rpitit: T1;
             type __baz_rpitit: T4<Assoc = impl T1>;
 
             type __foo_rpitit = impl T1;
             type __foo_rpitit = ?0.1;
-            type __bar_rpitit = impl T2<T>;
+            type __bar_rpitit = impl T2<?2.1>;
             type __baz_rpitit = ();
             type __baz_rpitit = impl T4<Assoc = ()>;
         "#]],
@@ -5109,3 +5111,48 @@ impl Trait for () {
         "#]],
     );
 }
+
+#[test]
+fn defaulted_method_with_rpitit() {
+    check_rpitit(
+        r#"
+//- minicore: sized
+//- /helpers.rs crate:helpers
+pub trait Bar<'a, B: ?Sized, C: ?Sized, D: ?Sized> {}
+
+//- /lib.rs crate:library deps:helpers
+use helpers::*;
+trait Trait<T> {
+    fn foo<'a, B>() -> impl Bar<'a, B, Self, T>;
+}
+struct Foo<T>(T);
+impl<T, U> Trait<(Foo<()>, U)> for Foo<T> {}
+    "#,
+        // The debruijn index in the value is 2, but should be 0 to refer to the associated
+        // type generics. It is 2 because opaques are wrapped in two binders, and so the 0
+        // is shifted in twice. Since users are not expected to see debruijn indices anyway,
+        // this does not matter.
+        expect![[r#"
+            type __foo_rpitit: Bar<?1.0, ?1.1, ?1.2, ?1.3>;
+
+            type __foo_rpitit = impl Bar<?2.0, ?2.1, Foo<?2.2>, (Foo<()>, ?2.3)>;
+        "#]],
+    );
+}
+
+#[test]
+fn check_foo() {
+    check_rpitit(
+        r#"
+//- minicore: future, send, sized
+use core::future::Future;
+
+trait DesugaredAsyncTrait {
+    fn foo(&self) -> impl Future<Output = usize> + Send;
+}
+
+impl DesugaredAsyncTrait for () {}
+    "#,
+        expect![[r#""#]],
+    );
+}

crates/hir-ty/src/tls.rs

@@ -97,10 +97,8 @@ impl DebugContext<'_> {
                 AnyTraitAssocType::Rpitit(assoc_type) => {
                     let assoc_type = assoc_type.loc(self.0);
                     let method_data = self.0.function_signature(assoc_type.synthesized_from_method);
-                    let placeholder_assoc_type_name = format!(
-                        "__{}_rpitit",
-                        method_data.name.display(self.0, Edition::LATEST).to_string()
-                    );
+                    let placeholder_assoc_type_name =
+                        format!("__{}_rpitit", method_data.name.display(self.0, Edition::LATEST));
                     (assoc_type.trait_id, placeholder_assoc_type_name)
                 }
             };