1 files changed, 202 insertions, 123 deletions

diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 75351c17d..9bf93981a 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -7,22 +7,19 @@ use chalk_ir::{
     cast::Cast, family::ChalkIr, Identifier, ImplId, Parameter, PlaceholderIndex, TypeId,
     TypeKindId, TypeName, UniverseIndex,
 };
-use chalk_rust_ir::{AssociatedTyDatum, ImplDatum, StructDatum, TraitDatum};
+use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
 
 use hir_expand::name;
 
 use ra_db::salsa::{InternId, InternKey};
 
-use super::{Canonical, ChalkContext, Impl, Obligation};
+use super::{AssocTyValue, Canonical, ChalkContext, Impl, Obligation};
 use crate::{
     db::HirDatabase,
     generics::{GenericDef, HasGenericParams},
     ty::display::HirDisplay,
-    ty::{
-        ApplicationTy, GenericPredicate, Namespace, ProjectionTy, Substs, TraitRef, Ty, TypeCtor,
-        TypeWalk,
-    },
-    AssocItem, Crate, HasBody, ImplBlock, Trait, TypeAlias,
+    ty::{ApplicationTy, GenericPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk},
+    Crate, HasBody, ImplBlock, Trait, TypeAlias,
 };
 
 /// This represents a trait whose name we could not resolve.
@@ -59,29 +56,36 @@ impl ToChalk for Ty {
                     }
                 };
                 let parameters = apply_ty.parameters.to_chalk(db);
-                chalk_ir::ApplicationTy { name, parameters }.cast()
+                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
             }
             Ty::Projection(proj_ty) => {
                 let associated_ty_id = proj_ty.associated_ty.to_chalk(db);
                 let parameters = proj_ty.parameters.to_chalk(db);
-                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast()
+                chalk_ir::ProjectionTy { associated_ty_id, parameters }.cast().intern()
             }
             Ty::Param { idx, .. } => {
                 PlaceholderIndex { ui: UniverseIndex::ROOT, idx: idx as usize }.to_ty::<ChalkIr>()
             }
-            Ty::Bound(idx) => chalk_ir::Ty::BoundVar(idx as usize),
+            Ty::Bound(idx) => chalk_ir::TyData::BoundVar(idx as usize).intern(),
             Ty::Infer(_infer_ty) => panic!("uncanonicalized infer ty"),
