Trait bounds on associated types

shepmaster · May 19, 2020 · 2824424 · 2824424
1 parent 043ce98
commit 2824424
Show file tree

Hide file tree

Showing 3 changed files with 65 additions and 3 deletions.
diff --git a/src/ast.rs b/src/ast.rs
@@ -615,15 +615,35 @@ pub enum TypeGenericsAngleMember {
 /// fn a() -> impl Iterator<Item = bool> {}
 /// //                      ^^^^^^^^^^^
 /// ```
-// TODO: add "type" to the name?
+// TODO: prefix the name with "type"?
 #[derive(Debug, HasExtent, ExtentIndex, Visit)]
 pub struct AssociatedType {
     pub extent: Extent,
     pub name: Ident,
+    pub value: AssociatedTypeValue,
+    pub whitespace: Vec<Whitespace>,
+}
+
+#[derive(Debug, HasExtent, ExtentIndex, Visit, Decompose)]
+pub enum AssociatedTypeValue {
+    Equal(AssociatedTypeValueEqual),
+    Bound(AssociatedTypeValueBound),
+}
+
+#[derive(Debug, HasExtent, ExtentIndex, Visit)]
+pub struct AssociatedTypeValueEqual {
+    pub extent: Extent,
     pub value: Type,
     pub whitespace: Vec<Whitespace>,
 }
 
+#[derive(Debug, HasExtent, ExtentIndex, Visit)]
+pub struct AssociatedTypeValueBound {
+    pub extent: Extent,
+    pub bounds: TraitBounds,
+    pub whitespace: Vec<Whitespace>,
+}
+
 /// A function pointer as a type
 ///
 /// ### Example Source

diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -2446,9 +2446,33 @@ fn associated_type<'s>(pm: &mut Master<'s>, pt: Point<'s>) -> Progress<'s, Assoc
     sequence!(pm, pt, {
         spt   = point;
         name  = ident;
+        value = associated_type_value;
+    }, |pm: &mut Master, pt| AssociatedType { extent: pm.state.ex(spt, pt), name, value, whitespace: Vec::new() })
+}
+
+fn associated_type_value<'s>(pm: &mut Master<'s>, pt: Point<'s>) ->
+    Progress<'s, AssociatedTypeValue>
+{
+    pm.alternate(pt)
+        .one(map(associated_type_value_equal, AssociatedTypeValue::Equal))
+        .one(map(associated_type_value_bound, AssociatedTypeValue::Bound))
+        .finish()
+}
+
+fn associated_type_value_equal<'s>(pm: &mut Master<'s>, pt: Point<'s>) -> Progress<'s, AssociatedTypeValueEqual> {
+    sequence!(pm, pt, {
+        spt   = point;
         _     = equals;
         value = typ;
-    }, |pm: &mut Master, pt| AssociatedType { extent: pm.state.ex(spt, pt), name, value, whitespace: Vec::new() })
+    }, |pm: &mut Master, pt| AssociatedTypeValueEqual { extent: pm.state.ex(spt, pt), value, whitespace: Vec::new() })
+}
+
+fn associated_type_value_bound<'s>(pm: &mut Master<'s>, pt: Point<'s>) -> Progress<'s, AssociatedTypeValueBound> {
+    sequence!(pm, pt, {
+        spt    = point;
+        _      = colon;
+        bounds = trait_bounds;
+    }, |pm: &mut Master, pt| AssociatedTypeValueBound { extent: pm.state.ex(spt, pt), bounds, whitespace: Vec::new() })
 }
 
 fn typ_function<'s>(pm: &mut Master<'s>, pt: Point<'s>) -> Progress<'s, TypeFunction> {
@@ -4141,11 +4165,17 @@ mod test {
     }
 
     #[test]
-    fn trait_bounds_with_associated_types() {
+    fn trait_bounds_with_associated_type_equality() {
         let p = qp(trait_bounds, "A<B, C = D>");
         assert_extent!(p, (0, 11))
     }
 
+    #[test]
+    fn trait_bounds_with_associated_type_bounds() {
+        let p = qp(trait_bounds, "A<B, C: D>");
+        assert_extent!(p, (0, 10))
+    }
+
     #[test]
     fn visibility_self() {
         let p = qp(visibility, "pub(self)");

diff --git a/src/visit.rs b/src/visit.rs
@@ -125,6 +125,9 @@ pub trait Visitor<'ast> {
     fn visit_as_type(&mut self, _: &'ast AsType) -> Control { Control::Continue }
     fn visit_ascription(&mut self, _: &'ast Ascription) -> Control { Control::Continue }
     fn visit_associated_type(&mut self, _: &'ast AssociatedType) -> Control { Control::Continue }
+    fn visit_associated_type_value(&mut self, _: &'ast AssociatedTypeValue) -> Control { Control::Continue }
+    fn visit_associated_type_value_equal(&mut self, _: &'ast AssociatedTypeValueEqual) -> Control { Control::Continue }
+    fn visit_associated_type_value_bound(&mut self, _: &'ast AssociatedTypeValueBound) -> Control { Control::Continue }
     fn visit_async_block(&mut self, _: &'ast AsyncBlock) -> Control { Control::Continue }
     fn visit_attribute(&mut self, _: &'ast Attribute) -> Control { Control::Continue }
     fn visit_attribute_literal(&mut self, _: &'ast AttributeLiteral) -> Control { Control::Continue }
@@ -323,6 +326,9 @@ pub trait Visitor<'ast> {
     fn exit_as_type(&mut self, _: &'ast AsType) {}
     fn exit_ascription(&mut self, _: &'ast Ascription) {}
     fn exit_associated_type(&mut self, _: &'ast AssociatedType) {}
+    fn exit_associated_type_value(&mut self, _: &'ast AssociatedTypeValue) {}
+    fn exit_associated_type_value_equal(&mut self, _: &'ast AssociatedTypeValueEqual) {}
+    fn exit_associated_type_value_bound(&mut self, _: &'ast AssociatedTypeValueBound) {}
     fn exit_async_block(&mut self, _: &'ast AsyncBlock) {}
     fn exit_attribute(&mut self, _: &'ast Attribute) {}
     fn exit_attribute_literal(&mut self, _: &'ast AttributeLiteral) {}
@@ -530,6 +536,9 @@ pub trait VisitorMut {
     fn visit_as_type(&mut self, _: &mut AsType) -> Control { Control::Continue }
     fn visit_ascription(&mut self, _: &mut Ascription) -> Control { Control::Continue }
     fn visit_associated_type(&mut self, _: &mut AssociatedType) -> Control { Control::Continue }
+    fn visit_associated_type_value(&mut self, _: &mut AssociatedTypeValue) -> Control { Control::Continue }
+    fn visit_associated_type_value_equal(&mut self, _: &mut AssociatedTypeValueEqual) -> Control { Control::Continue }
+    fn visit_associated_type_value_bound(&mut self, _: &mut AssociatedTypeValueBound) -> Control { Control::Continue }
     fn visit_async_block(&mut self, _: &mut AsyncBlock) -> Control { Control::Continue }
     fn visit_attribute(&mut self, _: &mut Attribute) -> Control { Control::Continue }
     fn visit_attribute_literal(&mut self, _: &mut AttributeLiteral) -> Control { Control::Continue }
@@ -728,6 +737,9 @@ pub trait VisitorMut {
     fn exit_as_type(&mut self, _: &mut AsType) {}
     fn exit_ascription(&mut self, _: &mut Ascription) {}
     fn exit_associated_type(&mut self, _: &mut AssociatedType) {}
+    fn exit_associated_type_value(&mut self, _: &mut AssociatedTypeValue) {}
+    fn exit_associated_type_value_equal(&mut self, _: &mut AssociatedTypeValueEqual) {}
+    fn exit_associated_type_value_bound(&mut self, _: &mut AssociatedTypeValueBound) {}
     fn exit_async_block(&mut self, _: &mut AsyncBlock) {}
     fn exit_attribute(&mut self, _: &mut Attribute) {}
     fn exit_attribute_literal(&mut self, _: &mut AttributeLiteral) {}