---

yaml
---
r: 96123
b: refs/heads/dist-snap
c: c8e6a38
h: refs/heads/master
i:
  96121: 3e60e07
  96119: 56bcd0d
v: v3

Author: huonw

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 5208332a1a0cc2d07d52c117a6abe7e2c8c1f36e
+refs/heads/dist-snap: c8e6a38693d73e06e59c69fbd40c3924836a10e9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -254,7 +254,6 @@ common_escape : '\x5c'
 hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
           | dec_digit ;
-oct_digit : '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' ;
 dec_digit : '0' | nonzero_dec ;
 nonzero_dec: '1' | '2' | '3' | '4'
            | '5' | '6' | '7' | '8' | '9' ;
@@ -319,9 +318,8 @@ r##"foo #"# bar"##;                // foo #"# bar
 ~~~~ {.ebnf .gram}
 
 num_lit : nonzero_dec [ dec_digit | '_' ] * num_suffix ?
-        | '0' [       [ dec_digit | '_' ] * num_suffix ?
+        | '0' [       [ dec_digit | '_' ] + num_suffix ?
               | 'b'   [ '1' | '0' | '_' ] + int_suffix ?
-              | 'o'   [ oct_digit | '_' ] + int_suffix ?
               | 'x'   [ hex_digit | '_' ] + int_suffix ? ] ;
 
 num_suffix : int_suffix | float_suffix ;

branches/dist-snap/src/libextra/num/bigint.rs

@@ -660,7 +660,7 @@ impl ToStrRadix for BigUint {
             let divider    = FromPrimitive::from_uint(base).unwrap();
             let mut result = ~[];
             let mut m      = n;
-            while m > divider {
+            while m >= divider {
                 let (d, m0) = m.div_mod_floor(&divider);
                 result.push(m0.to_uint().unwrap() as BigDigit);
                 m = d;
@@ -2520,6 +2520,11 @@ mod bigint_tests {
         check("-10", Some(-10));
         check("Z", None);
         check("_", None);
+
+        // issue 10522, this hit an edge case that caused it to
+        // attempt to allocate a vector of size (-1u) == huge.
+        let x: BigInt = from_str("1" + "0".repeat(36)).unwrap();
+        let _y = x.to_str();
     }
 
     #[test]

branches/dist-snap/src/librustc/middle/lint.rs

@@ -883,23 +883,20 @@ fn check_unused_unsafe(cx: &Context, e: &ast::Expr) {
 
 fn check_unused_mut_pat(cx: &Context, p: @ast::Pat) {
     match p.node {
-        ast::PatIdent(ast::BindByValue(ast::MutMutable),
-                      ref path, _) if pat_util::pat_is_binding(cx.tcx.def_map, p)=> {
-            // `let mut _a = 1;` doesn't need a warning.
-            let initial_underscore = match path.segments {
-                [ast::PathSegment { identifier: id, _ }] => {
-                    cx.tcx.sess.str_of(id).starts_with("_")
-                }
-                _ => {
-                    cx.tcx.sess.span_bug(p.span,
-                                         "mutable binding that doesn't \
-                                         consist of exactly one segment");
-                }
-            };
-
-            if !initial_underscore && !cx.tcx.used_mut_nodes.contains(&p.id) {
-                cx.span_lint(unused_mut, p.span,
-                             "variable does not need to be mutable");
+        ast::PatIdent(ast::BindByValue(ast::MutMutable), _, _) => {
+            let mut used = false;
+            let mut bindings = 0;
+            do pat_util::pat_bindings(cx.tcx.def_map, p) |_, id, _, _| {
+                used = used || cx.tcx.used_mut_nodes.contains(&id);
+                bindings += 1;
+            }
+            if !used {
+                let msg = if bindings == 1 {
+                    "variable does not need to be mutable"
+                } else {
+                    "variables do not need to be mutable"
+                };
+                cx.span_lint(unused_mut, p.span, msg);
             }
         }
         _ => ()

branches/dist-snap/src/librustc/middle/typeck/check/mod.rs

@@ -863,13 +863,11 @@ pub fn compare_impl_method(tcx: ty::ctxt,
     if impl_m.fty.sig.inputs.len() != trait_m.fty.sig.inputs.len() {
         tcx.sess.span_err(
             impl_m_span,
-            format!("method `{}` has {} parameter{} \
-                  but the declaration in trait `{}` has {}",
-                 tcx.sess.str_of(trait_m.ident),
-                 impl_m.fty.sig.inputs.len(),
-                 if impl_m.fty.sig.inputs.len() == 1 { "" } else { "s" },
-                 ty::item_path_str(tcx, trait_m.def_id),
-                 trait_m.fty.sig.inputs.len()));
+            format!("method `{}` has {} parameter(s) \
+                    but the trait has {} parameter(s)",
+                    tcx.sess.str_of(trait_m.ident),
+                    impl_m.fty.sig.inputs.len(),
+                    trait_m.fty.sig.inputs.len()));
         return;
     }
 

branches/dist-snap/src/librustpkg/api.rs

@@ -81,11 +81,6 @@ pub fn new_workcache_context(p: &Path) -> workcache::Context {
 
 pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,
                  lib: Path) {
-    build_lib_with_cfgs(sysroot, root, name, version, lib, ~[])
-}
-
-pub fn build_lib_with_cfgs(sysroot: Path, root: Path, name: ~str,
-                           version: Version, lib: Path, cfgs: ~[~str]) {
     let cx = default_context(sysroot, root.clone());
     let pkg_src = PkgSrc {
         source_workspace: root.clone(),
@@ -99,16 +94,11 @@ pub fn build_lib_with_cfgs(sysroot: Path, root: Path, name: ~str,
         tests: ~[],
         benchs: ~[]
     };
-    pkg_src.build(&cx, cfgs, []);
+    pkg_src.build(&cx, ~[], []);
 }
 
 pub fn build_exe(sysroot: Path, root: Path, name: ~str, version: Version,
                  main: Path) {
-    build_exe_with_cfgs(sysroot, root, name, version, main, ~[])
-}
-
-pub fn build_exe_with_cfgs(sysroot: Path, root: Path, name: ~str,
-                           version: Version, main: Path, cfgs: ~[~str]) {
     let cx = default_context(sysroot, root.clone());
     let pkg_src = PkgSrc {
         source_workspace: root.clone(),
@@ -123,7 +113,7 @@ pub fn build_exe_with_cfgs(sysroot: Path, root: Path, name: ~str,
         benchs: ~[]
     };
 
-    pkg_src.build(&cx, cfgs, []);
+    pkg_src.build(&cx, ~[], []);
 }
 
 pub fn install_pkg(cx: &BuildContext,

branches/dist-snap/src/libstd/any.rs

@@ -207,7 +207,7 @@ mod tests {
 
     #[test]
     fn type_id_hash() {
-        let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>());
+        let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>::());
 
         assert_eq!(a.hash(), b.hash());
     }

branches/dist-snap/src/libstd/io/buffered.rs

@@ -55,7 +55,8 @@ use prelude::*;
 
 use num;
 use vec;
-use super::{Stream, Decorator};
+use str;
+use super::{Reader, Writer, Stream, Decorator};
 
 // libuv recommends 64k buffers to maximize throughput
 // https://groups.google.com/forum/#!topic/libuv/oQO1HJAIDdA
@@ -92,10 +93,45 @@ impl<R: Reader> BufferedReader<R> {
     pub fn new(inner: R) -> BufferedReader<R> {
         BufferedReader::with_capacity(DEFAULT_CAPACITY, inner)
     }
-}
 
-impl<R: Reader> Buffer for BufferedReader<R> {
-    fn fill<'a>(&'a mut self) -> &'a [u8] {
+    /// Reads the next line of input, interpreted as a sequence of utf-8
+    /// encoded unicode codepoints. If a newline is encountered, then the
+    /// newline is contained in the returned string.
+    pub fn read_line(&mut self) -> Option<~str> {
+        self.read_until('\n' as u8).map(str::from_utf8_owned)
+    }
+
+    /// Reads a sequence of bytes leading up to a specified delimeter. Once the
+    /// specified byte is encountered, reading ceases and the bytes up to and
+    /// including the delimiter are returned.
+    pub fn read_until(&mut self, byte: u8) -> Option<~[u8]> {
+        let mut res = ~[];
+        let mut used;
+        loop {
+            {
+                let available = self.fill_buffer();
+                match available.iter().position(|&b| b == byte) {
+                    Some(i) => {
+                        res.push_all(available.slice_to(i + 1));
+                        used = i + 1;
+                        break
+                    }
+                    None => {
+                        res.push_all(available);
+                        used = available.len();
+                    }
+                }
+            }
+            if used == 0 {
+                break
+            }
+            self.pos += used;
+        }
+        self.pos += used;
+        return if res.len() == 0 {None} else {Some(res)};
+    }
+
+    fn fill_buffer<'a>(&'a mut self) -> &'a [u8] {
         if self.pos == self.cap {
             match self.inner.read(self.buf) {
                 Some(cap) => {
@@ -107,17 +143,12 @@ impl<R: Reader> Buffer for BufferedReader<R> {
         }
         return self.buf.slice(self.pos, self.cap);
     }
-
-    fn consume(&mut self, amt: uint) {
-        self.pos += amt;
-        assert!(self.pos <= self.cap);
-    }
 }
 
 impl<R: Reader> Reader for BufferedReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
         let nread = {
-            let available = self.fill();
+            let available = self.fill_buffer();
             if available.len() == 0 {
                 return None;
             }
@@ -135,9 +166,17 @@ impl<R: Reader> Reader for BufferedReader<R> {
 }
 
 impl<R: Reader> Decorator<R> for BufferedReader<R> {
-    fn inner(self) -> R { self.inner }
-    fn inner_ref<'a>(&'a self) -> &'a R { &self.inner }
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut R { &mut self.inner }
+    fn inner(self) -> R {
+        self.inner
+    }
+
+    fn inner_ref<'a>(&'a self) -> &'a R {
+        &self.inner
+    }
+
+    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut R {
+        &mut self.inner
+    }
 }
 
 /// Wraps a Writer and buffers output to it
@@ -240,8 +279,13 @@ impl<W: Writer> Decorator<W> for LineBufferedWriter<W> {
 struct InternalBufferedWriter<W>(BufferedWriter<W>);
 
 impl<W: Reader> Reader for InternalBufferedWriter<W> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> { self.inner.read(buf) }
-    fn eof(&mut self) -> bool { self.inner.eof() }
+    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        self.inner.read(buf)
+    }
+
+    fn eof(&mut self) -> bool {
+        self.inner.eof()
+    }
 }
 
 /// Wraps a Stream and buffers input and output to and from it
@@ -267,24 +311,35 @@ impl<S: Stream> BufferedStream<S> {
     }
 }
 
-impl<S: Stream> Buffer for BufferedStream<S> {
-    fn fill<'a>(&'a mut self) -> &'a [u8] { self.inner.fill() }
-    fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
-}
-
 impl<S: Stream> Reader for BufferedStream<S> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> { self.inner.read(buf) }
-    fn eof(&mut self) -> bool { self.inner.eof() }
+    fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
+        self.inner.read(buf)
+    }
+
+    fn eof(&mut self) -> bool {
+        self.inner.eof()
+    }
 }
 
 impl<S: Stream> Writer for BufferedStream<S> {
-    fn write(&mut self, buf: &[u8]) { self.inner.inner.write(buf) }
-    fn flush(&mut self) { self.inner.inner.flush() }
+    fn write(&mut self, buf: &[u8]) {
+        self.inner.inner.write(buf)
+    }
+
+    fn flush(&mut self) {
+        self.inner.inner.flush()
+    }
 }
 
 impl<S: Stream> Decorator<S> for BufferedStream<S> {
-    fn inner(self) -> S { self.inner.inner.inner() }
-    fn inner_ref<'a>(&'a self) -> &'a S { self.inner.inner.inner_ref() }
+    fn inner(self) -> S {
+        self.inner.inner.inner()
+    }
+
+    fn inner_ref<'a>(&'a self) -> &'a S {
+        self.inner.inner.inner_ref()
+    }
+
     fn inner_mut_ref<'a>(&'a mut self) -> &'a mut S {
         self.inner.inner.inner_mut_ref()
     }

