Demode iter::foldl and friends

4 files changed, 10 insertions, 10 deletions

diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index 90c1b6ba54e..90762c5b714 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -1014,7 +1014,7 @@ impl Liveness {
     fn propagate_through_opt_expr(opt_expr: Option<@expr>,
                                   succ: LiveNode) -> LiveNode {
         do opt_expr.foldl(succ) |succ, expr| {
-            self.propagate_through_expr(expr, succ)
+            self.propagate_through_expr(*expr, *succ)
         }
     }
 
diff --git a/src/rustc/middle/trans/meth.rs b/src/rustc/middle/trans/meth.rs
index 33df35cca52..ebc1645e3d8 100644
--- a/src/rustc/middle/trans/meth.rs
+++ b/src/rustc/middle/trans/meth.rs
@@ -364,8 +364,8 @@ fn combine_impl_and_methods_origins(bcx: block,
 
     // Flatten out to find the number of vtables the method expects.
     let m_vtables = m_boundss.foldl(0, |sum, m_bounds| {
-        m_bounds.foldl(sum, |sum, m_bound| {
-            sum + match m_bound {
+        m_bounds.foldl(*sum, |sum, m_bound| {
+            (*sum) + match (*m_bound) {
                 ty::bound_copy | ty::bound_owned |
                 ty::bound_send | ty::bound_const => 0,
                 ty::bound_trait(_) => 1
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 397a1cd6aa1..973db90ff66 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -2137,25 +2137,25 @@ fn type_size(cx: ctxt, ty: t) -> uint {
       }
 
       ty_rec(flds) => {
-        flds.foldl(0, |s, f| s + type_size(cx, f.mt.ty))
+        flds.foldl(0, |s, f| *s + type_size(cx, f.mt.ty))
       }
 
       ty_class(did, ref substs) => {
         let flds = class_items_as_fields(cx, did, substs);
-        flds.foldl(0, |s, f| s + type_size(cx, f.mt.ty))
+        flds.foldl(0, |s, f| *s + type_size(cx, f.mt.ty))
       }
 
       ty_tup(tys) => {
-        tys.foldl(0, |s, t| s + type_size(cx, t))
+        tys.foldl(0, |s, t| *s + type_size(cx, *t))
       }
 
       ty_enum(did, ref substs) => {
         let variants = substd_enum_variants(cx, did, substs);
         variants.foldl( // find max size of any variant
             0,
-            |m, v| uint::max(m,
+            |m, v| uint::max(*m,
                              // find size of this variant:
-                             v.args.foldl(0, |s, a| s + type_size(cx, a))))
+                             v.args.foldl(0, |s, a| *s + type_size(cx, *a))))
       }
 
       ty_param(_) | ty_self => {
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
index 29d4e9927ff..4afb3ad78a6 100644
--- a/src/rustc/middle/typeck/check/regionmanip.rs
+++ b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -111,14 +111,14 @@ fn replace_bound_regions_in_fn_ty(
 
         // For each type `ty` in `tys`...
         do tys.foldl(isr) |isr, ty| {
-            let mut isr = isr;
+            let mut isr = *isr;
 
             // Using fold_regions is inefficient, because it
             // constructs new types, but it avoids code duplication in
             // terms of locating all the regions within the various
             // kinds of types.  This had already caused me several
             // bugs so I decided to switch over.
-            do ty::fold_regions(tcx, ty) |r, in_fn| {
+            do ty::fold_regions(tcx, *ty) |r, in_fn| {
                 if !in_fn { isr = append_isr(isr, to_r, r); }
                 r
             };