Remove a large amount of deprecated functionality

Spring cleaning is here! In the Fall! This commit removes quite a large amount
of deprecated functionality from the standard libraries. I tried to ensure that
only old deprecated functionality was removed.

This is removing lots and lots of deprecated features, so this is a breaking
change. Please consult the deprecation messages of the deleted code to see how
to migrate code forward if it still needs migration.

[breaking-change]

2 files changed, 46 insertions, 47 deletions

diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index f1fdc71b9c6..65efd4f0042 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -134,12 +134,12 @@ pub fn buf_str(toks: Vec<Token>,
             s.push_str(", ");
         }
         s.push_str(format!("{}={}",
-                           szs.get(i),
-                           tok_str(toks.get(i).clone())).as_slice());
+                           szs[i],
+                           tok_str(toks[i].clone())).as_slice());
         i += 1u;
         i %= n;
     }
-    s.push_char(']');
+    s.push(']');
     return s.into_string();
 }
 
@@ -299,7 +299,7 @@ pub struct Printer {
 
 impl Printer {
     pub fn last_token(&mut self) -> Token {
-        (*self.token.get(self.right)).clone()
+        self.token[self.right].clone()
     }
     // be very careful with this!
     pub fn replace_last_token(&mut self, t: Token) {
@@ -311,8 +311,8 @@ impl Printer {
           Eof => {
             if !self.scan_stack_empty {
                 self.check_stack(0);
-                let left = (*self.token.get(self.left)).clone();
-                let left_size = *self.size.get(self.left);
+                let left = self.token[self.left].clone();
+                let left_size = self.size[self.left];
                 try!(self.advance_left(left, left_size));
             }
             self.indent(0);
@@ -388,14 +388,14 @@ impl Printer {
             debug!("scan window is {}, longer than space on line ({})",
                    self.right_total - self.left_total, self.space);
             if !self.scan_stack_empty {
-                if self.left == *self.scan_stack.get(self.bottom) {
+                if self.left == self.scan_stack[self.bottom] {
                     debug!("setting {} to infinity and popping", self.left);
                     let scanned = self.scan_pop_bottom();
                     *self.size.get_mut(scanned) = SIZE_INFINITY;
                 }
             }
-            let left = (*self.token.get(self.left)).clone();
-            let left_size = *self.size.get(self.left);
+            let left = self.token[self.left].clone();
+            let left_size = self.size[self.left];
             try!(self.advance_left(left, left_size));
             if self.left != self.right {
                 try!(self.check_stream());
@@ -416,7 +416,7 @@ impl Printer {
     }
     pub fn scan_pop(&mut self) -> uint {
         assert!((!self.scan_stack_empty));
-        let x = *self.scan_stack.get(self.top);
+        let x = self.scan_stack[self.top];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
         } else {
@@ -426,11 +426,11 @@ impl Printer {
     }
     pub fn scan_top(&mut self) -> uint {
         assert!((!self.scan_stack_empty));
-        return *self.scan_stack.get(self.top);
+        return self.scan_stack[self.top];
     }
     pub fn scan_pop_bottom(&mut self) -> uint {
         assert!((!self.scan_stack_empty));
-        let x = *self.scan_stack.get(self.bottom);
+        let x = self.scan_stack[self.bottom];
         if self.top == self.bottom {
             self.scan_stack_empty = true;
         } else {
@@ -458,8 +458,8 @@ impl Printer {
             if self.left != self.right {
                 self.left += 1u;
                 self.left %= self.buf_len;
-                let left = (*self.token.get(self.left)).clone();
-                let left_size = *self.size.get(self.left);
+                let left = self.token[self.left].clone();
+                let left_size = self.size[self.left];
                 try!(self.advance_left(left, left_size));
             }
             ret
@@ -470,29 +470,28 @@ impl Printer {
     pub fn check_stack(&mut self, k: int) {
         if !self.scan_stack_empty {
             let x = self.scan_top();
-            match self.token.get(x) {
-              &Begin(_) => {
-                if k > 0 {
+            match self.token[x] {
+                Begin(_) => {
+                    if k > 0 {
+                        let popped = self.scan_pop();
+                        *self.size.get_mut(popped) = self.size[x] +
+                            self.right_total;
+                        self.check_stack(k - 1);
+                    }
+                }
+                End => {
+                    // paper says + not =, but that makes no sense.
                     let popped = self.scan_pop();
-                    *self.size.get_mut(popped) = *self.size.get(x) +
-                        self.right_total;
-                    self.check_stack(k - 1);
+                    *self.size.get_mut(popped) = 1;
+                    self.check_stack(k + 1);
                 }
-              }
-              &End => {
-                // paper says + not =, but that makes no sense.
-                let popped = self.scan_pop();
-                *self.size.get_mut(popped) = 1;
-                self.check_stack(k + 1);
-              }
-              _ => {
-                let popped = self.scan_pop();
-                *self.size.get_mut(popped) = *self.size.get(x) +
-                    self.right_total;
-                if k > 0 {
-                    self.check_stack(k);
+                _ => {
+                    let popped = self.scan_pop();
+                    *self.size.get_mut(popped) = self.size[x] + self.right_total;
+                    if k > 0 {
+                        self.check_stack(k);
+                    }
                 }
-              }
             }
         }
     }
@@ -511,7 +510,7 @@ impl Printer {
         let print_stack = &mut self.print_stack;
         let n = print_stack.len();
         if n != 0u {
-            *print_stack.get(n - 1u)
+            (*print_stack)[n - 1]
         } else {
             PrintStackElem {
                 offset: 0,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index d32828192e9..26cf79ff8f9 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -175,7 +175,7 @@ pub fn to_string(f: |&mut State| -> IoResult<()>) -> String {
         let obj: TraitObject = mem::transmute_copy(&s.s.out);
         let wr: Box<MemWriter> = mem::transmute(obj.data);
         let result =
-            String::from_utf8(Vec::from_slice(wr.get_ref().as_slice())).unwrap();
+            String::from_utf8(wr.get_ref().as_slice().to_vec()).unwrap();
         mem::forget(wr);
         result.to_string()
     }
@@ -1466,7 +1466,7 @@ impl<'a> State<'a> {
             }
             ast::ExprMethodCall(ident, ref tys, ref args) => {
                 let base_args = args.slice_from(1);
-                try!(self.print_expr(&**args.get(0)));
+                try!(self.print_expr(&*args[0]));
                 try!(word(&mut self.s, "."));
                 try!(self.print_ident(ident.node));
                 if tys.len() > 0u {
@@ -2144,7 +2144,7 @@ impl<'a> State<'a> {
         for &explicit_self in opt_explicit_self.iter() {
             let m = match explicit_self {
                 &ast::SelfStatic => ast::MutImmutable,
-                _ => match decl.inputs.get(0).pat.node {
+                _ => match decl.inputs[0].pat.node {
                     ast::PatIdent(ast::BindByValue(m), _, _) => m,
                     _ => ast::MutImmutable
                 }
@@ -2319,7 +2319,7 @@ impl<'a> State<'a> {
 
         try!(self.commasep(Inconsistent, ints.as_slice(), |s, &idx| {
             if idx < generics.lifetimes.len() {
-                let lifetime = generics.lifetimes.get(idx);
+                let lifetime = &generics.lifetimes[idx];
                 s.print_lifetime_def(lifetime)
             } else {
                 let idx = idx - generics.lifetimes.len();
@@ -2663,14 +2663,14 @@ impl<'a> State<'a> {
             ast::LitStr(ref st, style) => self.print_string(st.get(), style),
             ast::LitByte(byte) => {
                 let mut res = String::from_str("b'");
-                (byte as char).escape_default(|c| res.push_char(c));
-                res.push_char('\'');
+                (byte as char).escape_default(|c| res.push(c));
+                res.push('\'');
                 word(&mut self.s, res.as_slice())
             }
             ast::LitChar(ch) => {
                 let mut res = String::from_str("'");
-                ch.escape_default(|c| res.push_char(c));
-                res.push_char('\'');
+                ch.escape_default(|c| res.push(c));
+                res.push('\'');
                 word(&mut self.s, res.as_slice())
             }
             ast::LitInt(i, t) => {
@@ -2717,7 +2717,7 @@ impl<'a> State<'a> {
         match self.literals {
             Some(ref lits) => {
                 while self.cur_cmnt_and_lit.cur_lit < lits.len() {
-                    let ltrl = (*(*lits).get(self.cur_cmnt_and_lit.cur_lit)).clone();
+                    let ltrl = (*lits)[self.cur_cmnt_and_lit.cur_lit].clone();
                     if ltrl.pos > pos { return None; }
                     self.cur_cmnt_and_lit.cur_lit += 1u;
                     if ltrl.pos == pos { return Some(ltrl); }
@@ -2749,7 +2749,7 @@ impl<'a> State<'a> {
             comments::Mixed => {
                 assert_eq!(cmnt.lines.len(), 1u);
                 try!(zerobreak(&mut self.s));
-                try!(word(&mut self.s, cmnt.lines.get(0).as_slice()));
+                try!(word(&mut self.s, cmnt.lines[0].as_slice()));
                 zerobreak(&mut self.s)
             }
             comments::Isolated => {
@@ -2767,7 +2767,7 @@ impl<'a> State<'a> {
             comments::Trailing => {
                 try!(word(&mut self.s, " "));
                 if cmnt.lines.len() == 1u {
-                    try!(word(&mut self.s, cmnt.lines.get(0).as_slice()));
+                    try!(word(&mut self.s, cmnt.lines[0].as_slice()));
                     hardbreak(&mut self.s)
                 } else {
                     try!(self.ibox(0u));
@@ -2813,7 +2813,7 @@ impl<'a> State<'a> {
         match self.comments {
             Some(ref cmnts) => {
                 if self.cur_cmnt_and_lit.cur_cmnt < cmnts.len() {
-                    Some((*cmnts.get(self.cur_cmnt_and_lit.cur_cmnt)).clone())
+                    Some(cmnts[self.cur_cmnt_and_lit.cur_cmnt].clone())
                 } else {
                     None
                 }