Updating tests to use pipes.

Author: eholk

src/libcore/future.rs

@@ -138,6 +138,15 @@ fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
 }
 
 // The pipe protocol, generated by pipec
+/*
+proto! future_pipe {
+    waiting:recv<T:send> {
+        completed(T) -> terminated
+    }
+
+    terminated { }
+}
+*/
 mod future_pipe {
     fn init<T: send>() -> (client::waiting<T>, server::waiting<T>) {
         { let (s, c) = pipes::entangle(); (c, s) }

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();
+            });
     }
 }

src/test/bench/msgsend-ring-contracts.rs renamed to src/test/bench/msgsend-ring-pipes.rs

@@ -4,7 +4,7 @@
 // that things will look really good once we get that lock out of the
 // message path.
 
-// This version uses semi-automatically compiled channel contracts.
+// This version uses automatically compiled channel contracts.
 
 // xfail-pretty
 
@@ -13,40 +13,15 @@ import future::future;
 use std;
 import std::time;
 
-import ring::server::recv;
-
-// This module was generated by the pipe compiler.
-mod ring {
-    fn init() -> (client::num, server::num) { pipes::entangle() }
-    enum num { num(uint, server::num), }
-    mod client {
-        fn num(-pipe: num, x_0: uint) -> num {
-            let (c, s) = pipes::entangle();
-            let message = ring::num(x_0, s);
-            pipes::send(pipe, message);
-            c
-        }
-        type num = pipes::send_packet<ring::num>;
-    }
-    mod server {
-        impl recv for num {
-            fn recv() -> extern fn(-num) -> ring::num {
-                fn recv(-pipe: num) -> ring::num {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type num = pipes::recv_packet<ring::num>;
+import pipes::recv;
+
+proto! ring {
+    num:send {
+        num(uint) -> num
     }
 }
 
 fn macros() {
-    #macro[
-        [#recv[chan],
-         chan.recv()(chan)]
-    ];
-
     #macro[
         [#move[x],
          unsafe { let y <- *ptr::addr_of(x); y }]
@@ -68,7 +43,7 @@ fn thread_ring(i: uint,
         num_port2 <-> num_port;
         num_chan = some(ring::client::num(option::unwrap(num_chan2), i * j));
         let port = option::unwrap(num_port2);
-        alt (#recv(port)) {
+        alt (option::unwrap(recv(port))) {
           ring::num(_n, p) {
             //log(error, _n);
             num_port = some(#move(p));

src/test/run-pass/pipe-manual-1.rs

@@ -1,72 +1,22 @@
+// xfail-pretty
+
 use std;
 import std::timer::sleep;
 import std::uv;
 
 import pipes::{recv, select};
 
-// Compiled by pipec
-mod oneshot {
-    fn init() -> (client::waiting, server::waiting) { pipes::entangle() }
-    enum waiting { signal(server::signaled), }
-    enum signaled { }
-    mod client {
-        fn signal(-pipe: waiting) -> signaled {
-            let (c, s) = pipes::entangle();
-            let message = oneshot::signal(s);
-            pipes::send(pipe, message);
-            c
-        }
-        type waiting = pipes::send_packet<oneshot::waiting>;
-        type signaled = pipes::send_packet<oneshot::signaled>;
-    }
-    mod server {
-        impl recv for waiting {
-            fn recv() -> extern fn(-waiting) -> oneshot::waiting {
-                fn recv(-pipe: waiting) -> oneshot::waiting {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type waiting = pipes::recv_packet<oneshot::waiting>;
-        impl recv for signaled {
-            fn recv() -> extern fn(-signaled) -> oneshot::signaled {
-                fn recv(-pipe: signaled) -> oneshot::signaled {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type signaled = pipes::recv_packet<oneshot::signaled>;
+proto! oneshot {
+    waiting:send {
+        signal -> signaled
     }
+
+    signaled:send { }
 }
 
-mod stream {
-    fn init<T: send>() -> (client::stream<T>, server::stream<T>) {
-        pipes::entangle()
-    }
-    enum stream<T: send> { send(T, server::stream<T>), }
-    mod client {
-        fn send<T: send>(+pipe: stream<T>, +x_0: T) -> stream<T> {
-            {
-                let (c, s) = pipes::entangle();
-                let message = stream::send(x_0, s);
-                pipes::send(pipe, message);
-                c
-            }
-        }
-        type stream<T: send> = pipes::send_packet<stream::stream<T>>;
-    }
-    mod server {
-        impl recv<T: send> for stream<T> {
-            fn recv() -> extern fn(+stream<T>) -> stream::stream<T> {
-                fn recv<T: send>(+pipe: stream<T>) -> stream::stream<T> {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type stream<T: send> = pipes::recv_packet<stream::stream<T>>;
+proto! stream {
+    stream:send<T:send> {
+        send(T) -> stream<T>
     }
 }
 

src/test/run-pass/pipe-manual-2.rs

@@ -1,54 +1,22 @@
+// xfail-pretty
+
 use std;
 import std::timer::sleep;
 import std::uv;
+import pipes::recv;
 
-// Compiled by pipec
-mod oneshot {
-    fn init() -> (client::waiting, server::waiting) { pipes::entangle() }
-    enum waiting { signal(server::signaled), }
-    enum signaled { }
-    mod client {
-        fn signal(-pipe: waiting) -> signaled {
-            let (c, s) = pipes::entangle();
-            let message = oneshot::signal(s);
-            pipes::send(pipe, message);
-            c
-        }
-        type waiting = pipes::send_packet<oneshot::waiting>;
-        type signaled = pipes::send_packet<oneshot::signaled>;
-    }
-    mod server {
-        impl recv for waiting {
-            fn recv() -> extern fn(-waiting) -> oneshot::waiting {
-                fn recv(-pipe: waiting) -> oneshot::waiting {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type waiting = pipes::recv_packet<oneshot::waiting>;
-        impl recv for signaled {
-            fn recv() -> extern fn(-signaled) -> oneshot::signaled {
-                fn recv(-pipe: signaled) -> oneshot::signaled {
-                    option::unwrap(pipes::recv(pipe))
-                }
-                recv
-            }
-        }
-        type signaled = pipes::recv_packet<oneshot::signaled>;
+proto! oneshot {
+    waiting:send {
+        signal -> signaled
     }
+
+    signaled:send { }
 }
 
 fn main() {
     import oneshot::client::*;
-    import oneshot::server::recv;
-
-    #macro[
-        [#recv[chan],
-         chan.recv()(chan)]
-    ];
 
-    let c = pipes::spawn_service(oneshot::init, |p| { #recv(p); });
+    let c = pipes::spawn_service(oneshot::init, |p| { recv(p); });
 
     let iotask = uv::global_loop::get();
     sleep(iotask, 5000);