Compiled a bounded version of pingpong.

There are some failures in the other pipe tests, but these seem to just be a matter of generalizing the library code.

Updating pipes library so all tests pass again

Author: eholk

src/libcore/pipes.rs

@@ -8,7 +8,7 @@ import arc::methods;
 // Things used by code generated by the pipe compiler.
 export entangle, get_buffer, drop_buffer;
 export send_packet_buffered, recv_packet_buffered;
-export mk_packet, entangle_buffer, has_buffer;
+export packet, mk_packet, entangle_buffer, has_buffer;
 
 // export these so we can find them in the buffer_resource
 // destructor. This is probably another metadata bug.
@@ -376,7 +376,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>)
 }
 
 /// Returns true if messages are available.
-pure fn peek<T: send>(p: recv_packet<T>) -> bool {
+pure fn peek<T: send, Tb: send>(p: recv_packet_buffered<T, Tb>) -> bool {
     alt unsafe {(*p.header()).state} {
       empty { false }
       blocked { fail ~"peeking on blocked packet" }
@@ -480,10 +480,11 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
     ready_packet
 }
 
-fn select2<A: send, B: send>(
-    +a: recv_packet<A>,
-    +b: recv_packet<B>)
-    -> either<(option<A>, recv_packet<B>), (recv_packet<A>, option<B>)>
+fn select2<A: send, Ab: send, B: send, Bb: send>(
+    +a: recv_packet_buffered<A, Ab>,
+    +b: recv_packet_buffered<B, Bb>)
+    -> either<(option<A>, recv_packet_buffered<B, Bb>),
+              (recv_packet_buffered<A, Ab>, option<B>)>
 {
     let i = wait_many([a.header(), b.header()]/_);
 
@@ -514,8 +515,8 @@ fn select2i<A: selectable, B: selectable>(a: A, b: B) -> either<(), ()> {
 
 #[doc = "Waits on a set of endpoints. Returns a message, its index,
  and a list of the remaining endpoints."]
-fn select<T: send>(+endpoints: ~[recv_packet<T>])
-    -> (uint, option<T>, ~[recv_packet<T>])
+fn select<T: send, Tb: send>(+endpoints: ~[recv_packet_buffered<T, Tb>])
+    -> (uint, option<T>, ~[recv_packet_buffered<T, Tb>])
 {
     let ready = wait_many(endpoints.map(|p| p.header()));
     let mut remaining = ~[];
@@ -657,10 +658,11 @@ fn entangle<T: send>() -> (send_packet<T>, recv_packet<T>) {
     (send_packet(p), recv_packet(p))
 }
 
-fn spawn_service<T: send>(
-    init: extern fn() -> (send_packet<T>, recv_packet<T>),
-    +service: fn~(+recv_packet<T>))
-    -> send_packet<T>
+fn spawn_service<T: send, Tb: send>(
+    init: extern fn() -> (send_packet_buffered<T, Tb>,
+                          recv_packet_buffered<T, Tb>),
+    +service: fn~(+recv_packet_buffered<T, Tb>))
+    -> send_packet_buffered<T, Tb>
 {
     let (client, server) = init();
 
@@ -676,10 +678,11 @@ fn spawn_service<T: send>(
     client
 }
 
-fn spawn_service_recv<T: send>(
-    init: extern fn() -> (recv_packet<T>, send_packet<T>),
-    +service: fn~(+send_packet<T>))
-    -> recv_packet<T>
+fn spawn_service_recv<T: send, Tb: send>(
+    init: extern fn() -> (recv_packet_buffered<T, Tb>,
+                          send_packet_buffered<T, Tb>),
+    +service: fn~(+send_packet_buffered<T, Tb>))
+    -> recv_packet_buffered<T, Tb>
 {
     let (client, server) = init();
 

src/libsyntax/ext/pipes/ast_builder.rs

@@ -7,6 +7,14 @@ import ast::{ident, node_id};
 import codemap::span;
 import ext::base::mk_ctxt;
 
+// Transitional reexports so qquote can find the paths it is looking for
+mod syntax {
+    import ext;
+    export ext;
+    import parse;
+    export parse;
+}
+
 fn ident(s: ~str) -> ast::ident {
     @(copy s)
 }
@@ -93,9 +101,60 @@ trait ext_ctxt_ast_builder {
     fn ty_vars(+ty_params: ~[ast::ty_param]) -> ~[@ast::ty];
     fn ty_field_imm(name: ident, ty: @ast::ty) -> ast::ty_field;
     fn ty_rec(+~[ast::ty_field]) -> @ast::ty;
+    fn field_imm(name: ident, e: @ast::expr) -> ast::field;
+    fn rec(+~[ast::field]) -> @ast::expr;
+    fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk;
+    fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt;
+    fn stmt_expr(e: @ast::expr) -> @ast::stmt;
+    fn block_expr(b: ast::blk) -> @ast::expr;
 }
 
 impl ast_builder of ext_ctxt_ast_builder for ext_ctxt {
+    fn block_expr(b: ast::blk) -> @ast::expr {
+        @{id: self.next_id(),
+          callee_id: self.next_id(),
+          node: ast::expr_block(b),
+          span: empty_span()}
+    }
+
+    fn stmt_expr(e: @ast::expr) -> @ast::stmt {
+        @{node: ast::stmt_expr(e, self.next_id()),
+          span: empty_span()}
+    }
+
+    fn stmt_let(ident: ident, e: @ast::expr) -> @ast::stmt {
+        // If the quasiquoter could interpolate idents, this is all
+        // we'd need.
+        //
+        //let ext_cx = self;
+        //#ast[stmt] { let $(ident) = $(e) }
+
+        @{node: ast::stmt_decl(@{node: ast::decl_local(~[
+            @{node: {is_mutbl: false,
+                     ty: self.ty_infer(),
+                     pat: @{id: self.next_id(),
+                            node: ast::pat_ident(path(ident), none),
+                            span: empty_span()},
+                     init: some({op: ast::init_move,
+                                 expr: e}),
+                     id: self.next_id()},
+              span: empty_span()}]),
+                               span: empty_span()}, self.next_id()),
+         span: empty_span()}
+    }
+
+    fn field_imm(name: ident, e: @ast::expr) -> ast::field {
+        {node: {mutbl: ast::m_imm, ident: name, expr: e},
+         span: empty_span()}
+    }
+
+    fn rec(+fields: ~[ast::field]) -> @ast::expr {
+        @{id: self.next_id(),
+          callee_id: self.next_id(),
+          node: ast::expr_rec(fields, none),
+          span: empty_span()}
+    }
+
     fn ty_field_imm(name: ident, ty: @ast::ty) -> ast::ty_field {
         {node: {ident: name, mt: { ty: ty, mutbl: ast::m_imm } },
           span: empty_span()}
@@ -107,6 +166,12 @@ impl ast_builder of ext_ctxt_ast_builder for ext_ctxt {
           span: empty_span()}
     }
 
+    fn ty_infer() -> @ast::ty {
+        @{id: self.next_id(),
+          node: ast::ty_infer,
+          span: empty_span()}
+    }
+
     fn ty_param(id: ast::ident, +bounds: ~[ast::ty_param_bound])
         -> ast::ty_param
     {
@@ -128,9 +193,9 @@ impl ast_builder of ext_ctxt_ast_builder for ext_ctxt {
          id: self.next_id()}
     }
 
-    fn expr_block(e: @ast::expr) -> ast::blk {
+    fn block(+stmts: ~[@ast::stmt], e: @ast::expr) -> ast::blk {
         let blk = {view_items: ~[],
-                   stmts: ~[],
+                   stmts: stmts,
                    expr: some(e),
                    id: self.next_id(),
                    rules: ast::default_blk};
@@ -139,6 +204,10 @@ impl ast_builder of ext_ctxt_ast_builder for ext_ctxt {
          span: empty_span()}
     }
 
+    fn expr_block(e: @ast::expr) -> ast::blk {
+        self.block(~[], e)
+    }
+
     fn fn_decl(+inputs: ~[ast::arg],
                output: @ast::ty) -> ast::fn_decl {
         {inputs: inputs,