Lower tuples correctly, clean up parsing

Author: MarkMcCaskey

chalk-integration/src/lowering.rs

@@ -1074,14 +1074,18 @@ impl LowerTy for Ty {
                 };
                 Ok(chalk_ir::TyData::Function(function).intern(interner))
             }
-            Ty::Tuple { arity } => Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
-                name: chalk_ir::TypeName::Tuple(arity),
-                substitution: chalk_ir::Substitution::empty(interner),
+            Ty::Tuple { ref types } => Ok(chalk_ir::TyData::Apply(chalk_ir::ApplicationTy {
+                name: chalk_ir::TypeName::Tuple(types.len()),
+                substitution: chalk_ir::Substitution::from_fallible(
+                    interner,
+                    types.iter().map(|t| Ok(t.lower(env)?)),
+                )?,
             })
             .intern(interner)),
 
             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)),

chalk-parse/src/ast.rs

@@ -176,7 +176,7 @@ pub enum Ty {
         ty: Box<Ty>,
     },
     Tuple {
-        arity: usize,
+        types: Vec<Box<Ty>>,
     },
     Scalar {
         ty: ScalarType,

chalk-parse/src/parser.lalrpop

@@ -212,10 +212,14 @@ ScalarType: ScalarType = {
 };
 
 TupleOrParensInner: Ty = {
-    <l:Comma2<Ty>> => Ty::Tuple { arity: l.len() }, 
-    <Ty> "," => Ty::Tuple { arity: 1 },
     <Ty>,
-    () => Ty::Tuple { arity: 0 },
+    <first:Ty> "," <rest:Comma<Ty>> => {
+        let mut types = Vec::with_capacity(rest.len() + 1);
+        types.push(Box::new(first));
+        types.extend(rest.into_iter().map(Box::new));
+        Ty::Tuple { types }
+    },
+    () => Ty::Tuple { types: vec![] },
 };
 
 Lifetime: Lifetime = {
@@ -370,26 +374,11 @@ Separator1<S, T>: Vec<T> = {
     }
 };
 
-Separator2<S, T>: Vec<T> = {
-    <t1:T> S <t2:T> => vec![t1, t2],
-    <t1:T> S <t2:T> S <v:Separator<S, T>> => {
-        let mut v = v;
-        v.push(t1);
-        v.push(t2);
-        v
-    }
-};
-
 #[inline]
 Comma<T>: Vec<T> = {
     <Separator<",", T>>
 };
 
-#[inline]
-Comma2<T>: Vec<T> = {
-    <Separator2<",", T>>
-};
-
 #[inline]
 SemiColon<T>: Vec<T> = {
     <Separator<";", T>>

tests/lowering/mod.rs

@@ -470,9 +470,89 @@ fn scalars() {
             struct i32 { }
         }
 
-        // TODO: improve this error message
         error_msg {
             "parse error: UnrecognizedToken { token: (8, Token(45, \"i32\"), 11), expected: [\"r#\\\"([A-Za-z]|_)([A-Za-z0-9]|_)*\\\"#\"] }"
         }
     }
 }
+
+#[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)"
+        );
+    });
+}