Implement GATs, step 1

chalk-parse/src/ast.rs

@@ -54,6 +54,8 @@ pub struct TraitFlags {
 pub struct AssocTyDefn {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
+    pub bounds: Vec<TraitBound>,
+    pub where_clauses: Vec<QuantifiedWhereClause>,
 }
 
 pub enum ParameterKind {
@@ -115,7 +117,6 @@ pub struct Impl {
 pub struct AssocTyValue {
     pub name: Identifier,
     pub parameter_kinds: Vec<ParameterKind>,
-    pub where_clauses: Vec<WhereClause>,
     pub value: Ty,
 }
 
@@ -176,6 +177,11 @@ impl PolarizedTraitRef {
     }
 }
 
+pub struct TraitBound {
+    pub trait_name: Identifier,
+    pub args_no_self: Vec<Parameter>,
+}
+
 #[derive(Copy, Clone, Debug)]
 pub struct Identifier {
     pub str: InternedString,

chalk-parse/src/parser.lalrpop

@@ -72,9 +72,24 @@ TraitDefn: TraitDefn = {
 };
 
 AssocTyDefn: AssocTyDefn = {
-    "type" <name:Id> <p:Angle<ParameterKind>> ";" => AssocTyDefn {
-        name: name,
-        parameter_kinds: p
+    "type" <name:Id> <p:Angle<ParameterKind>> <b:(":" <Plus<TraitBound>>)?>
+        <w:QuantifiedWhereClauses> ";" =>
+    {
+        AssocTyDefn {
+            name: name,
+            parameter_kinds: p,
+            where_clauses: w,
+            bounds: b.unwrap_or(vec![]),
+        }
+    }
+};
+
+TraitBound: TraitBound = {
+    <t:Id> <a:Angle<Parameter>> => {
+        TraitBound {
+            trait_name: t,
+            args_no_self: a,
+        }
     }
 };
 
@@ -102,11 +117,10 @@ ParameterKind: ParameterKind = {
 };
 
 AssocTyValue: AssocTyValue = {
-    "type" <n:Id> <a:Angle<ParameterKind>> <wc:WhereClauses> "=" <v:Ty> ";" => AssocTyValue {
+    "type" <n:Id> <a:Angle<ParameterKind>> "=" <v:Ty> ";" => AssocTyValue {
         name: n,
         parameter_kinds: a,
         value: v,
-        where_clauses: wc,
     },
 };
 
@@ -201,11 +215,6 @@ InlineClause: Clause = {
     }
 };
 
-WhereClauses: Vec<WhereClause> = {
-    "where" <Comma<WhereClause>>,
-    () => vec![],
-};
-
 QuantifiedWhereClauses: Vec<QuantifiedWhereClause> = {
     "where" <Comma<QuantifiedWhereClause>>,
     () => vec![],
@@ -290,6 +299,11 @@ SemiColon<T>: Vec<T> = {
     <Separator<";", T>>
 };
 
+#[inline]
+Plus<T>: Vec<T> = {
+    <Separator<"+", T>>
+};
+
 Angle<T>: Vec<T> = {
     "<" <Comma<T>> ">",
     () => vec![],

src/fold/mod.rs

@@ -567,7 +567,7 @@ struct_fold!(AssociatedTyValue {
     associated_ty_id,
     value,
 });
-struct_fold!(AssociatedTyValueBound { ty, where_clauses });
+struct_fold!(AssociatedTyValueBound { ty });
 struct_fold!(Environment { clauses });
 struct_fold!(InEnvironment[F] { environment, goal } where F: Fold<Result = F>);
 struct_fold!(EqGoal { a, b });

src/ir/lowering/mod.rs

@@ -872,7 +872,6 @@ impl LowerAssocTyValue for AssocTyValue {
         let value = env.in_binders(self.all_parameters(), |env| {
             Ok(ir::AssociatedTyValueBound {
                 ty: self.value.lower(env)?,
-                where_clauses: self.where_clauses.lower(env)?,
             })
         })?;
         Ok(ir::AssociatedTyValue {

src/ir/lowering/test.rs

@@ -211,8 +211,7 @@ fn atc_accounting() {
             AssociatedTyValue {
                 associated_ty_id: (Iterable::Iter),
                 value: for<lifetime> AssociatedTyValueBound {
-                    ty: Iter<'?0, ?1>,
-                    where_clauses: []
+                    ty: Iter<'?0, ?1>
                 }
             }
         ],
@@ -303,3 +302,34 @@ fn check_parameter_kinds() {
         }
     }
 }
+
+#[test]
+fn gat_parse() {
+    let program = Arc::new(
+        parse_and_lower_program(
+            "
+            trait Sized {}
+
+            trait Foo {
+                type Item<'a, T>: Sized + Clone where Self: Sized;
+            }
+
+            trait Bar {
+                type Item<'a, T> where Self: Sized;
+            }
+
+            trait Baz {
+                type Item<'a, T>: Clone;
+            }
+
+            trait Quux {
+                type Item<'a, T>;
+            }
+            ",
+            SolverChoice::slg()
+        ).unwrap()
+    );
+    tls::set_current_program(&program, || {
+        println!("{:#?}", program.associated_ty_data.values());
+    });
+}

src/ir/mod.rs

@@ -289,10 +289,6 @@ pub struct AssociatedTyValue {
 pub struct AssociatedTyValueBound {
     /// Type that we normalize to. The X in `type Foo<'a> = X`.
     crate ty: Ty,
-
-    /// Where-clauses that must hold for projection to be valid. The
-    /// WC in `type Foo<'a> = X where WC`.
-    crate where_clauses: Vec<DomainGoal>,
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

src/rules/mod.rs

@@ -200,10 +200,7 @@ impl ir::AssociatedTyValue {
             .trait_ref
             .trait_ref()
             .up_shift(self.value.len());
-        let conditions: Vec<ir::Goal> = Some(impl_trait_ref.clone().cast())
-            .into_iter()
-            .chain(self.value.value.where_clauses.clone().cast())
-            .collect();
+        let conditions: Vec<ir::Goal> = vec![impl_trait_ref.clone().cast()];
 
         // Bound parameters + `Self` type of the trait-ref
         let parameters: Vec<_> = {