Fix built-in Fn impls when generics are involved

chalk-solve/src/clauses/builtin_traits.rs

@@ -57,11 +57,17 @@ pub fn add_builtin_assoc_program_clauses<I: Interner>(
 ) -> 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| {
+                fn_family::add_fn_trait_program_clauses(db, builder, well_known, self_ty)?;
+                Ok(())
+            })
         }
-        _ => {}
+        _ => 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

@@ -102,11 +102,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 {
+            "Unique"
+        }
+
+        goal {
+            forall<T> { Normalize(<foo<T> as FnOnce<(T,)>>::Output -> T) }
+        } yields {
+            "Unique"
+        }
     }
 }