-            // FIXME use Chalk's Dyn/Opaque once the bugs with that are fixed
-            Ty::Unknown | Ty::Dyn(_) | Ty::Opaque(_) => {
+            Ty::Dyn(predicates) => {
+                let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
+                chalk_ir::TyData::Dyn(make_binders(where_clauses, 1)).intern()
+            }
+            Ty::Opaque(predicates) => {
+                let where_clauses = predicates.iter().cloned().map(|p| p.to_chalk(db)).collect();
+                chalk_ir::TyData::Opaque(make_binders(where_clauses, 1)).intern()
+            }
+            Ty::Unknown => {
                 let parameters = Vec::new();
                 let name = TypeName::Error;
-                chalk_ir::ApplicationTy { name, parameters }.cast()
+                chalk_ir::ApplicationTy { name, parameters }.cast().intern()
             }
         }
     }
     fn from_chalk(db: &impl HirDatabase, chalk: chalk_ir::Ty<ChalkIr>) -> Self {
-        match chalk {
-            chalk_ir::Ty::Apply(apply_ty) => {
+        match chalk.data().clone() {
+            chalk_ir::TyData::Apply(apply_ty) => {
                 // FIXME this is kind of hacky due to the fact that
                 // TypeName::Placeholder is a Ty::Param on our side
                 match apply_ty.name {
@@ -104,21 +108,21 @@ impl ToChalk for Ty {
                     }
                 }
             }
-            chalk_ir::Ty::Projection(proj) => {
+            chalk_ir::TyData::Projection(proj) => {
                 let associated_ty = from_chalk(db, proj.associated_ty_id);
                 let parameters = from_chalk(db, proj.parameters);
                 Ty::Projection(ProjectionTy { associated_ty, parameters })
             }
-            chalk_ir::Ty::ForAll(_) => unimplemented!(),
-            chalk_ir::Ty::BoundVar(idx) => Ty::Bound(idx as u32),
-            chalk_ir::Ty::InferenceVar(_iv) => Ty::Unknown,
-            chalk_ir::Ty::Dyn(where_clauses) => {
+            chalk_ir::TyData::ForAll(_) => unimplemented!(),
+            chalk_ir::TyData::BoundVar(idx) => Ty::Bound(idx as u32),
+            chalk_ir::TyData::InferenceVar(_iv) => Ty::Unknown,
+            chalk_ir::TyData::Dyn(where_clauses) => {
                 assert_eq!(where_clauses.binders.len(), 1);
                 let predicates =
                     where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
                 Ty::Dyn(predicates)
             }
-            chalk_ir::Ty::Opaque(where_clauses) => {
+            chalk_ir::TyData::Opaque(where_clauses) => {
                 assert_eq!(where_clauses.binders.len(), 1);
                 let predicates =
                     where_clauses.value.into_iter().map(|c| from_chalk(db, c)).collect();
@@ -191,11 +195,11 @@ impl ToChalk for Impl {
     type Chalk = chalk_ir::ImplId;
 
     fn to_chalk(self, db: &impl HirDatabase) -> chalk_ir::ImplId {
-        db.intern_impl(self).into()
+        db.intern_chalk_impl(self).into()
     }
 
     fn from_chalk(db: &impl HirDatabase, impl_id: chalk_ir::ImplId) -> Impl {
-        db.lookup_intern_impl(impl_id.into())
+        db.lookup_intern_chalk_impl(impl_id.into())
     }
 }
 
@@ -211,6 +215,21 @@ impl ToChalk for TypeAlias {
     }
 }
 
+impl ToChalk for AssocTyValue {
+    type Chalk = chalk_rust_ir::AssociatedTyValueId;
+
+    fn to_chalk(self, db: &impl HirDatabase) -> chalk_rust_ir::AssociatedTyValueId {
+        db.intern_assoc_ty_value(self).into()
+    }
+
+    fn from_chalk(
+        db: &impl HirDatabase,
+        assoc_ty_value_id: chalk_rust_ir::AssociatedTyValueId,
+    ) -> AssocTyValue {
+        db.lookup_intern_assoc_ty_value(assoc_ty_value_id.into())
+    }
+}
+
 impl ToChalk for GenericPredicate {
     type Chalk = chalk_ir::QuantifiedWhereClause<ChalkIr>;
 
@@ -399,20 +418,20 @@ fn convert_where_clauses(
     result
 }
 
-impl<'a, DB> chalk_solve::RustIrDatabase for ChalkContext<'a, DB>
+impl<'a, DB> chalk_solve::RustIrDatabase<ChalkIr> for ChalkContext<'a, DB>
 where
     DB: HirDatabase,
 {
-    fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum> {
+    fn associated_ty_data(&self, id: TypeId) -> Arc<AssociatedTyDatum<ChalkIr>> {
         self.db.associated_ty_data(id)
     }
-    fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum> {
+    fn trait_datum(&self, trait_id: chalk_ir::TraitId) -> Arc<TraitDatum<ChalkIr>> {
         self.db.trait_datum(self.krate, trait_id)
     }
-    fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum> {
+    fn struct_datum(&self, struct_id: chalk_ir::StructId) -> Arc<StructDatum<ChalkIr>> {
         self.db.struct_datum(self.krate, struct_id)
     }
-    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum> {
+    fn impl_datum(&self, impl_id: ImplId) -> Arc<ImplDatum<ChalkIr>> {
         self.db.impl_datum(self.krate, impl_id)
     }
     fn impls_for_trait(
@@ -462,13 +481,11 @@ where
     fn type_name(&self, _id: TypeKindId) -> Identifier {
         unimplemented!()
     }
-    fn split_projection<'p>(
+    fn associated_ty_value(
         &self,
-        projection: &'p chalk_ir::ProjectionTy<ChalkIr>,
-    ) -> (Arc<AssociatedTyDatum>, &'p [Parameter<ChalkIr>], &'p [Parameter<ChalkIr>]) {
-        debug!("split_projection {:?}", projection);
-        // we don't support GATs, so I think this should always be correct currently
-        (self.db.associated_ty_data(projection.associated_ty_id), &projection.parameters, &[])
+        id: chalk_rust_ir::AssociatedTyValueId,
+    ) -> Arc<AssociatedTyValue<ChalkIr>> {
+        self.db.associated_ty_value(self.krate, id)
     }
     fn custom_clauses(&self) -> Vec<chalk_ir::ProgramClause<ChalkIr>> {
         vec![]
@@ -485,7 +502,7 @@ where
 pub(crate) fn associated_ty_data_query(
     db: &impl HirDatabase,
     id: TypeId,
-) -> Arc<AssociatedTyDatum> {
+) -> Arc<AssociatedTyDatum<ChalkIr>> {
     debug!("associated_ty_data {:?}", id);
     let type_alias: TypeAlias = from_chalk(db, id);
     let trait_ = match type_alias.container(db) {
@@ -493,19 +510,16 @@ pub(crate) fn associated_ty_data_query(
         _ => panic!("associated type not in trait"),
     };
     let generic_params = type_alias.generic_params(db);
-    let parameter_kinds = generic_params
-        .params_including_parent()
-        .into_iter()
-        .map(|p| chalk_ir::ParameterKind::Ty(lalrpop_intern::intern(&p.name.to_string())))
-        .collect();
+    let bound_data = chalk_rust_ir::AssociatedTyDatumBound {
+        // FIXME add bounds and where clauses
+        bounds: vec![],
+        where_clauses: vec![],
+    };
     let datum = AssociatedTyDatum {
         trait_id: trait_.to_chalk(db),
         id,
         name: lalrpop_intern::intern(&type_alias.name(db).to_string()),
-        parameter_kinds,
-        // FIXME add bounds and where clauses
-        bounds: vec![],
-        where_clauses: vec![],
+        binders: make_binders(bound_data, generic_params.count_params_including_parent()),
     };
     Arc::new(datum)
 }
@@ -514,17 +528,10 @@ pub(crate) fn trait_datum_query(
     db: &impl HirDatabase,
     krate: Crate,
     trait_id: chalk_ir::TraitId,
-) -> Arc<TraitDatum> {
+) -> Arc<TraitDatum<ChalkIr>> {
     debug!("trait_datum {:?}", trait_id);
     if trait_id == UNKNOWN_TRAIT {
-        let trait_datum_bound = chalk_rust_ir::TraitDatumBound {
-            trait_ref: chalk_ir::TraitRef {
-                trait_id: UNKNOWN_TRAIT,
-                parameters: vec![chalk_ir::Ty::BoundVar(0).cast()],
-            },
-            associated_ty_ids: Vec::new(),
-            where_clauses: Vec::new(),
-        };
+        let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses: Vec::new() };
 
         let flags = chalk_rust_ir::TraitFlags {
             auto: false,
@@ -532,18 +539,24 @@ pub(crate) fn trait_datum_query(
             upstream: true,
             fundamental: false,
             non_enumerable: true,
+            coinductive: false,
         };
-        return Arc::new(TraitDatum { binders: make_binders(trait_datum_bound, 1), flags });
+        return Arc::new(TraitDatum {
+            id: trait_id,
+            binders: make_binders(trait_datum_bound, 1),
+            flags,
+            associated_ty_ids: vec![],
+        });
     }
     let trait_: Trait = from_chalk(db, trait_id);
     debug!("trait {:?} = {:?}", trait_id, trait_.name(db));
     let generic_params = trait_.generic_params(db);
     let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = trait_.trait_ref(db).subst(&bound_vars).to_chalk(db);
     let flags = chalk_rust_ir::TraitFlags {
         auto: trait_.is_auto(db),
         upstream: trait_.module(db).krate() != krate,
         non_enumerable: true,
+        coinductive: false, // only relevant for Chalk testing
         // FIXME set these flags correctly
         marker: false,
         fundamental: false,
@@ -558,10 +571,13 @@ pub(crate) fn trait_datum_query(
         })
         .map(|type_alias| type_alias.to_chalk(db))
         .collect();
-    let trait_datum_bound =
-        chalk_rust_ir::TraitDatumBound { trait_ref, where_clauses, associated_ty_ids };
-    let trait_datum =
-        TraitDatum { binders: make_binders(trait_datum_bound, bound_vars.len()), flags };
+    let trait_datum_bound = chalk_rust_ir::TraitDatumBound { where_clauses };
+    let trait_datum = TraitDatum {
+        id: trait_id,
+        binders: make_binders(trait_datum_bound, bound_vars.len()),
+        flags,
+        associated_ty_ids,
+    };
     Arc::new(trait_datum)
 }
 
@@ -569,7 +585,7 @@ pub(crate) fn struct_datum_query(
     db: &impl HirDatabase,
     krate: Crate,
     struct_id: chalk_ir::StructId,
-) -> Arc<StructDatum> {
+) -> Arc<StructDatum<ChalkIr>> {
     debug!("struct_datum {:?}", struct_id);
     let type_ctor: TypeCtor = from_chalk(db, struct_id);
     debug!("struct {:?} = {:?}", struct_id, type_ctor);
@@ -588,17 +604,12 @@ pub(crate) fn struct_datum_query(
         // FIXME set fundamental flag correctly
         fundamental: false,
     };
-    let self_ty = chalk_ir::ApplicationTy {
-        name: TypeName::TypeKindId(type_ctor.to_chalk(db).into()),
-        parameters: (0..num_params).map(|i| chalk_ir::Ty::BoundVar(i).cast()).collect(),
-    };
     let struct_datum_bound = chalk_rust_ir::StructDatumBound {
-        self_ty,
         fields: Vec::new(), // FIXME add fields (only relevant for auto traits)
         where_clauses,
-        flags,
     };
-    let struct_datum = StructDatum { binders: make_binders(struct_datum_bound, num_params) };
+    let struct_datum =
+        StructDatum { id: struct_id, binders: make_binders(struct_datum_bound, num_params), flags };
     Arc::new(struct_datum)
 }
 
@@ -606,16 +617,15 @@ pub(crate) fn impl_datum_query(
     db: &impl HirDatabase,
     krate: Crate,
     impl_id: ImplId,
-) -> Arc<ImplDatum> {
+) -> Arc<ImplDatum<ChalkIr>> {
     let _p = ra_prof::profile("impl_datum");
     debug!("impl_datum {:?}", impl_id);
     let impl_: Impl = from_chalk(db, impl_id);
     match impl_ {
         Impl::ImplBlock(impl_block) => impl_block_datum(db, krate, impl_id, impl_block),
-        Impl::ClosureFnTraitImpl(data) => {
-            closure_fn_trait_impl_datum(db, krate, impl_id, data).unwrap_or_else(invalid_impl_datum)
-        }
+        Impl::ClosureFnTraitImpl(data) => closure_fn_trait_impl_datum(db, krate, data),
     }
+    .unwrap_or_else(invalid_impl_datum)
 }
 
 fn impl_block_datum(
@@ -623,14 +633,12 @@ fn impl_block_datum(
     krate: Crate,
     impl_id: ImplId,
     impl_block: ImplBlock,
-) -> Arc<ImplDatum> {
+) -> Option<Arc<ImplDatum<ChalkIr>>> {
     let generic_params = impl_block.generic_params(db);
     let bound_vars = Substs::bound_vars(&generic_params);
-    let trait_ref = impl_block
-        .target_trait_ref(db)
-        .expect("FIXME handle unresolved impl block trait ref")
-        .subst(&bound_vars);
-    let impl_type = if impl_block.module().krate() == krate {
+    let trait_ref = impl_block.target_trait_ref(db)?.subst(&bound_vars);
+    let trait_ = trait_ref.trait_;
+    let impl_type = if impl_block.krate(db) == krate {
         chalk_rust_ir::ImplType::Local
     } else {
         chalk_rust_ir::ImplType::External
@@ -644,28 +652,7 @@ fn impl_block_datum(
         trait_ref.display(db),
         where_clauses
     );
-    let trait_ = trait_ref.trait_;
     let trait_ref = trait_ref.to_chalk(db);
-    let associated_ty_values = impl_block
-        .items(db)
-        .into_iter()
-        .filter_map(|item| match item {
-            AssocItem::TypeAlias(t) => Some(t),
-            _ => None,
-        })
-        .filter_map(|t| {
-            let assoc_ty = trait_.associated_type_by_name(db, &t.name(db))?;
-            let ty = db.type_for_def(t.into(), Namespace::Types).subst(&bound_vars);
-            Some(chalk_rust_ir::AssociatedTyValue {
-                impl_id,
-                associated_ty_id: assoc_ty.to_chalk(db),
-                value: chalk_ir::Binders {
-                    value: chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) },
-                    binders: vec![], // we don't support GATs yet
-                },
-            })
-        })
-        .collect();
 
     let polarity = if negative {
         chalk_rust_ir::Polarity::Negative
@@ -673,31 +660,41 @@ fn impl_block_datum(
         chalk_rust_ir::Polarity::Positive
     };
 
-    let impl_datum_bound =
-        chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses, associated_ty_values };
+    let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses };
+    let associated_ty_value_ids = impl_block
+        .items(db)
+        .into_iter()
+        .filter_map(|item| match item {
+            crate::AssocItem::TypeAlias(type_alias) => Some(type_alias),
+            _ => None,
+        })
+        .filter(|type_alias| {
+            // don't include associated types that don't exist in the trait
+            trait_.associated_type_by_name(db, &type_alias.name(db)).is_some()
+        })
+        .map(|type_alias| AssocTyValue::TypeAlias(type_alias).to_chalk(db))
+        .collect();
     debug!("impl_datum: {:?}", impl_datum_bound);
     let impl_datum = ImplDatum {
         binders: make_binders(impl_datum_bound, bound_vars.len()),
         impl_type,
         polarity,
+        associated_ty_value_ids,
     };
-    Arc::new(impl_datum)
+    Some(Arc::new(impl_datum))
 }
 
-fn invalid_impl_datum() -> Arc<ImplDatum> {
+fn invalid_impl_datum() -> Arc<ImplDatum<ChalkIr>> {
     let trait_ref = chalk_ir::TraitRef {
         trait_id: UNKNOWN_TRAIT,
-        parameters: vec![chalk_ir::Ty::BoundVar(0).cast()],
-    };
-    let impl_datum_bound = chalk_rust_ir::ImplDatumBound {
-        trait_ref,
-        where_clauses: Vec::new(),
-        associated_ty_values: Vec::new(),
+        parameters: vec![chalk_ir::TyData::BoundVar(0).cast().intern().cast()],
     };
+    let impl_datum_bound = chalk_rust_ir::ImplDatumBound { trait_ref, where_clauses: Vec::new() };
     let impl_datum = ImplDatum {
         binders: make_binders(impl_datum_bound, 1),
         impl_type: chalk_rust_ir::ImplType::External,
         polarity: chalk_rust_ir::Polarity::Positive,
+        associated_ty_value_ids: Vec::new(),
     };
     Arc::new(impl_datum)
 }
@@ -705,15 +702,19 @@ fn invalid_impl_datum() -> Arc<ImplDatum> {
 fn closure_fn_trait_impl_datum(
     db: &impl HirDatabase,
     krate: Crate,
-    impl_id: ImplId,
     data: super::ClosureFnTraitImplData,
-) -> Option<Arc<ImplDatum>> {
+) -> Option<Arc<ImplDatum<ChalkIr>>> {
     // for some closure |X, Y| -> Z:
     // impl<T, U, V> Fn<(T, U)> for closure<fn(T, U) -> V> { Output = V }
 
-    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
     let trait_ = get_fn_trait(db, krate, data.fn_trait)?; // get corresponding fn trait
 
+    // validate FnOnce trait, since we need it in the assoc ty value definition
+    // and don't want to return a valid value only to find out later that FnOnce
+    // is broken
+    let fn_once_trait = get_fn_trait(db, krate, super::FnTrait::FnOnce)?;
+    fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
+
     let num_args: u16 = match &data.def.body(db)[data.expr] {
         crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
         _ => {
@@ -726,7 +727,6 @@ fn closure_fn_trait_impl_datum(
         TypeCtor::Tuple { cardinality: num_args },
         Substs::builder(num_args as usize).fill_with_bound_vars(0).build(),
     );
-    let output_ty = Ty::Bound(num_args.into());
     let sig_ty = Ty::apply(
         TypeCtor::FnPtr { num_args },
         Substs::builder(num_args as usize + 1).fill_with_bound_vars(0).build(),
@@ -739,32 +739,99 @@ fn closure_fn_trait_impl_datum(
         substs: Substs::build_for_def(db, trait_).push(self_ty).push(arg_ty).build(),
     };
 
-    let output_ty_id = fn_once_trait.associated_type_by_name(db, &name::OUTPUT_TYPE)?;
-
-    let output_ty_value = chalk_rust_ir::AssociatedTyValue {
-        associated_ty_id: output_ty_id.to_chalk(db),
-        impl_id,
-        value: make_binders(
-            chalk_rust_ir::AssociatedTyValueBound { ty: output_ty.to_chalk(db) },
-            0,
-        ),
-    };
+    let output_ty_id = AssocTyValue::ClosureFnTraitImplOutput(data.clone()).to_chalk(db);
 
     let impl_type = chalk_rust_ir::ImplType::External;
 
     let impl_datum_bound = chalk_rust_ir::ImplDatumBound {
         trait_ref: trait_ref.to_chalk(db),
         where_clauses: Vec::new(),
-        associated_ty_values: vec![output_ty_value],
     };
     let impl_datum = ImplDatum {
         binders: make_binders(impl_datum_bound, num_args as usize + 1),
         impl_type,
         polarity: chalk_rust_ir::Polarity::Positive,
+        associated_ty_value_ids: vec![output_ty_id],
     };
     Some(Arc::new(impl_datum))
 }
 
+pub(crate) fn associated_ty_value_query(
+    db: &impl HirDatabase,
+    krate: Crate,
+    id: chalk_rust_ir::AssociatedTyValueId,
+) -> Arc<chalk_rust_ir::AssociatedTyValue<ChalkIr>> {
+    let data: AssocTyValue = from_chalk(db, id);
+    match data {
+        AssocTyValue::TypeAlias(type_alias) => {
+            type_alias_associated_ty_value(db, krate, type_alias)
+        }
+        AssocTyValue::ClosureFnTraitImplOutput(data) => {
+            closure_fn_trait_output_assoc_ty_value(db, krate, data)
+        }
+    }
+}
+
+fn type_alias_associated_ty_value(
+    db: &impl HirDatabase,
+    _krate: Crate,
+    type_alias: TypeAlias,
+) -> Arc<AssociatedTyValue<ChalkIr>> {
+    let impl_block = type_alias.impl_block(db).expect("assoc ty value should be in impl");
+    let impl_id = Impl::ImplBlock(impl_block).to_chalk(db);
+    let trait_ = impl_block
+        .target_trait_ref(db)
+        .expect("assoc ty value should not exist") // we don't return any assoc ty values if the impl'd trait can't be resolved
+        .trait_;
+    let assoc_ty = trait_
+        .associated_type_by_name(db, &type_alias.name(db))
+        .expect("assoc ty value should not exist"); // validated when building the impl data as well
+    let generic_params = impl_block.generic_params(db);
+    let bound_vars = Substs::bound_vars(&generic_params);
+    let ty = db.type_for_def(type_alias.into(), crate::ty::Namespace::Types).subst(&bound_vars);
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: ty.to_chalk(db) };
+    let value = chalk_rust_ir::AssociatedTyValue {
+        impl_id,
+        associated_ty_id: assoc_ty.to_chalk(db),
+        value: make_binders(value_bound, bound_vars.len()),
+    };
+    Arc::new(value)
+}
+
+fn closure_fn_trait_output_assoc_ty_value(
+    db: &impl HirDatabase,
+    krate: Crate,
+    data: super::ClosureFnTraitImplData,
+) -> Arc<AssociatedTyValue<ChalkIr>> {
+    let impl_id = Impl::ClosureFnTraitImpl(data.clone()).to_chalk(db);
+
+    let num_args: u16 = match &data.def.body(db)[data.expr] {
+        crate::expr::Expr::Lambda { args, .. } => args.len() as u16,
+        _ => {
+            log::warn!("closure for closure type {:?} not found", data);
+            0
+        }
+    };
+
+    let output_ty = Ty::Bound(num_args.into());
+
+    let fn_once_trait =
+        get_fn_trait(db, krate, super::FnTrait::FnOnce).expect("assoc ty value should not exist");
+
+    let output_ty_id = fn_once_trait
+        .associated_type_by_name(db, &name::OUTPUT_TYPE)
+        .expect("assoc ty value should not exist");
+
+    let value_bound = chalk_rust_ir::AssociatedTyValueBound { ty: output_ty.to_chalk(db) };
+
+    let value = chalk_rust_ir::AssociatedTyValue {
+        associated_ty_id: output_ty_id.to_chalk(db),
+        impl_id,
+        value: make_binders(value_bound, num_args as usize + 1),
+    };
+    Arc::new(value)
+}
+
 fn get_fn_trait(db: &impl HirDatabase, krate: Crate, fn_trait: super::FnTrait) -> Option<Trait> {
     let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
     match target {
@@ -803,3 +870,15 @@ impl From<crate::ids::GlobalImplId> for chalk_ir::ImplId {
         chalk_ir::ImplId(id_to_chalk(impl_id))
     }
 }
+
+impl From<chalk_rust_ir::AssociatedTyValueId> for crate::ids::AssocTyValueId {
+    fn from(id: chalk_rust_ir::AssociatedTyValueId) -> Self {
+        id_from_chalk(id.0)
+    }
+}
+
+impl From<crate::ids::AssocTyValueId> for chalk_rust_ir::AssociatedTyValueId {
+    fn from(assoc_ty_value_id: crate::ids::AssocTyValueId) -> Self {
+        chalk_rust_ir::AssociatedTyValueId(id_to_chalk(assoc_ty_value_id))
+    }
+}