Force builtin traits to be non-enumerable

There's no way to enumerate all types these can apply to. Flounder if we
have to prove that one of these traits applies to an inference variable.

Author: matthewjasper

chalk-solve/src/clauses/builtin_traits.rs

@@ -28,6 +28,10 @@ pub fn add_builtin_program_clauses<I: Interner>(
         let ty = self_ty.kind(db.interner()).clone();
 
         match well_known {
+            // There are no builtin impls provided for the following traits:
+            WellKnownTrait::Unpin | WellKnownTrait::Drop | WellKnownTrait::CoerceUnsized => (),
+            // Built-in traits are non-enumerable.
+            _ if self_ty.is_general_var(db.interner(), binders) => return Err(Floundered),
             WellKnownTrait::Sized => {
                 sized::add_sized_program_clauses(db, builder, trait_ref, ty, binders)?;
             }
@@ -48,8 +52,6 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Generator => {
                 generator::add_generator_program_clauses(db, builder, self_ty)?;
             }
-            // There are no builtin impls provided for the following traits:
-            WellKnownTrait::Unpin | WellKnownTrait::Drop | WellKnownTrait::CoerceUnsized => (),
         }
         Ok(())
     })

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

@@ -156,8 +156,6 @@ pub fn add_fn_trait_program_clauses<I: Interner>(
             });
             Ok(())
         }
-        // Function traits are non-enumerable
-        TyKind::InferenceVar(..) | TyKind::BoundVar(_) | TyKind::Alias(..) => Err(Floundered),
         _ => Ok(()),
     }
 }

tests/test/cycle.rs

@@ -226,7 +226,6 @@ fn infinite_recursion() {
 fn cycle_with_ambiguity() {
     test! {
         program {
-            #[non_enumerable]
             #[lang(sized)]
             trait Sized { }
             trait From<T> {}

tests/test/tuples.rs

@@ -39,10 +39,6 @@ fn tuple_trait_impl() {
 fn tuples_are_copy() {
     test! {
         program {
-            // FIXME: If we don't declare Copy non-enumerable, `exists<T> { T:
-            // Copy }` gives wrong results, because it doesn't consider the
-            // built-in impls.
-            #[non_enumerable]
             #[lang(copy)]
             trait Copy { }
 
@@ -107,8 +103,6 @@ fn tuples_are_sized() {
         program {
             #[lang(sized)]
             trait Sized { }
-
-            trait Foo {}
         }
 
         goal {
@@ -179,7 +173,6 @@ fn tuples_are_sized() {
 fn tuples_are_clone() {
     test! {
         program {
-            #[non_enumerable] // see above
             #[lang(clone)]
             trait Clone { }