Fix scalar, tuple tests to properly assert

Author: MarkMcCaskey

chalk-integration/src/lowering.rs

@@ -1085,7 +1085,6 @@ impl LowerTy for Ty {
 
             Ty::Scalar { ty } => Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
                 name: chalk_ir::TypeName::Scalar(ast_scalar_to_chalk_scalar(ty)),
-                // substitution: chalk_ir::Substitution::from_fallible(interner, ty.lower(env)?)?,
                 substitution: chalk_ir::Substitution::empty(interner),
             })
             .intern(interner)),

tests/lowering/mod.rs

@@ -475,84 +475,3 @@ fn scalars() {
         }
     }
 }
-
-#[test]
-fn tuple_trait_impl() {
-    let db = ChalkDatabase::with(
-        "
-trait Foo { }
-struct S1 { }
-impl Foo for (S1, S1) { }
-",
-        SolverChoice::default(),
-    );
-    let goal = db.parse_and_lower_goal("(S1, S1): Foo").unwrap();
-    db.with_program(|_| {
-        assert_eq!(format!("{:?}", goal), "Implemented(2<S1, S1>: Foo)");
-    });
-    let db = ChalkDatabase::with(
-        "
-trait Foo { }
-impl Foo for (i32, i32, (i32,)) { }
-",
-        SolverChoice::default(),
-    );
-    let goal = db.parse_and_lower_goal("(i32, i32, (i32,)): Foo").unwrap();
-    db.with_program(|_| {
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(3<Int(I32), Int(I32), 1<Int(I32)>>: Foo)"
-        );
-    });
-}
-
-#[test]
-fn scalar_trait_impl() {
-    let db = ChalkDatabase::with(
-        "
-trait Foo { }
-impl Foo for usize { }
-impl Foo for isize { }
-impl<T1, T2> Foo for (T1, T2) where T1: Foo, T2: Foo { }
-impl<T> Foo for (T,T,T) where T: Foo { }
-",
-        SolverChoice::default(),
-    );
-    let goal = db.parse_and_lower_goal("(usize, usize): Foo").unwrap();
-    db.with_program(|_| {
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(2<Uint(Usize), Uint(Usize)>: Foo)"
-        );
-    });
-    let goal = db.parse_and_lower_goal("(usize, isize): Foo").unwrap();
-    db.with_program(|_| {
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(2<Uint(Usize), Int(Isize)>: Foo)"
-        );
-    });
-    let goal = db.parse_and_lower_goal("(usize, bool): Foo").unwrap();
-    db.with_program(|_| {
-        // TODO: This should fail (Foo is not implemented for bool)
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(2<Uint(Usize), Bool>: Foo)"
-        );
-    });
-    let goal = db.parse_and_lower_goal("(usize,usize,usize): Foo").unwrap();
-    db.with_program(|_| {
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(3<Uint(Usize), Uint(Usize), Uint(Usize)>: Foo)"
-        );
-    });
-    let goal = db.parse_and_lower_goal("(char,u8,i8): Foo").unwrap();
-    db.with_program(|_| {
-        // TODO: This should fail (the three types are not the same)
-        assert_eq!(
-            format!("{:?}", goal),
-            "Implemented(3<Char, Uint(U8), Int(I8)>: Foo)"
-        );
-    });
-}

tests/test/mod.rs

@@ -270,5 +270,7 @@ mod impls;
 mod misc;
 mod negation;
 mod projection;
+mod scalars;
+mod tuples;
 mod unify;
 mod wf_goals;

tests/test/scalars.rs

@@ -0,0 +1,87 @@
+use super::*;
+
+#[test]
+fn scalar_in_tuple_trait_impl() {
+    test! {
+        program {
+            trait Foo { }
+            impl Foo for usize { }
+            impl Foo for isize { }
+            impl<T1, T2> Foo for (T1, T2) where T1: Foo, T2: Foo { }
+            impl<T> Foo for (T,T,T) where T: Foo { }
+        }
+
+        goal {
+            (usize, usize): Foo
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            (usize, isize): Foo
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            (usize, bool): Foo
+        } yields {
+            "No possible solution"
+        }
+
+        goal {
+            (usize, usize, usize): Foo
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            (char, u8, i8): Foo
+        } yields {
+            "No possible solution"
+        }
+    }
+}
+
+#[test]
+fn scalar_trait_impl() {
+    test! {
+        program {
+            trait Foo { }
+
+            impl Foo for i8 { }
+            impl Foo for i16 { }
+            impl Foo for i32 { }
+            impl Foo for i64 { }
+            impl Foo for i128 { }
+            impl Foo for isize { }
+            impl Foo for u8 { }
+            impl Foo for u16 { }
+            impl Foo for u32 { }
+            impl Foo for u64 { }
+            impl Foo for u128 { }
+            impl Foo for usize { }
+            impl Foo for f32 { }
+            impl Foo for f64 { }
+            impl Foo for bool { }
+            impl Foo for char { }
+        }
+
+        goal { i8: Foo } yields { "Unique" }
+        goal { i16: Foo } yields { "Unique" }
+        goal { i32: Foo } yields { "Unique" }
+        goal { i64: Foo } yields { "Unique" }
+        goal { i128: Foo } yields { "Unique" }
+        goal { isize: Foo } yields { "Unique" }
+        goal { u8: Foo } yields { "Unique" }
+        goal { u16: Foo } yields { "Unique" }
+        goal { u32: Foo } yields { "Unique" }
+        goal { u64: Foo } yields { "Unique" }
+        goal { u128: Foo } yields { "Unique" }
+        goal { usize: Foo } yields { "Unique" }
+        goal { f32: Foo } yields { "Unique" }
+        goal { f64: Foo } yields { "Unique" }
+        goal { bool: Foo } yields { "Unique" }
+        goal { char: Foo } yields { "Unique" }
+    }
+}

tests/test/tuples.rs

@@ -0,0 +1,36 @@
+use super::*;
+
+#[test]
+fn tuple_trait_impl() {
+    test! {
+        program {
+            trait Foo { }
+            struct S1 { }
+            impl Foo for (S1, S1) { }
+            impl Foo for () { }
+        }
+        goal {
+            (S1, S1): Foo
+        } yields {
+            "Unique"
+        }
+
+        goal {
+            (): Foo
+        } yields {
+            "Unique"
+        }
+    }
+    test! {
+        program {
+            trait Foo { }
+            impl Foo for (i32, i32, (i32,)) { }
+        }
+
+        goal {
+            (i32, i32, (i32, )): Foo
+        } yields {
+            "Unique"
+        }
+    }
+}