Some cleanup

Author: Aaron1011

chalk-solve/src/clauses/builtin_traits.rs

@@ -1,10 +1,10 @@
 use super::{builder::ClauseBuilder, generalize};
 use crate::{Interner, RustIrDatabase, TraitRef, WellKnownTrait};
-use chalk_ir::{ProjectionTy, Substitution, Ty};
+use chalk_ir::{ProjectionTy, Substitution, Ty, AliasTy};
 
 mod clone;
 mod copy;
-mod fn_;
+mod fn_family;
 mod sized;
 
 /// For well known traits we have special hard-coded impls, either as an
@@ -34,7 +34,7 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Copy => copy::add_copy_program_clauses(db, builder, &trait_ref, ty),
             WellKnownTrait::Clone => clone::add_clone_program_clauses(db, builder, &trait_ref, ty),
             WellKnownTrait::FnOnce | WellKnownTrait::FnMut | WellKnownTrait::Fn => {
-                fn_::add_fn_trait_program_clauses(db, builder, trait_ref.trait_id, ty, false)
+                fn_family::add_fn_trait_program_clauses(db, builder, trait_ref.trait_id, ty)
             }
             // Drop impls are provided explicitly
             WellKnownTrait::Drop => (),
@@ -53,13 +53,9 @@ pub fn add_builtin_assoc_program_clauses<I: Interner>(
     match well_known {
         WellKnownTrait::FnOnce => {
             let interner = db.interner();
-            let self_ty = proj
-                .substitution
-                .at(interner, 0)
-                .assert_ty_ref(interner)
-                .data(interner);
+            let self_ty = AliasTy::Projection(proj.clone()).self_type_parameter(interner);
             let trait_id = db.well_known_trait_id(well_known).unwrap();
-            fn_::add_fn_trait_program_clauses(db, builder, trait_id, self_ty, true);
+            fn_family::add_fn_trait_program_clauses(db, builder, trait_id, self_ty.data(interner));
         }
         _ => {}
     }

chalk-solve/src/clauses/builtin_traits/fn_.rs renamed to chalk-solve/src/clauses/builtin_traits/fn_family.rs

@@ -18,7 +18,6 @@ pub fn add_fn_trait_program_clauses<I: Interner>(
     builder: &mut ClauseBuilder<'_, I>,
     trait_id: TraitId<I>,
     ty: &TyData<I>,
-    assoc_output: bool,
 ) {
     match ty {
         TyData::Function(fn_val) => {
@@ -59,7 +58,9 @@ pub fn add_fn_trait_program_clauses<I: Interner>(
             // (e.g. `for<'a> fn(&'a u8): FnOnce<(&'b u8)>`)
             let bound_ref = Binders::new(VariableKinds::from(interner, binders), new_trait_ref);
             builder.push_binders(&bound_ref, |this, inner_trait| {
-                if assoc_output {
+                this.push_fact(inner_trait.clone());
+
+                if let Some(WellKnownTrait::FnOnce) = db.trait_datum(trait_id).well_known {
                     //The `Output` type is defined on the `FnOnce`
                     let fn_once = db.trait_datum(trait_id);
                     assert_eq!(fn_once.well_known, Some(WellKnownTrait::FnOnce));
@@ -83,10 +84,8 @@ pub fn add_fn_trait_program_clauses<I: Interner>(
                     };
 
                     this.push_clause(normalize, std::iter::once(inner_trait));
-                } else {
-                    this.push_fact(inner_trait);
                 }
-            })
+            });
         }
         _ => {}
     }