Add parse rules for ProjectionEq bounds on GATs

Author: tmandry

chalk-parse/src/ast.rs

@@ -68,6 +68,25 @@ pub enum Parameter {
     Lifetime(Lifetime),
 }
 
+/// Represents a trait bound on e.g. a type or type parameter.
+/// Does not know anything about what it's binding.
+pub struct TraitBound {
+    pub trait_name: Identifier,
+    pub args_no_self: Vec<TraitBoundParameter>,
+}
+
+pub enum TraitBoundParameter {
+    Ty(Ty),
+    Lifetime(Lifetime),
+    ProjectionEq(ProjectionEqBound),
+}
+
+pub struct ProjectionEqBound {
+    pub name: Identifier,
+    pub parameters: Vec<Parameter>,
+    pub value: Ty,
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum Kind {
     Ty,
@@ -177,11 +196,6 @@ 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

@@ -85,14 +85,26 @@ AssocTyDefn: AssocTyDefn = {
 };
 
 TraitBound: TraitBound = {
-    <t:Id> <a:Angle<Parameter>> => {
+    <t:Id> <a:Angle<TraitBoundParameter>> => {
         TraitBound {
             trait_name: t,
             args_no_self: a,
         }
     }
 };
 
+TraitBoundParameter: TraitBoundParameter = {
+    Ty => TraitBoundParameter::Ty(<>),
+    Lifetime => TraitBoundParameter::Lifetime(<>),
+    ProjectionEqBound => TraitBoundParameter::ProjectionEq(<>),
+};
+
+ProjectionEqBound: ProjectionEqBound = {
+    <name:Id> <parameters:Angle<Parameter>> "=" <value:Ty> => ProjectionEqBound {
+        name, parameters, value
+    },
+};
+
 Impl: Impl = {
     "impl" <p:Angle<ParameterKind>> <mark:"!"?> <t:Id> <a:Angle<Parameter>> "for" <s:Ty>
         <w:QuantifiedWhereClauses> "{" <assoc:AssocTyValue*> "}" =>

src/ir/lowering/test.rs

@@ -318,8 +318,12 @@ fn gat_parse() {
                 type Item<'a, T> where Self: Sized;
             }
 
+            struct Container<T> {
+                value: T
+            }
+
             trait Baz {
-                type Item<'a, T>: Clone;
+                type Item<'a, 'b, T>: Foo<Item<'b, T> = Containter<T>> + Clone;
             }
 
             trait Quux {