Fix built-in Fn impls when generics are involved

There were two problems:
 - the FnDef impl was using a wrong substitution for the FnDef (calling
   `builder.substitution_in_scope()`, which wasn't even necessarily the same
   number of parameters -- not sure what the intention was there)
 - when looking for `Normalize` clauses, the self type wasn't generalized (so
   bound variables were handled wrongly). (This lead to crashes when trying to
   integrate it in rust-analyzer: rust-lang/rust-analyzer#4982)

Author: flodiebold

chalk-solve/src/clauses/builtin_traits.rs

@@ -55,13 +55,19 @@ pub fn add_builtin_assoc_program_clauses<I: Interner>(
     well_known: WellKnownTrait,
     self_ty: Ty<I>,
 ) -> Result<(), Floundered> {
-    match well_known {
-        WellKnownTrait::FnOnce => {
-            fn_family::add_fn_trait_program_clauses(db, builder, well_known, self_ty)?;
+    // If `self_ty` contains bound vars, we want to universally quantify them.
+    // `Generalize` collects them for us.
+    let generalized = generalize::Generalize::apply(db.interner(), &self_ty);
+
+    builder.push_binders(&generalized, |builder, self_ty| {
+        match well_known {
+            WellKnownTrait::FnOnce => {
+                fn_family::add_fn_trait_program_clauses(db, builder, well_known, self_ty)?;
+            }
+            _ => {}
         }
-        _ => {}
-    }
-    Ok(())
+        Ok(())
+    })
 }
 
 /// Given a trait ref `T0: Trait` and a list of types `U0..Un`, pushes a clause of the form

chalk-solve/src/clauses/builtin_traits/fn_family.rs

@@ -61,6 +61,10 @@ fn push_clauses_for_apply<I: Interner>(
     self_ty: Ty<I>,
     inputs_and_output: &Binders<FnDefInputsAndOutputDatum<I>>,
 ) {
+    eprintln!(
+        "push_clauses_for_apply({:?}, {:?}, {:#?}, {:?})",
+        well_known, trait_id, self_ty, inputs_and_output
+    );
     let interner = db.interner();
     builder.push_binders(inputs_and_output, |builder, inputs_and_output| {
         let arg_sub = inputs_and_output
@@ -102,11 +106,6 @@ pub fn add_fn_trait_program_clauses<I: Interner>(
                 let bound = fn_def_datum
                     .binders
                     .substitute(builder.interner(), &apply.substitution);
-                let self_ty = ApplicationTy {
-                    name: apply.name,
-                    substitution: builder.substitution_in_scope(),
-                }
-                .intern(interner);
                 push_clauses_for_apply(
                     db,
                     builder,

tests/test/fn_def.rs

@@ -96,5 +96,73 @@ fn fn_def_implements_fn_traits() {
         } yields {
             "Unique"
         }
+
+        goal {
+            bar: Fn<(i32,)>
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            Normalize(<bar as FnOnce<(i32,)>>::Output -> ())
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            baz: Fn<(i32,)>
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            Normalize(<baz as FnOnce<(i32,)>>::Output -> u8)
+        } yields {
+            "Unique"
+        }
+    }
+}
+
+#[test]
+fn generic_fn_implements_fn_traits() {
+    test! {
+        program {
+            #[lang(fn_once)]
+            trait FnOnce<Args> {
+                type Output;
+            }
+
+            #[lang(fn_mut)]
+            trait FnMut<Args> where Self: FnOnce<Args> { }
+
+            #[lang(fn)]
+            trait Fn<Args> where Self: FnMut<Args> { }
+
+            fn foo<T>(t: T) -> T;
+        }
+
+        goal {
+            exists<T> { foo<T>: Fn<(T,)> }
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            forall<T> { foo<T>: Fn<(T,)> }
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            exists<T> { Normalize(<foo<T> as FnOnce<(T,)>>::Output -> T) }
+        } yields[SolverChoice::recursive()] {
+            "Unique"
+        }
+
+        goal {
+            forall<T> { Normalize(<foo<T> as FnOnce<(T,)>>::Output -> T) }
+        } yields {
+            "Unique"
+        }
     }
 }