---

yaml
---
r: 159486
b: refs/heads/master
c: 85c2c2e
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f637f1c5a27b2d8023342163c6ac5c394d91c1fe
+refs/heads/master: 85c2c2e38ce7c606fac1e9c8fa9d2ab71b35c8c8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
 refs/heads/try: f58aad6dce273570fb130b4df008ef9acd5a5be2

trunk/src/libgraphviz/lib.rs

@@ -90,7 +90,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed> for Edges {
     fn target(&self, e: &Ed) -> Nd { let &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -182,7 +182,7 @@ impl<'a> dot::GraphWalk<'a, Nd, Ed<'a>> for Graph {
     fn target(&self, e: &Ed) -> Nd { let & &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -246,7 +246,7 @@ impl<'a> dot::GraphWalk<'a, Nd<'a>, Ed<'a>> for Graph {
     fn target(&self, e: &Ed<'a>) -> Nd<'a> { let &(_,t) = e; t }
 }
 
-# pub fn main() { use std::io::MemWriter; render_to(&mut MemWriter::new()) }
+# pub fn main() { render_to(&mut Vec::new()) }
 ```
 
 ```no_run
@@ -274,7 +274,7 @@ pub fn main() {
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(globs)]
+#![feature(globs, slicing_syntax)]
 
 pub use self::LabelText::*;
 
@@ -553,7 +553,7 @@ mod tests {
     use self::NodeLabels::*;
     use super::{Id, LabelText, LabelStr, EscStr, Labeller};
     use super::{Nodes, Edges, GraphWalk, render};
-    use std::io::{MemWriter, BufReader, IoResult};
+    use std::io::{BufReader, IoResult};
     use std::str;
 
     /// each node is an index in a vector in the graph.
@@ -702,9 +702,9 @@ mod tests {
     }
 
     fn test_input(g: LabelledGraph) -> IoResult<String> {
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer.get_ref());
+        let mut r = BufReader::new(writer[]);
         r.read_to_string()
     }
 
@@ -809,15 +809,15 @@ r#"digraph hasse_diagram {
             "branch2",
             "afterward"));
 
-        let mut writer = MemWriter::new();
+        let mut writer = Vec::new();
 
         let g = LabelledGraphWithEscStrs::new(
             "syntax_tree", labels,
             vec!(edge(0, 1, "then"), edge(0, 2, "else"),
                  edge(1, 3, ";"),    edge(2, 3, ";"   )));
 
         render(&g, &mut writer).unwrap();
-        let mut r = BufReader::new(writer.get_ref());
+        let mut r = BufReader::new(writer[]);
         let r = r.read_to_string();
 
         assert_eq!(r.unwrap().as_slice(),

trunk/src/librustc/middle/liveness.rs

@@ -122,7 +122,6 @@ use util::nodemap::NodeMap;
 use std::fmt;
 use std::io;
 use std::rc::Rc;
-use std::str;
 use std::uint;
 use syntax::ast;
 use syntax::ast::*;
@@ -742,7 +741,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
 
     #[allow(unused_must_use)]
     fn ln_str(&self, ln: LiveNode) -> String {
-        let mut wr = io::MemWriter::new();
+        let mut wr = Vec::new();
         {
             let wr = &mut wr as &mut io::Writer;
             write!(wr, "[ln({}) of kind {} reads", ln.get(), self.ir.lnk(ln));
@@ -751,7 +750,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             self.write_vars(wr, ln, |idx| self.users[idx].writer);
             write!(wr, "  precedes {}]", self.successors[ln.get()].to_string());
         }
-        str::from_utf8(wr.unwrap().as_slice()).unwrap().to_string()
+        String::from_utf8(wr).unwrap()
     }
 
     fn init_empty(&mut self, ln: LiveNode, succ_ln: LiveNode) {

trunk/src/librustc/middle/trans/cabi_x86_64.rs

@@ -62,12 +62,12 @@ impl RegClass {
     }
 }
 
-trait ClassList for Sized? {
+trait ClassList {
     fn is_pass_byval(&self) -> bool;
     fn is_ret_bysret(&self) -> bool;
 }
 
-impl ClassList for [RegClass] {
+impl<'a> ClassList for &'a [RegClass] {
     fn is_pass_byval(&self) -> bool {
         if self.len() == 0 { return false; }
 

trunk/src/librustc/middle/trans/llrepr.rs

@@ -12,11 +12,11 @@ use middle::trans::context::CrateContext;
 use middle::trans::type_::Type;
 use llvm::ValueRef;
 
-pub trait LlvmRepr for Sized? {
+pub trait LlvmRepr {
     fn llrepr(&self, ccx: &CrateContext) -> String;
 }
 
-impl<T:LlvmRepr> LlvmRepr for [T] {
+impl<'a, T:LlvmRepr> LlvmRepr for &'a [T] {
     fn llrepr(&self, ccx: &CrateContext) -> String {
         let reprs: Vec<String> = self.iter().map(|t| t.llrepr(ccx)).collect();
         format!("[{}]", reprs.connect(","))

trunk/src/librustc/util/ppaux.rs

@@ -37,7 +37,7 @@ use syntax::{ast, ast_util};
 use syntax::owned_slice::OwnedSlice;
 
 /// Produces a string suitable for debugging output.
-pub trait Repr for Sized? {
+pub trait Repr {
     fn repr(&self, tcx: &ctxt) -> String;
 }
 
@@ -578,9 +578,9 @@ impl Repr for () {
     }
 }
 
-impl<'a, Sized? T:Repr> Repr for &'a T {
+impl<'a,T:Repr> Repr for &'a T {
     fn repr(&self, tcx: &ctxt) -> String {
-        Repr::repr(*self, tcx)
+        (&**self).repr(tcx)
     }
 }
 
@@ -600,9 +600,9 @@ fn repr_vec<T:Repr>(tcx: &ctxt, v: &[T]) -> String {
     vec_map_to_string(v, |t| t.repr(tcx))
 }
 
-impl<T:Repr> Repr for [T] {
+impl<'a, T:Repr> Repr for &'a [T] {
     fn repr(&self, tcx: &ctxt) -> String {
-        repr_vec(tcx, self)
+        repr_vec(tcx, *self)
     }
 }
 

trunk/src/librustdoc/html/highlight.rs

@@ -28,13 +28,13 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String {
                                       src.to_string(),
                                       "<stdin>".to_string());
 
-    let mut out = io::MemWriter::new();
+    let mut out = Vec::new();
     doit(&sess,
          lexer::StringReader::new(&sess.span_diagnostic, fm),
          class,
          id,
          &mut out).unwrap();
-    String::from_utf8_lossy(out.unwrap().as_slice()).into_string()
+    String::from_utf8_lossy(out[]).into_string()
 }
 
 /// Exhausts the `lexer` writing the output into `out`.

trunk/src/librustdoc/html/render.rs

@@ -38,7 +38,7 @@ use std::collections::{HashMap, HashSet};
 use std::collections::hash_map::{Occupied, Vacant};
 use std::fmt;
 use std::io::fs::PathExtensions;
-use std::io::{fs, File, BufferedWriter, MemWriter, BufferedReader};
+use std::io::{fs, File, BufferedWriter, BufferedReader};
 use std::io;
 use std::str;
 use std::string::String;
@@ -420,7 +420,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String>
     }
 
     // Collect the index into a string
-    let mut w = MemWriter::new();
+    let mut w = Vec::new();
     try!(write!(&mut w, r#"searchIndex['{}'] = {{"items":["#, krate.name));
 
     let mut lastpath = "".to_string();
@@ -463,7 +463,7 @@ fn build_index(krate: &clean::Crate, cache: &mut Cache) -> io::IoResult<String>
 
     try!(write!(&mut w, "]}};"));
 
-    Ok(String::from_utf8(w.unwrap()).unwrap())
+    Ok(String::from_utf8(w).unwrap())
 }
 
 fn write_shared(cx: &Context,

trunk/src/librustdoc/lib.rs

@@ -28,7 +28,7 @@ extern crate "test" as testing;
 #[phase(plugin, link)] extern crate log;
 
 use std::io;
-use std::io::{File, MemWriter};
+use std::io::File;
 use std::collections::HashMap;
 use std::collections::hash_map::{Occupied, Vacant};
 use serialize::{json, Decodable, Encodable};
@@ -467,12 +467,12 @@ fn json_output(krate: clean::Crate, res: Vec<plugins::PluginJson> ,
     // FIXME #8335: yuck, Rust -> str -> JSON round trip! No way to .encode
     // straight to the Rust JSON representation.
     let crate_json_str = {
-        let mut w = MemWriter::new();
+        let mut w = Vec::new();
         {
             let mut encoder = json::Encoder::new(&mut w as &mut io::Writer);
             krate.encode(&mut encoder).unwrap();
         }
-        String::from_utf8(w.unwrap()).unwrap()
+        String::from_utf8(w).unwrap()
     };
     let crate_json = match json::from_str(crate_json_str.as_slice()) {
         Ok(j) => j,

trunk/src/libserialize/json.rs

@@ -206,7 +206,6 @@ use self::InternalStackElement::*;
 use std;
 use std::collections::{HashMap, TreeMap};
 use std::{char, f64, fmt, io, num, str};
-use std::io::MemWriter;
 use std::mem::{swap, transmute};
 use std::num::{Float, FPNaN, FPInfinite, Int};
 use std::str::{FromStr, ScalarValue};
@@ -412,14 +411,14 @@ impl<'a> Encoder<'a> {
     /// Encode the specified struct into a json [u8]
     pub fn buffer_encode<T:Encodable<Encoder<'a>, io::IoError>>(object: &T) -> Vec<u8>  {
         //Serialize the object in a string using a writer
-        let mut m = MemWriter::new();
+        let mut m = Vec::new();
         // FIXME(14302) remove the transmute and unsafe block.
         unsafe {
             let mut encoder = Encoder::new(&mut m as &mut io::Writer);
-            // MemWriter never Errs
+            // Vec<u8> never Errs
             let _ = object.encode(transmute(&mut encoder));
         }
-        m.unwrap()
+        m
     }
 }
 
@@ -578,13 +577,13 @@ impl<'a> ::Encoder<io::IoError> for Encoder<'a> {
         if idx != 0 { try!(write!(self.writer, ",")) }
         // ref #12967, make sure to wrap a key in double quotes,
         // in the event that its of a type that omits them (eg numbers)
-        let mut buf = MemWriter::new();
+        let mut buf = Vec::new();
         // FIXME(14302) remove the transmute and unsafe block.
         unsafe {
             let mut check_encoder = Encoder::new(&mut buf);
             try!(f(transmute(&mut check_encoder)));
         }
-        let out = str::from_utf8(buf.get_ref()).unwrap();
+        let out = str::from_utf8(buf[]).unwrap();
         let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
         if needs_wrapping { try!(write!(self.writer, "\"")); }
         try!(f(self));
@@ -839,13 +838,13 @@ impl<'a> ::Encoder<io::IoError> for PrettyEncoder<'a> {
         try!(spaces(self.writer, self.curr_indent));
         // ref #12967, make sure to wrap a key in double quotes,
         // in the event that its of a type that omits them (eg numbers)
-        let mut buf = MemWriter::new();
+        let mut buf = Vec::new();
         // FIXME(14302) remove the transmute and unsafe block.
         unsafe {
             let mut check_encoder = PrettyEncoder::new(&mut buf);
             try!(f(transmute(&mut check_encoder)));
         }
-        let out = str::from_utf8(buf.get_ref()).unwrap();
+        let out = str::from_utf8(buf[]).unwrap();
         let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
         if needs_wrapping { try!(write!(self.writer, "\"")); }
         try!(f(self));
@@ -892,9 +891,9 @@ impl Json {
 
     /// Encodes a json value into a string
     pub fn to_pretty_str(&self) -> string::String {
-        let mut s = MemWriter::new();
+        let mut s = Vec::new();
         self.to_pretty_writer(&mut s as &mut io::Writer).unwrap();
-        string::String::from_utf8(s.unwrap()).unwrap()
+        string::String::from_utf8(s).unwrap()
     }
 
      /// If the Json value is an Object, returns the value associated with the provided key.
@@ -2659,12 +2658,11 @@ mod tests {
     }
 
     fn with_str_writer(f: |&mut io::Writer|) -> string::String {
-        use std::io::MemWriter;
         use std::str;
 
-        let mut m = MemWriter::new();
+        let mut m = Vec::new();
         f(&mut m as &mut io::Writer);
-        str::from_utf8(m.unwrap().as_slice()).unwrap().to_string()
+        string::String::from_utf8(m).unwrap()
     }
 
     #[test]
@@ -3286,17 +3284,15 @@ mod tests {
     fn test_encode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
         use std::io::Writer;
-        use std::io::MemWriter;
         use std::collections::HashMap;
         let mut hm: HashMap<uint, bool> = HashMap::new();
         hm.insert(1, true);
-        let mut mem_buf = MemWriter::new();
+        let mut mem_buf = Vec::new();
         {
             let mut encoder = Encoder::new(&mut mem_buf as &mut io::Writer);
             hm.encode(&mut encoder).unwrap();
         }
-        let bytes = mem_buf.unwrap();
-        let json_str = from_utf8(bytes.as_slice()).unwrap();
+        let json_str = from_utf8(mem_buf[]).unwrap();
         match from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3307,17 +3303,15 @@ mod tests {
     fn test_prettyencode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
         use std::io::Writer;
-        use std::io::MemWriter;
         use std::collections::HashMap;
         let mut hm: HashMap<uint, bool> = HashMap::new();
         hm.insert(1, true);
-        let mut mem_buf = MemWriter::new();
+        let mut mem_buf = Vec::new();
         {
             let mut encoder = PrettyEncoder::new(&mut mem_buf as &mut io::Writer);
             hm.encode(&mut encoder).unwrap()
         }
-        let bytes = mem_buf.unwrap();
-        let json_str = from_utf8(bytes.as_slice()).unwrap();
+        let json_str = from_utf8(mem_buf[]).unwrap();
         match from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3327,7 +3321,6 @@ mod tests {
     #[test]
     fn test_prettyencoder_indent_level_param() {
         use std::str::from_utf8;
-        use std::io::MemWriter;
         use std::collections::TreeMap;
 
         let mut tree = TreeMap::new();
@@ -3354,15 +3347,14 @@ mod tests {
 
         // Test up to 4 spaces of indents (more?)
         for i in range(0, 4u) {
-            let mut writer = MemWriter::new();
+            let mut writer = Vec::new();
             {
                 let ref mut encoder = PrettyEncoder::new(&mut writer);
                 encoder.set_indent(i);
                 json.encode(encoder).unwrap();
             }
 
-            let bytes = writer.unwrap();
-            let printed = from_utf8(bytes.as_slice()).unwrap();
+            let printed = from_utf8(writer[]).unwrap();
 
             // Check for indents at each line
             let lines: Vec<&str> = printed.lines().collect();