Fix a bug

The binders of the recovery value weren't correct.

Author: ChayimFriedman2

crates/hir-def/src/nameres/assoc.rs

@@ -112,6 +112,13 @@ impl ImplItems {
     pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
         self.macro_calls.iter().flat_map(|it| it.iter()).copied()
     }
+
+    pub fn method_by_name(&self, name: &Name) -> Option<FunctionId> {
+        self.items.iter().find_map(|(item_name, item)| match item {
+            AssocItemId::FunctionId(t) if item_name == name => Some(*t),
+            _ => None,
+        })
+    }
 }
 
 struct AssocItemCollector<'a> {

crates/hir-ty/src/chalk_db.rs

@@ -13,9 +13,7 @@ use chalk_ir::{
     cast::{Cast, Caster},
     fold::shift::Shift,
 };
-use chalk_solve::rust_ir::{
-    self, AssociatedTyDatumBound, AssociatedTyValueBound, OpaqueTyDatumBound, WellKnownTrait,
-};
+use chalk_solve::rust_ir::{self, AssociatedTyDatumBound, OpaqueTyDatumBound, WellKnownTrait};
 
 use base_db::Crate;
 use hir_def::{
@@ -33,15 +31,16 @@ use crate::{
     db::{HirDatabase, InternedCoroutine},
     from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id,
     generics::generics,
-    lower::LifetimeElisionKind,
-    lower::trait_fn_signature,
+    lower::{LifetimeElisionKind, trait_fn_signature},
     make_binders, make_single_type_binders,
     mapping::{
         AnyImplAssocType, AnyTraitAssocType, ToChalk, from_assoc_type_value_id, from_chalk,
         to_assoc_type_id_rpitit, to_assoc_type_value_id, to_assoc_type_value_id_rpitit,
     },
     method_resolution::{ALL_FLOAT_FPS, ALL_INT_FPS, TraitImpls, TyFingerprint},
-    rpitit::{RpititImplAssocTy, RpititImplAssocTyId, impl_method_rpitit_values},
+    rpitit::{
+        RpititImplAssocTy, RpititImplAssocTyId, impl_method_rpitit_values, recovery_rpitit_value,
+    },
     to_assoc_type_id, to_chalk_trait_id,
     traits::ChalkContext,
     utils::ClosureSubst,
@@ -1020,18 +1019,7 @@ pub(crate) fn associated_ty_value_cycle(
         AnyImplAssocType::Normal(type_alias) => {
             type_alias_associated_ty_value(db, krate, type_alias)
         }
-        AnyImplAssocType::Rpitit(assoc_type_id) => {
-            let assoc = assoc_type_id.loc(db);
-            let trait_assoc = assoc.trait_assoc.loc(db);
-            Arc::new(AssociatedTyValue {
-                associated_ty_id: to_assoc_type_id_rpitit(assoc.trait_assoc),
-                impl_id: assoc.impl_id.to_chalk(db),
-                value: trait_assoc
-                    .bounds
-                    .as_ref()
-                    .map(|_| AssociatedTyValueBound { ty: TyKind::Error.intern(Interner) }),
-            })
-        }
+        AnyImplAssocType::Rpitit(assoc_type_id) => recovery_rpitit_value(db, assoc_type_id),
     }
 }
 

crates/hir-ty/src/rpitit.rs

@@ -10,8 +10,7 @@ use chalk_ir::{
 };
 use chalk_solve::rust_ir::AssociatedTyValueBound;
 use hir_def::{
-    AssocItemId, ConstParamId, FunctionId, GenericDefId, GenericParamId, ImplId, ItemContainerId,
-    TraitId,
+    ConstParamId, FunctionId, GenericDefId, GenericParamId, ImplId, ItemContainerId, TraitId,
     hir::generics::{GenericParams, TypeOrConstParamData},
     resolver::HasResolver,
 };
@@ -78,16 +77,7 @@ pub(crate) fn impl_method_rpitit_values(
     let trait_method_generics = generics(db, trait_method_id.into());
     let trait_method = db.function_signature(trait_method_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),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    });
+    let impl_method = impl_items.method_by_name(&trait_method.name);
     let impl_method = match impl_method {
         Some(impl_method) => impl_method,
         None => {
@@ -244,7 +234,7 @@ fn defaulted_impl_method_rpitit_values(
         Interner,
         variable_kinds_from_generics(
             db,
-            trait_method_generics.iter_self_id().chain(impl_generics.iter_id()),
+            impl_generics.iter_id().chain(trait_method_generics.iter_self_id()),
         ),
     );
     defaulted_rpitit_values
@@ -640,3 +630,25 @@ pub(crate) fn add_method_body_rpitit_clauses(
         _ => {}
     }
 }
+
+pub(crate) fn recovery_rpitit_value(
+    db: &dyn HirDatabase,
+    impl_assoc: RpititImplAssocTyId,
+) -> Arc<AssociatedTyValue> {
+    let impl_assoc = impl_assoc.loc(db);
+    let trait_assoc = impl_assoc.trait_assoc.loc(db);
+    let impl_generics = generics(db, impl_assoc.impl_id.into());
+    let trait_method_generics = generics(db, trait_assoc.synthesized_from_method.into());
+    let binders = VariableKinds::from_iter(
+        Interner,
+        variable_kinds_from_generics(
+            db,
+            impl_generics.iter_id().chain(trait_method_generics.iter_self_id()),
+        ),
+    );
+    Arc::new(AssociatedTyValue {
+        associated_ty_id: to_assoc_type_id_rpitit(impl_assoc.trait_assoc),
+        impl_id: impl_assoc.impl_id.to_chalk(db),
+        value: Binders::new(binders, AssociatedTyValueBound { ty: TyKind::Error.intern(Interner) }),
+    })
+}

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

@@ -5190,3 +5190,43 @@ trait Trait {
         "#]],
     );
 }
+
+#[test]
+fn rpitit_cycle_with_impl_generics() {
+    check_infer(
+        r#"
+//- minicore: sized, iterator
+pub trait HasAttrs: Sized {
+    fn foo(self) -> impl Iterator<Item = ()> {
+        loop {}
+    }
+}
+enum Either<L, R> {
+    Left(L),
+    Right(R),
+}
+impl<L, R> HasAttrs for Either<L, R>
+where
+    L: HasAttrs,
+    R: HasAttrs,
+{
+}
+struct AnyHasAttrs;
+impl HasAttrs for AnyHasAttrs {}
+
+fn foo(v: AnyHasAttrs) {
+    v.foo();
+}
+    "#,
+        expect![[r#"
+            39..43 'self': Self
+            73..96 '{     ...     }': !
+            83..90 'loop {}': !
+            88..90 '{}': ()
+            290..291 'v': AnyHasAttrs
+            306..322 '{     ...o(); }': ()
+            312..313 'v': AnyHasAttrs
+            312..319 'v.foo()': {unknown}
+        "#]],
+    );
+}