Comply with Chalk expectations

Chalk apparently requires associated type values to contain both the impl and the associated ty binders, completely unlike the docs (which say they should only contain those of the associated type). So fix that.

Author: ChayimFriedman2

crates/hir-ty/src/chalk_db.rs

@@ -50,7 +50,7 @@ use crate::{
     to_assoc_type_id, to_chalk_trait_id,
     traits::ChalkContext,
     utils::ClosureSubst,
-    wrap_empty_binders,
+    variable_kinds_from_generics, wrap_empty_binders,
 };
 
 pub(crate) type AssociatedTyDatum = chalk_solve::rust_ir::AssociatedTyDatum<Interner>;
@@ -1059,9 +1059,14 @@ fn impl_method_rpitit_values(
                 DebruijnIndex::INNERMOST,
             );
             let trait_assoc = trait_assoc_id.loc(db);
+            // Completely unlike the docs, Chalk requires both the impl generics and the associated type
+            // generics in the binder.
             let impl_rpitit_binders = VariableKinds::from_iter(
                 Interner,
-                &trait_assoc.bounds.binders.as_slice(Interner)[..trait_method_generics.len()],
+                trait_assoc.bounds.binders.as_slice(Interner)[..trait_method_generics.len()]
+                    .iter()
+                    .cloned()
+                    .chain(variable_kinds_from_generics(db, impl_method_generics.iter_parent_id())),
             );
             let impl_rpitit = Binders::new(
                 impl_rpitit_binders,
@@ -1288,44 +1293,48 @@ pub(crate) fn associated_ty_value_query(
         AnyImplAssocType::Normal(type_alias) => {
             type_alias_associated_ty_value(db, krate, type_alias)
         }
-        AnyImplAssocType::Rpitit(assoc_type_id) => {
-            let assoc_type = assoc_type_id.loc(db);
-            let trait_assoc = assoc_type.trait_assoc.loc(db);
-            let all_method_assocs = impl_method_rpitit_values(
-                db,
-                assoc_type.impl_id,
-                trait_assoc.synthesized_from_method,
-            );
-            let trait_assoc_id = to_assoc_type_id_rpitit(assoc_type.trait_assoc);
-            all_method_assocs
-                .iter()
-                .find(|method_assoc| method_assoc.associated_ty_id == trait_assoc_id)
-                .cloned()
-                .unwrap_or_else(|| {
-                    let impl_id = hir_def::ImplId::to_chalk(assoc_type.impl_id, db);
-                    let trait_method_generics =
-                        generics(db, trait_assoc.synthesized_from_method.into());
-                    Arc::new(AssociatedTyValue {
-                        associated_ty_id: trait_assoc_id,
-                        impl_id,
-                        // In this situation, we don't know even that the trait and impl generics match, therefore
-                        // the only binders we can give to comply with the trait's binders are the trait's binders.
-                        // However, for impl associated types chalk wants only their own generics, excluding
-                        // those of the impl (unlike in traits), therefore we filter them here.
-                        value: Binders::new(
-                            VariableKinds::from_iter(
-                                Interner,
-                                &trait_assoc.bounds.binders.as_slice(Interner)
-                                    [..trait_method_generics.len_self()],
-                            ),
-                            rust_ir::AssociatedTyValueBound { ty: TyKind::Error.intern(Interner) },
-                        ),
-                    })
-                })
-        }
+        AnyImplAssocType::Rpitit(assoc_type_id) => rpitit_associated_ty_value(db, assoc_type_id),
     }
 }
 
