Handle tuples for builtin Copy and Clone traits

Author: marmeladema

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

@@ -1,6 +1,32 @@
+use crate::clauses::builtin_traits::needs_impl_for_tys;
 use crate::clauses::ClauseBuilder;
 use crate::{Interner, RustIrDatabase, TraitRef};
-use chalk_ir::TyData;
+use chalk_ir::{ApplicationTy, Substitution, TyData, TypeName};
+
+fn push_tuple_copy_conditions<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    trait_ref: &TraitRef<I>,
+    arity: usize,
+    substitution: &Substitution<I>,
+) {
+    // Empty tuples are always Copy
+    if arity == 0 {
+        builder.push_fact(trait_ref.clone());
+        return;
+    }
+
+    let interner = db.interner();
+
+    needs_impl_for_tys(
+        db,
+        builder,
+        trait_ref,
+        substitution
+            .iter(interner)
+            .map(|param| param.ty(interner).unwrap().clone()),
+    );
+}
 
 pub fn add_copy_program_clauses<I: Interner>(
     db: &dyn RustIrDatabase<I>,
@@ -11,6 +37,12 @@ pub fn add_copy_program_clauses<I: Interner>(
     let _interner = db.interner();
 
     match ty {
+        TyData::Apply(ApplicationTy { name, substitution }) => match name {
+            TypeName::Tuple(arity) => {
+                push_tuple_copy_conditions(db, builder, trait_ref, *arity, substitution)
+            }
+            _ => return,
+        },
         TyData::Function(_) => builder.push_fact(trait_ref.clone()),
         // TODO(areredify)
         // when #368 lands, extend this to handle everything accordingly

tests/test/tuples.rs

@@ -84,3 +84,53 @@ fn tuples_are_sized() {
         }
     }
 }
+
+#[test]
+fn tuples_are_copy() {
+    test! {
+        program {
+            #[lang(copy)]
+            trait Copy { }
+
+            trait Foo {}
+
+            impl Copy for u8 {}
+        }
+
+        goal {
+            (dyn Foo,): Copy
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            (u8, dyn Foo): Copy
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            (dyn Foo, u8): Copy
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            (): Copy
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+
+        goal {
+            (u8,): Copy
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+
+        goal {
+            (u8, u8): Copy
+        } yields {
+            "Unique; substitution [], lifetime constraints []"
+        }
+    }
+}