Implement support for Tuple trait

chalk-integration/src/lowering.rs

@@ -1143,6 +1143,7 @@ impl Lower for WellKnownTrait {
             WellKnownTrait::DiscriminantKind => rust_ir::WellKnownTrait::DiscriminantKind,
             WellKnownTrait::Generator => rust_ir::WellKnownTrait::Generator,
             WellKnownTrait::DispatchFromDyn => rust_ir::WellKnownTrait::DispatchFromDyn,
+            WellKnownTrait::Tuple => rust_ir::WellKnownTrait::Tuple,
         }
     }
 }

chalk-parse/src/ast.rs

@@ -161,6 +161,7 @@ pub enum WellKnownTrait {
     DiscriminantKind,
     Generator,
     DispatchFromDyn,
+    Tuple,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -69,6 +69,7 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "discriminant_kind" ")" "]" => WellKnownTrait::DiscriminantKind,
      "#" "[" "lang" "(" "generator" ")" "]" => WellKnownTrait::Generator,
      "#" "[" "lang" "(" "dispatch_from_dyn" ")" "]" => WellKnownTrait::DispatchFromDyn,
+     "#" "[" "lang" "(" "tuple_trait" ")" "]" => WellKnownTrait::Tuple,
 };
 
 AdtReprAttr: AdtReprAttr = {

chalk-solve/src/clauses/builtin_traits.rs

@@ -8,6 +8,7 @@ mod discriminant_kind;
 mod fn_family;
 mod generator;
 mod sized;
+mod tuple;
 mod unsize;
 
 /// For well known traits we have special hard-coded impls, either as an
@@ -50,6 +51,9 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Generator => {
                 generator::add_generator_program_clauses(db, builder, self_ty)?;
             }
+            WellKnownTrait::Tuple => {
+                tuple::add_tuple_program_clauses(db, builder, self_ty)?;
+            }
             // There are no builtin impls provided for the following traits:
             WellKnownTrait::Unpin
             | WellKnownTrait::Drop

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

@@ -0,0 +1,31 @@
+use crate::clauses::ClauseBuilder;
+use crate::rust_ir::WellKnownTrait;
+use crate::{Interner, RustIrDatabase, TraitRef};
+use chalk_ir::{Floundered, Substitution, Ty, TyKind};
+
+/// Add implicit impls of the generator trait, i.e., add a clause that all generators implement
+/// `Generator` and clauses for `Generator`'s associated types.
+pub fn add_tuple_program_clauses<I: Interner>(
+    db: &dyn RustIrDatabase<I>,
+    builder: &mut ClauseBuilder<'_, I>,
+    self_ty: Ty<I>,
+) -> Result<(), Floundered> {
+    let interner = db.interner();
+
+    match self_ty.kind(interner) {
+        TyKind::Tuple(..) => {
+            let trait_id = db.well_known_trait_id(WellKnownTrait::Tuple).unwrap();
+
+            builder.push_fact(TraitRef {
+                trait_id,
+                substitution: Substitution::from1(interner, self_ty),
+            });
+
+            Ok(())
+        }
+
+        // Generator trait is non-enumerable
+        TyKind::InferenceVar(..) | TyKind::BoundVar(_) | TyKind::Alias(..) => Err(Floundered),
+        _ => Ok(()),
+    }
+}

chalk-solve/src/display/items.rs

@@ -205,6 +205,7 @@ impl<I: Interner> RenderAsRust<I> for TraitDatum<I> {
                 WellKnownTrait::DiscriminantKind => "discriminant_kind",
                 WellKnownTrait::Generator => "generator",
                 WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
+                WellKnownTrait::Tuple => "tuple_trait",
             };
             writeln!(f, "#[lang({})]", name)?;
         }

chalk-solve/src/rust_ir.rs

@@ -277,6 +277,7 @@ pub enum WellKnownTrait {
     DiscriminantKind,
     Generator,
     DispatchFromDyn,
+    Tuple,
 }
 
 chalk_ir::const_visit!(WellKnownTrait);

chalk-solve/src/wf.rs

@@ -435,7 +435,8 @@ where
             | WellKnownTrait::Unsize
             | WellKnownTrait::Sized
             | WellKnownTrait::DiscriminantKind
-            | WellKnownTrait::Generator => false,
+            | WellKnownTrait::Generator
+            | WellKnownTrait::Tuple => false,
         };
 
         if is_legal {

tests/test/tuples.rs

@@ -294,3 +294,55 @@ fn tuples_are_wf() {
         }
     }
 }
+
+#[test]
+fn tuples_implement_tuple_trait() {
+    test! {
+        program {
+            #[lang(tuple_trait)]
+            trait Tuple { }
+        }
+
+        goal {
+            (): Tuple
+        } yields {
+            expect![["Unique"]]
+        }
+
+        goal {
+            (u8,): Tuple
+        } yields {
+            expect![["Unique"]]
+        }
+
+        goal {
+            (i32, i32): Tuple
+        } yields {
+            expect![["Unique"]]
+        }
+
+        goal {
+            ([u8],): Tuple
+        } yields {
+            expect![["Unique"]]
+        }
+
+        goal {
+            forall<T> { (T,): Tuple }
+        } yields {
+            expect![["Unique"]]
+        }
+
+        goal {
+            i32: Tuple
+        } yields {
+            expect![["No possible solution"]]
+        }
+
+        goal {
+            exists<T> { T: Tuple }
+        } yields {
+            expect![["Ambiguous; no inference guidance"]]
+        }
+    }
+}