+fn rpitit_associated_ty_value(
+    db: &dyn HirDatabase,
+    assoc_type_id: RpititImplAssocTyId,
+) -> Arc<AssociatedTyValue> {
+    let assoc_type = assoc_type_id.loc(db);
+    let trait_assoc = assoc_type.trait_assoc.loc(db);
+    let all_method_assocs =
+        impl_method_rpitit_values(db, assoc_type.impl_id, trait_assoc.synthesized_from_method);
+    let trait_assoc_id = to_assoc_type_id_rpitit(assoc_type.trait_assoc);
+    all_method_assocs
+        .iter()
+        .find(|method_assoc| method_assoc.associated_ty_id == trait_assoc_id)
+        .cloned()
+        .unwrap_or_else(|| {
+            let impl_id = hir_def::ImplId::to_chalk(assoc_type.impl_id, db);
+            let trait_method_generics = generics(db, trait_assoc.synthesized_from_method.into());
+            let impl_generics = generics(db, assoc_type.impl_id.into());
+            // In this situation, we don't know even that the trait and impl generics match, therefore
+            // the only binders we can give to comply with the trait's binders are the trait's binders.
+            // However, for impl associated types chalk wants only their own generics, excluding
+            // those of the impl (unlike in traits), therefore we filter them here.
+            // Completely unlike the docs, Chalk requires both the impl generics and the associated type
+            // generics in the binder.
+            let value = Binders::new(
+                VariableKinds::from_iter(
+                    Interner,
+                    trait_assoc.bounds.binders.as_slice(Interner)
+                        [..trait_method_generics.len_self()]
+                        .iter()
+                        .cloned()
+                        .chain(variable_kinds_from_generics(db, impl_generics.iter_id())),
+                ),
+                rust_ir::AssociatedTyValueBound { ty: TyKind::Error.intern(Interner) },
+            );
+            Arc::new(AssociatedTyValue { associated_ty_id: trait_assoc_id, impl_id, value })
+        })
+}
+
 fn type_alias_associated_ty_value(
     db: &dyn HirDatabase,
     _krate: Crate,

crates/hir-ty/src/lib.rs

@@ -62,7 +62,10 @@ use chalk_ir::{
     interner::HasInterner,
 };
 use either::Either;
-use hir_def::{CallableDefId, GeneralConstId, TypeOrConstParamId, hir::ExprId, type_ref::Rawness};
+use hir_def::{
+    CallableDefId, GeneralConstId, GenericParamId, TypeOrConstParamId, hir::ExprId,
+    type_ref::Rawness,
+};
 use hir_expand::name::Name;
 use indexmap::{IndexMap, map::Entry};
 use intern::{Symbol, sym};
@@ -343,29 +346,25 @@ pub(crate) fn make_single_type_binders<T: HasInterner<Interner = Interner>>(
     )
 }
 
+pub(crate) fn variable_kinds_from_generics(
+    db: &dyn HirDatabase,
+    generics: impl Iterator<Item = GenericParamId>,
+) -> impl Iterator<Item = VariableKind> {
+    generics.map(|x| match x {
+        GenericParamId::ConstParamId(id) => VariableKind::Const(db.const_param_ty(id)),
+        GenericParamId::TypeParamId(_) => VariableKind::Ty(chalk_ir::TyVariableKind::General),
+        GenericParamId::LifetimeParamId(_) => VariableKind::Lifetime,
+    })
+}
+
 pub(crate) fn make_binders<T: HasInterner<Interner = Interner>>(
     db: &dyn HirDatabase,
     generics: &Generics,
     value: T,
 ) -> Binders<T> {
-    Binders::new(variable_kinds_from_iter(db, generics.iter_id()), value)
-}
-
-pub(crate) fn variable_kinds_from_iter(
-    db: &dyn HirDatabase,
-    iter: impl Iterator<Item = hir_def::GenericParamId>,
-) -> VariableKinds {
-    VariableKinds::from_iter(
-        Interner,
-        iter.map(|x| match x {
-            hir_def::GenericParamId::ConstParamId(id) => {
-                chalk_ir::VariableKind::Const(db.const_param_ty(id))
-            }
-            hir_def::GenericParamId::TypeParamId(_) => {
-                chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)
-            }
-            hir_def::GenericParamId::LifetimeParamId(_) => chalk_ir::VariableKind::Lifetime,
-        }),
+    Binders::new(
+        VariableKinds::from_iter(Interner, variable_kinds_from_generics(db, generics.iter_id())),
+        value,
     )
 }
 

crates/hir-ty/src/lower.rs

@@ -66,7 +66,7 @@ use crate::{
     mapping::{ToChalk, from_chalk_trait_id, lt_to_placeholder_idx, to_assoc_type_id_rpitit},
     static_lifetime, to_chalk_trait_id, to_placeholder_idx,
     utils::all_super_trait_refs,
-    variable_kinds_from_iter,
+    variable_kinds_from_generics,
 };
 
 #[derive(Debug, Default)]
@@ -1448,7 +1448,10 @@ pub(crate) fn generic_defaults_with_diagnostics_query(
         p: GenericParamDataRef<'_>,
         generic_params: &Generics,
     ) -> (Binders<crate::GenericArg>, bool) {
-        let binders = variable_kinds_from_iter(ctx.db, generic_params.iter_id().take(idx));
+        let binders = VariableKinds::from_iter(
+            Interner,
+            variable_kinds_from_generics(ctx.db, generic_params.iter_id().take(idx)),
+        );
         match p {
             GenericParamDataRef::TypeParamData(p) => {
                 let ty = p.default.as_ref().map_or_else(