---

yaml
---
r: 94151
b: refs/heads/try
c: 29ca435
h: refs/heads/master
i:
  94149: 73bd734
  94147: f9d0310
  94143: 671cfa1
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: fce4a174b9ffff71a66feecd9f4960f17fc9c331
+refs/heads/try: 29ca4350c8d64facb39311660e8ee919766f481a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/back/link.rs

@@ -492,7 +492,7 @@ pub fn build_link_meta(sess: Session,
         }
 
         fn len_and_str_lit(l: ast::lit) -> ~str {
-            len_and_str(pprust::lit_to_str(@l))
+            len_and_str(pprust::lit_to_str(&l))
         }
 
         let cmh_items = attr::sort_meta_items(cmh_items);

branches/try/src/librustc/front/test.rs

@@ -330,7 +330,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
      };
 
     debug!("Synthetic test module:\n{}\n",
-           pprust::item_to_str(@item.clone(), cx.sess.intr()));
+           pprust::item_to_str(&item, cx.sess.intr()));
 
     return @item;
 }

branches/try/src/librustc/middle/lint.rs

@@ -1028,27 +1028,47 @@ fn check_unused_mut_pat(cx: &Context, p: &ast::Pat) {
     }
 }
 
+enum Allocation {
+    VectorAllocation,
+    BoxAllocation
+}
+
 fn check_unnecessary_allocation(cx: &Context, e: &ast::Expr) {
-    // Warn if string and vector literals with sigils are immediately borrowed.
-    // Those can have the sigil removed.
-    match e.node {
+    // Warn if string and vector literals with sigils, or boxing expressions,
+    // are immediately borrowed.
+    let allocation = match e.node {
         ast::ExprVstore(e2, ast::ExprVstoreUniq) |
         ast::ExprVstore(e2, ast::ExprVstoreBox) => {
             match e2.node {
                 ast::ExprLit(@codemap::Spanned{node: ast::lit_str(..), ..}) |
-                ast::ExprVec(..) => {}
+                ast::ExprVec(..) => VectorAllocation,
                 _ => return
             }
         }
+        ast::ExprUnary(_, ast::UnUniq, _) |
+        ast::ExprUnary(_, ast::UnBox(..), _) => BoxAllocation,
 
         _ => return
-    }
+    };
+
+    let report = |msg| {
+        cx.span_lint(unnecessary_allocation, e.span, msg);
+    };
 
     match cx.tcx.adjustments.find_copy(&e.id) {
-        Some(@ty::AutoDerefRef(ty::AutoDerefRef {
-            autoref: Some(ty::AutoBorrowVec(..)), .. })) => {
-            cx.span_lint(unnecessary_allocation, e.span,
-                         "unnecessary allocation, the sigil can be removed");
+        Some(@ty::AutoDerefRef(ty::AutoDerefRef { autoref, .. })) => {
+            match (allocation, autoref) {
+                (VectorAllocation, Some(ty::AutoBorrowVec(..))) => {
+                    report("unnecessary allocation, the sigil can be removed");
+                }
+                (BoxAllocation, Some(ty::AutoPtr(_, ast::MutImmutable))) => {
+                    report("unnecessary allocation, use & instead");
+                }
+                (BoxAllocation, Some(ty::AutoPtr(_, ast::MutMutable))) => {
+                    report("unnecessary allocation, use &mut instead");
+                }
+                _ => ()
+            }
         }
 
         _ => ()

branches/try/src/libstd/io/comm_adapters.rs

@@ -8,30 +8,107 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use option::Option;
-use comm::{GenericPort, GenericChan};
+use prelude::*;
+
+use comm::{GenericPort, GenericChan, GenericSmartChan};
+use cmp;
+use io;
+use option::{None, Option, Some};
 use super::{Reader, Writer};
+use vec::{bytes, CopyableVector, MutableVector, ImmutableVector};
 
-pub struct PortReader<P>;
+/// Allows reading from a port.
+///
+/// # Example
+///
+/// ```
+/// let reader = PortReader::new(port);
+///
+/// let mut buf = ~[0u8, ..100];
+/// match reader.read(buf) {
+///     Some(nread) => println!("Read {} bytes", nread),
+///     None => println!("At the end of the stream!")
+/// }
+/// ```
+pub struct PortReader<P> {
+    priv buf: Option<~[u8]>,  // A buffer of bytes received but not consumed.
+    priv pos: uint,           // How many of the buffered bytes have already be consumed.
+    priv port: P,             // The port to pull data from.
+    priv closed: bool,        // Whether the pipe this port connects to has been closed.
+}
 
 impl<P: GenericPort<~[u8]>> PortReader<P> {
-    pub fn new(_port: P) -> PortReader<P> { fail!() }
+    pub fn new(port: P) -> PortReader<P> {
+        PortReader {
+            buf: None,
+            pos: 0,
+            port: port,
+            closed: false,
+        }
+    }
 }
 
 impl<P: GenericPort<~[u8]>> Reader for PortReader<P> {
-    fn read(&mut self, _buf: &mut [u8]) -> Option<uint> { fail!() }
+    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        let mut num_read = 0;
+        loop {
+            match self.buf {
+                Some(ref prev) => {
+                    let dst = buf.mut_slice_from(num_read);
+                    let src = prev.slice_from(self.pos);
+                    let count = cmp::min(dst.len(), src.len());
+                    bytes::copy_memory(dst, src, count);
+                    num_read += count;
+                    self.pos += count;
+                },
+                None => (),
+            };
+            if num_read == buf.len() || self.closed {
+                break;
+            }
+            self.pos = 0;
+            self.buf = self.port.try_recv();
+            self.closed = self.buf.is_none();
+        }
+        if self.closed && num_read == 0 {
+            io::io_error::cond.raise(io::standard_error(io::EndOfFile));
+            None
+        } else {
+            Some(num_read)
+        }
+    }
 
-    fn eof(&mut self) -> bool { fail!() }
+    fn eof(&mut self) -> bool { self.closed }
 }
 
-pub struct ChanWriter<C>;
+/// Allows writing to a chan.
+///
+/// # Example
+///
+/// ```
+/// let writer = ChanWriter::new(chan);
+/// writer.write("hello, world".as_bytes());
+/// ```
+pub struct ChanWriter<C> {
+    chan: C,
+}
 
-impl<C: GenericChan<~[u8]>> ChanWriter<C> {
-    pub fn new(_chan: C) -> ChanWriter<C> { fail!() }
+impl<C: GenericSmartChan<~[u8]>> ChanWriter<C> {
+    pub fn new(chan: C) -> ChanWriter<C> {
+        ChanWriter { chan: chan }
+    }
 }
 
-impl<C: GenericChan<~[u8]>> Writer for ChanWriter<C> {
-    fn write(&mut self, _buf: &[u8]) { fail!() }
+impl<C: GenericSmartChan<~[u8]>> Writer for ChanWriter<C> {
+    fn write(&mut self, buf: &[u8]) {
+        if !self.chan.try_send(buf.to_owned()) {
+            io::io_error::cond.raise(io::IoError {
+                kind: io::BrokenPipe,
+                desc: "Pipe closed",
+                detail: None
+            });
+        }
+    }
 }
 
 pub struct ReaderPort<R>;
@@ -55,3 +132,87 @@ impl<W: Writer> WriterChan<W> {
 impl<W: Writer> GenericChan<~[u8]> for WriterChan<W> {
     fn send(&self, _x: ~[u8]) { fail!() }
 }
+
+
+#[cfg(test)]
+mod test {
+    use prelude::*;
+    use super::*;
+    use io;
+    use comm;
+    use task;
+
+    #[test]
+    fn test_port_reader() {
+        let (port, chan) = comm::stream();
+        do task::spawn {
+          chan.send(~[1u8, 2u8]);
+          chan.send(~[]);
+          chan.send(~[3u8, 4u8]);
+          chan.send(~[5u8, 6u8]);
+          chan.send(~[7u8, 8u8]);
+        }
+
+        let mut reader = PortReader::new(port);
+        let mut buf = ~[0u8, ..3];
+
+        assert_eq!(false, reader.eof());
+
+        assert_eq!(Some(0), reader.read(~[]));
+        assert_eq!(false, reader.eof());
+
+        assert_eq!(Some(3), reader.read(buf));
+        assert_eq!(false, reader.eof());
+        assert_eq!(~[1,2,3], buf);
+
+        assert_eq!(Some(3), reader.read(buf));
+        assert_eq!(false, reader.eof());
+        assert_eq!(~[4,5,6], buf);
+
+        assert_eq!(Some(2), reader.read(buf));
+        assert_eq!(~[7,8,6], buf);
+        assert_eq!(true, reader.eof());
+
+        let mut err = None;
+        let result = io::io_error::cond.trap(|io::standard_error(k, _, _)| {
+            err = Some(k)
+        }).inside(|| {
+            reader.read(buf)
+        });
+        assert_eq!(Some(io::EndOfFile), err);
+        assert_eq!(None, result);
+        assert_eq!(true, reader.eof());
+        assert_eq!(~[7,8,6], buf);
+
+        // Ensure it continues to fail in the same way.
+        err = None;
+        let result = io::io_error::cond.trap(|io::standard_error(k, _, _)| {
+            err = Some(k)
+        }).inside(|| {
+            reader.read(buf)
+        });
+        assert_eq!(Some(io::EndOfFile), err);
+        assert_eq!(None, result);
+        assert_eq!(true, reader.eof());
+        assert_eq!(~[7,8,6], buf);
+    }
+
+    #[test]
+    fn test_chan_writer() {
+        let (port, chan) = comm::stream();
+        let mut writer = ChanWriter::new(chan);
+        writer.write_be_u32(42);
+
+        let wanted = ~[0u8, 0u8, 0u8, 42u8];
+        let got = do task::try { port.recv() }.unwrap();
+        assert_eq!(wanted, got);
+
+        let mut err = None;
+        io::io_error::cond.trap(|io::IoError { kind, .. } | {
+            err = Some(kind)
+        }).inside(|| {
+            writer.write_u8(1)
+        });
+        assert_eq!(Some(io::BrokenPipe), err);
+    }
+}

branches/try/src/libsyntax/ext/quote.rs

@@ -119,78 +119,78 @@ pub mod rt {
     impl<'self> ToSource for &'self str {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_str(self.to_managed(), ast::CookedStr));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for int {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for i8 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i8));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for i16 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i16));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
 
     impl ToSource for i32 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i32));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for i64 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_int(*self as i64, ast::ty_i64));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for uint {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for u8 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u8));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for u16 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u16));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for u32 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u32));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 
     impl ToSource for u64 {
         fn to_source(&self) -> @str {
             let lit = dummy_spanned(ast::lit_uint(*self as u64, ast::ty_u64));
-            pprust::lit_to_str(@lit).to_managed()
+            pprust::lit_to_str(&lit).to_managed()
         }
     }
 

branches/try/src/libsyntax/print/pprust.rs

@@ -1902,7 +1902,7 @@ pub fn print_meta_item(s: @ps, item: &ast::MetaItem) {
       ast::MetaNameValue(name, value) => {
         word_space(s, name);
         word_space(s, "=");
-        print_literal(s, @value);
+        print_literal(s, &value);
       }
       ast::MetaList(name, ref items) => {
         word(s.s, name);