Updating tests to use pipes.

1 files changed, 36 insertions, 22 deletions

diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index 919960f4c82..abf19825fdd 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -10,11 +10,10 @@ impl proto_parser for parser {
     fn parse_proto(id: ident) -> protocol {
         let proto = protocol(id);
 
-        self.expect(token::LBRACE);
-
-        while self.token != token::RBRACE {
-            self.parse_state(proto);
-        }
+        self.parse_unspanned_seq(token::LBRACE,
+                                 token::RBRACE,
+                                 {sep: none, trailing_sep_allowed: false},
+                                 |self| self.parse_state(proto));
 
         ret proto;
     }
@@ -35,29 +34,44 @@ impl proto_parser for parser {
           _ { fail }
         };
 
-        let state = proto.add_state(id, dir);
-        // TODO: add typarams too.
+        let typarms = if self.token == token::LT {
+            self.parse_ty_params()
+        }
+        else { ~[] };
+
+        let state = proto.add_state_poly(id, dir, typarms);
 
-        self.expect(token::LBRACE);
+        // parse the messages
+        self.parse_unspanned_seq(
+            token::LBRACE, token::RBRACE,
+            {sep: some(token::COMMA), trailing_sep_allowed: true},
+            |self| {
+                let mname = self.parse_ident();
 
-        while self.token != token::RBRACE {
-            let mname = self.parse_ident();
+                let args = if self.token == token::LPAREN {
+                    self.parse_unspanned_seq(token::LPAREN,
+                                             token::RPAREN,
+                                             {sep: some(token::COMMA),
+                                              trailing_sep_allowed: true},
+                                             |p| p.parse_ty(false))
+                }
+                else { ~[] };
 
-            // TODO: parse data
+                self.expect(token::RARROW);
 
-            self.expect(token::RARROW);
+                let next = self.parse_ident();
 
-            let next = self.parse_ident();
-            // TODO: parse next types
+                let ntys = if self.token == token::LT {
+                    self.parse_unspanned_seq(token::LT,
+                                             token::GT,
+                                             {sep: some(token::COMMA),
+                                              trailing_sep_allowed: true},
+                                             |p| p.parse_ty(false))
+                }
+                else { ~[] };
 
-            state.add_message(mname, ~[], next, ~[]);
+                state.add_message(mname, args, next, ntys);
 
-            alt copy self.token {
-              token::COMMA { self.bump() }
-              token::RBRACE { }
-              _ { fail }
-            }
-        }
-        self.bump();
+            });
     }
 }