branches/dist-snap/src/libstd/io/mem.rs

@@ -123,18 +123,29 @@ impl Reader for MemReader {
 
 impl Seek for MemReader {
     fn tell(&self) -> u64 { self.pos as u64 }
-    fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() }
-}
 
-impl Buffer for MemReader {
-    fn fill<'a>(&'a mut self) -> &'a [u8] { self.buf.slice_from(self.pos) }
-    fn consume(&mut self, amt: uint) { self.pos += amt; }
+    fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() }
 }
 
 impl Decorator<~[u8]> for MemReader {
-    fn inner(self) -> ~[u8] { self.buf }
-    fn inner_ref<'a>(&'a self) -> &'a ~[u8] { &self.buf }
-    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut ~[u8] { &mut self.buf }
+
+    fn inner(self) -> ~[u8] {
+        match self {
+            MemReader { buf: buf, _ } => buf
+        }
+    }
+
+    fn inner_ref<'a>(&'a self) -> &'a ~[u8] {
+        match *self {
+            MemReader { buf: ref buf, _ } => buf
+        }
+    }
+
+    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut ~[u8] {
+        match *self {
+            MemReader { buf: ref mut buf, _ } => buf
+        }
+    }
 }
 
 
@@ -233,11 +244,6 @@ impl<'self> Seek for BufReader<'self> {
     fn seek(&mut self, _pos: i64, _style: SeekStyle) { fail!() }
 }
 
-impl<'self> Buffer for BufReader<'self> {
-    fn fill<'a>(&'a mut self) -> &'a [u8] { self.buf.slice_from(self.pos) }
-    fn consume(&mut self, amt: uint) { self.pos += amt; }
-}
-
 ///Calls a function with a MemWriter and returns
 ///the writer's stored vector.
 pub fn with_mem_writer(writeFn:&fn(&mut MemWriter)) -> ~[u8] {
@@ -388,20 +394,4 @@ mod test {
         let buf = with_mem_writer(|wr| wr.write([1,2,3,4,5,6,7]));
         assert_eq!(buf, ~[1,2,3,4,5,6,7]);
     }
-
-    #[test]
-    fn test_read_char() {
-        let mut r = BufReader::new(bytes!("Việt"));
-        assert_eq!(r.read_char(), Some('V'));
-        assert_eq!(r.read_char(), Some('i'));
-        assert_eq!(r.read_char(), Some('ệ'));
-        assert_eq!(r.read_char(), Some('t'));
-        assert_eq!(r.read_char(), None);
-    }
-
-    #[test]
-    fn test_read_bad_char() {
-        let mut r = BufReader::new(bytes!(0x80));
-        assert_eq!(r.read_char(), None);
-    }
 }