auto merge of #12955 : sfackler/rust/vec_ng-doc, r=alexcrichton

I also removed a couple of methods that were silly and added sort.

Author: bors

src/libnum/bigint.rs

@@ -117,7 +117,7 @@ impl TotalOrd for BigUint {
         if s_len < o_len { return Less; }
         if s_len > o_len { return Greater;  }
 
-        for (&self_i, &other_i) in self.data.rev_iter().zip(other.data.rev_iter()) {
+        for (&self_i, &other_i) in self.data.iter().rev().zip(other.data.iter().rev()) {
             if self_i < other_i { return Less; }
             if self_i > other_i { return Greater; }
         }
@@ -788,7 +788,7 @@ impl BigUint {
 
         let mut borrow = 0;
         let mut shifted_rev = Vec::with_capacity(self.data.len());
-        for elem in self.data.rev_iter() {
+        for elem in self.data.iter().rev() {
             shifted_rev.push((*elem >> n_bits) | borrow);
             borrow = *elem << (BigDigit::bits - n_bits);
         }

src/librustc/middle/check_match.rs

@@ -288,7 +288,7 @@ fn is_useful(cx: &MatchCheckCtxt, m: &matrix, v: &[@Pat]) -> useful {
                 is_useful_specialized(cx, m, v, vec(n), n, left_ty)
               }
               ty::ty_unboxed_vec(..) | ty::ty_vec(..) => {
-                let max_len = m.rev_iter().fold(0, |max_len, r| {
+                let max_len = m.iter().rev().fold(0, |max_len, r| {
                   match r.get(0).node {
                     PatVec(ref before, _, ref after) => {
                       cmp::max(before.len() + after.len(), max_len)

src/librustc/middle/liveness.rs

@@ -879,7 +879,7 @@ impl<'a> Liveness<'a> {
     fn propagate_through_block(&mut self, blk: &Block, succ: LiveNode)
                                -> LiveNode {
         let succ = self.propagate_through_opt_expr(blk.expr, succ);
-        blk.stmts.rev_iter().fold(succ, |succ, stmt| {
+        blk.stmts.iter().rev().fold(succ, |succ, stmt| {
             self.propagate_through_stmt(*stmt, succ)
         })
     }
@@ -980,7 +980,7 @@ impl<'a> Liveness<'a> {
                         this.ir.tcx.sess.span_bug(expr.span, "no registered caps");
                      }
                  };
-                 caps.deref().rev_iter().fold(succ, |succ, cap| {
+                 caps.deref().iter().rev().fold(succ, |succ, cap| {
                      this.init_from_succ(cap.ln, succ);
                      let var = this.variable(cap.var_nid, expr.span);
                      this.acc(cap.ln, var, ACC_READ | ACC_USE);
@@ -1121,7 +1121,7 @@ impl<'a> Liveness<'a> {
 
           ExprStruct(_, ref fields, with_expr) => {
             let succ = self.propagate_through_opt_expr(with_expr, succ);
-            fields.rev_iter().fold(succ, |succ, field| {
+            fields.iter().rev().fold(succ, |succ, field| {
                 self.propagate_through_expr(field.expr, succ)
             })
           }
@@ -1173,14 +1173,14 @@ impl<'a> Liveness<'a> {
           }
 
           ExprInlineAsm(ref ia) => {
-            let succ = ia.outputs.rev_iter().fold(succ, |succ, &(_, expr)| {
+            let succ = ia.outputs.iter().rev().fold(succ, |succ, &(_, expr)| {
                 // see comment on lvalues in
                 // propagate_through_lvalue_components()
                 let succ = self.write_lvalue(expr, succ, ACC_WRITE);
                 self.propagate_through_lvalue_components(expr, succ)
             });
             // Inputs are executed first. Propagate last because of rev order
-            ia.inputs.rev_iter().fold(succ, |succ, &(_, expr)| {
+            ia.inputs.iter().rev().fold(succ, |succ, &(_, expr)| {
                 self.propagate_through_expr(expr, succ)
             })
           }

src/librustc/middle/resolve.rs

@@ -5520,7 +5520,8 @@ impl<'a> Resolver<'a> {
         if idents.len() == 0 {
             return ~"???";
         }
-        return self.idents_to_str(idents.move_rev_iter()
+        return self.idents_to_str(idents.move_iter()
+                                        .rev()
                                         .collect::<Vec<ast::Ident>>()
                                         .as_slice());
     }

src/librustc/middle/typeck/check/vtable.rs

@@ -94,7 +94,8 @@ fn lookup_vtables(vcx: &VtableContext,
     // We do this backwards for reasons discussed above.
     assert_eq!(substs.tps.len(), type_param_defs.len());
     let mut result: Vec<vtable_param_res> =
-        substs.tps.rev_iter()
+        substs.tps.iter()
+        .rev()
         .zip(type_param_defs.rev_iter())
         .map(|(ty, def)|
             lookup_vtables_for_param(vcx, span, Some(substs),

src/libstd/vec_ng.rs

@@ -1158,7 +1158,7 @@ pub fn cs_fold(use_foldl: bool,
                       field.other.as_slice())
                 })
             } else {
-                all_fields.rev_iter().fold(base, |old, field| {
+                all_fields.iter().rev().fold(base, |old, field| {
                     f(cx,
                       field.span,
                       old,
@@ -1235,7 +1235,7 @@ pub fn cs_same_method_fold(use_foldl: bool,
                     f(cx, span, old, new)
                 })
             } else {
-                vals.rev_iter().fold(base, |old, &new| {
+                vals.iter().rev().fold(base, |old, &new| {
                     f(cx, span, old, new)
                 })
             }

src/libsyntax/ext/deriving/generic.rs

@@ -60,7 +60,7 @@ pub fn expand_meta_deriving(cx: &mut ExtCtxt,
             cx.span_warn(mitem.span, "empty trait list in `deriving`");
         }
         MetaList(_, ref titems) => {
-            for &titem in titems.rev_iter() {
+            for &titem in titems.iter().rev() {
                 match titem.node {
                     MetaNameValue(ref tname, _) |
                     MetaList(ref tname, _) |

src/libsyntax/ext/deriving/mod.rs

@@ -264,7 +264,7 @@ pub fn expand_item(it: @ast::Item, fld: &mut MacroExpander)
     let it = expand_item_modifiers(it, fld);
 
     let mut decorator_items = SmallVector::zero();
-    for attr in it.attrs.rev_iter() {
+    for attr in it.attrs.iter().rev() {
         let mname = attr.name();
 
         match fld.extsbox.find(&intern(mname.get())) {

src/libsyntax/ext/expand.rs

@@ -309,7 +309,7 @@ mod tests {
     // returning the resulting index
     fn unfold_test_sc(tscs : Vec<TestSC> , tail: SyntaxContext, table: &SCTable)
         -> SyntaxContext {
-        tscs.rev_iter().fold(tail, |tail : SyntaxContext, tsc : &TestSC|
+        tscs.iter().rev().fold(tail, |tail : SyntaxContext, tsc : &TestSC|
                   {match *tsc {
                       M(mrk) => new_mark_internal(mrk,tail,table),
                       R(ident,name) => new_rename_internal(ident,name,tail,table)}})
@@ -355,7 +355,7 @@ mod tests {
     // in a vector. v[0] will be the outermost mark.
     fn unfold_marks(mrks: Vec<Mrk> , tail: SyntaxContext, table: &SCTable)
                     -> SyntaxContext {
-        mrks.rev_iter().fold(tail, |tail:SyntaxContext, mrk:&Mrk|
+        mrks.iter().rev().fold(tail, |tail:SyntaxContext, mrk:&Mrk|
                    {new_mark_internal(*mrk,tail,table)})
     }