---

yaml
---
r: 60652
b: refs/heads/auto
c: 1965d72
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4bbc13d6db303264cea477972969bf88442a611b
+refs/heads/auto: 1965d7295775b93d56f6daea96a6d2f6e8f242da
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/librustc/middle/trans/common.rs

@@ -1367,13 +1367,21 @@ pub type mono_id = @mono_id_;
 impl to_bytes::IterBytes for mono_param_id {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-            mono_precise(t, ref mids) =>
-                to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), mids, lsb0, f),
+            mono_precise(t, ref mids) => {
+                0u8.iter_bytes(lsb0, f) &&
+                ty::type_id(t).iter_bytes(lsb0, f) &&
+                mids.iter_bytes(lsb0, f)
+            }
 
             mono_any => 1u8.iter_bytes(lsb0, f),
 
-            mono_repr(ref a, ref b, ref c, ref d) =>
-                to_bytes::iter_bytes_5(&2u8, a, b, c, d, lsb0, f)
+            mono_repr(ref a, ref b, ref c, ref d) => {
+                2u8.iter_bytes(lsb0, f) &&
+                a.iter_bytes(lsb0, f) &&
+                b.iter_bytes(lsb0, f) &&
+                c.iter_bytes(lsb0, f) &&
+                d.iter_bytes(lsb0, f)
+            }
         }
     }
 }
@@ -1386,7 +1394,7 @@ impl to_bytes::IterBytes for MonoDataClass {
 
 impl to_bytes::IterBytes for mono_id_ {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f)
+        self.def.iter_bytes(lsb0, f) && self.params.iter_bytes(lsb0, f)
     }
 }
 

branches/auto/src/librustc/middle/trans/glue.rs

@@ -546,23 +546,20 @@ pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
         decr_refcnt_maybe_free(bcx, llbox, ty::mk_opaque_box(ccx.tcx))
       }
       ty::ty_trait(_, _, ty::UniqTraitStore, _) => {
-          let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
-          // Only drop the value when it is non-null
-          do with_cond(bcx, IsNotNull(bcx, Load(bcx, lluniquevalue))) |bcx| {
-              let llvtable = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_vtable]));
-
-              // Cast the vtable to a pointer to a pointer to a tydesc.
-              let llvtable = PointerCast(bcx,
-                                         llvtable,
-                                         T_ptr(T_ptr(ccx.tydesc_type)));
-              let lltydesc = Load(bcx, llvtable);
-              call_tydesc_glue_full(bcx,
-                                    lluniquevalue,
-                                    lltydesc,
-                                    abi::tydesc_field_free_glue,
-                                    None);
-              bcx
-          }
+        let lluniquevalue = GEPi(bcx, v0, [0, abi::trt_field_box]);
+        let llvtable = Load(bcx, GEPi(bcx, v0, [0, abi::trt_field_vtable]));
+
+        // Cast the vtable to a pointer to a pointer to a tydesc.
+        let llvtable = PointerCast(bcx,
+                                   llvtable,
+                                   T_ptr(T_ptr(ccx.tydesc_type)));
+        let lltydesc = Load(bcx, llvtable);
+        call_tydesc_glue_full(bcx,
+                              lluniquevalue,
+                              lltydesc,
+                              abi::tydesc_field_free_glue,
+                              None);
+        bcx
       }
       ty::ty_opaque_closure_ptr(ck) => {
         closure::make_opaque_cbox_drop_glue(bcx, ck, v0)

branches/auto/src/librustc/middle/ty.rs

@@ -137,7 +137,9 @@ type creader_cache = @mut HashMap<creader_cache_key, t>;
 
 impl to_bytes::IterBytes for creader_cache_key {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        to_bytes::iter_bytes_3(&self.cnum, &self.pos, &self.len, lsb0, f)
+        self.cnum.iter_bytes(lsb0, f) &&
+        self.pos.iter_bytes(lsb0, f) &&
+        self.len.iter_bytes(lsb0, f)
     }
 }
 
@@ -392,14 +394,19 @@ pub struct FnSig {
 
 impl to_bytes::IterBytes for BareFnTy {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        to_bytes::iter_bytes_3(&self.purity, &self.abis, &self.sig, lsb0, f)
+        self.purity.iter_bytes(lsb0, f) &&
+        self.abis.iter_bytes(lsb0, f) &&
+        self.sig.iter_bytes(lsb0, f)
     }
 }
 
 impl to_bytes::IterBytes for ClosureTy {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        to_bytes::iter_bytes_5(&self.purity, &self.sigil, &self.onceness,
-                               &self.region, &self.sig, lsb0, f)
+        self.purity.iter_bytes(lsb0, f) &&
+        self.sigil.iter_bytes(lsb0, f) &&
+        self.onceness.iter_bytes(lsb0, f) &&
+        self.region.iter_bytes(lsb0, f) &&
+        self.sig.iter_bytes(lsb0, f)
     }
 }
 
@@ -717,9 +724,15 @@ pub enum InferTy {
 impl to_bytes::IterBytes for InferTy {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-          TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f),
-          IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f),
-          FloatVar(ref fv) => to_bytes::iter_bytes_2(&2u8, fv, lsb0, f),
+            TyVar(ref tv) => {
+                0u8.iter_bytes(lsb0, f) && tv.iter_bytes(lsb0, f)
+            }
+            IntVar(ref iv) => {
+                1u8.iter_bytes(lsb0, f) && iv.iter_bytes(lsb0, f)
+            }
+            FloatVar(ref fv) => {
+                2u8.iter_bytes(lsb0, f) && fv.iter_bytes(lsb0, f)
+            }
         }
     }
 }
@@ -733,8 +746,12 @@ pub enum InferRegion {
 impl to_bytes::IterBytes for InferRegion {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-            ReVar(ref rv) => to_bytes::iter_bytes_2(&0u8, rv, lsb0, f),
-            ReSkolemized(ref v, _) => to_bytes::iter_bytes_2(&1u8, v, lsb0, f)
+            ReVar(ref rv) => {
+                0u8.iter_bytes(lsb0, f) && rv.iter_bytes(lsb0, f)
+            }
+            ReSkolemized(ref v, _) => {
+                1u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f)
+            }
         }
     }
 }
@@ -2626,119 +2643,115 @@ impl cmp::TotalEq for bound_region {
 impl to_bytes::IterBytes for vstore {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-          vstore_fixed(ref u) =>
-          to_bytes::iter_bytes_2(&0u8, u, lsb0, f),
-
-          vstore_uniq => 1u8.iter_bytes(lsb0, f),
-          vstore_box => 2u8.iter_bytes(lsb0, f),
+            vstore_fixed(ref u) => {
+                0u8.iter_bytes(lsb0, f) && u.iter_bytes(lsb0, f)
+            }
+            vstore_uniq => 1u8.iter_bytes(lsb0, f),
+            vstore_box => 2u8.iter_bytes(lsb0, f),
 
-          vstore_slice(ref r) =>
-          to_bytes::iter_bytes_2(&3u8, r, lsb0, f),
+            vstore_slice(ref r) => {
+                3u8.iter_bytes(lsb0, f) && r.iter_bytes(lsb0, f)
+            }
         }
     }
 }
 
 impl to_bytes::IterBytes for substs {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-          to_bytes::iter_bytes_3(&self.self_r,
-                                 &self.self_ty,
-                                 &self.tps, lsb0, f)
+        self.self_r.iter_bytes(lsb0, f) &&
+        self.self_ty.iter_bytes(lsb0, f) &&
+        self.tps.iter_bytes(lsb0, f)
     }
 }
 
 impl to_bytes::IterBytes for mt {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-          to_bytes::iter_bytes_2(&self.ty,
-                                 &self.mutbl, lsb0, f)
+        self.ty.iter_bytes(lsb0, f) && self.mutbl.iter_bytes(lsb0, f)
     }
 }
 
 impl to_bytes::IterBytes for field {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-          to_bytes::iter_bytes_2(&self.ident,
-                                 &self.mt, lsb0, f)
+        self.ident.iter_bytes(lsb0, f) && self.mt.iter_bytes(lsb0, f)
     }
 }
 
 impl to_bytes::IterBytes for FnSig {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
-        to_bytes::iter_bytes_2(&self.inputs,
-                               &self.output,
-                               lsb0, f)
+        self.inputs.iter_bytes(lsb0, f) && self.output.iter_bytes(lsb0, f)
     }
 }
 
 impl to_bytes::IterBytes for sty {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-          ty_nil => 0u8.iter_bytes(lsb0, f),
-          ty_bool => 1u8.iter_bytes(lsb0, f),
+            ty_nil => 0u8.iter_bytes(lsb0, f),
+            ty_bool => 1u8.iter_bytes(lsb0, f),
 
-          ty_int(ref t) =>
-          to_bytes::iter_bytes_2(&2u8, t, lsb0, f),
+            ty_int(ref t) => 2u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
 
-          ty_uint(ref t) =>
-          to_bytes::iter_bytes_2(&3u8, t, lsb0, f),
+            ty_uint(ref t) => 3u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
 
-          ty_float(ref t) =>
-          to_bytes::iter_bytes_2(&4u8, t, lsb0, f),
+            ty_float(ref t) => 4u8.iter_bytes(lsb0, f) && t.iter_bytes(lsb0, f),
 
-          ty_estr(ref v) =>
-          to_bytes::iter_bytes_2(&5u8, v, lsb0, f),
+            ty_estr(ref v) => 5u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f),
 
-          ty_enum(ref did, ref substs) =>
-          to_bytes::iter_bytes_3(&6u8, did, substs, lsb0, f),
+            ty_enum(ref did, ref substs) => {
+                6u8.iter_bytes(lsb0, f) &&
+                did.iter_bytes(lsb0, f) &&
+                substs.iter_bytes(lsb0, f)
+            }
 
-          ty_box(ref mt) =>
-          to_bytes::iter_bytes_2(&7u8, mt, lsb0, f),
+            ty_box(ref mt) => 7u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
 
-          ty_evec(ref mt, ref v) =>
-          to_bytes::iter_bytes_3(&8u8, mt, v, lsb0, f),
+            ty_evec(ref mt, ref v) => {
+                8u8.iter_bytes(lsb0, f) &&
+                mt.iter_bytes(lsb0, f) &&
+                v.iter_bytes(lsb0, f)
+            }
 
-          ty_unboxed_vec(ref mt) =>
-          to_bytes::iter_bytes_2(&9u8, mt, lsb0, f),
+            ty_unboxed_vec(ref mt) => 9u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
 
-          ty_tup(ref ts) =>
-          to_bytes::iter_bytes_2(&10u8, ts, lsb0, f),
+            ty_tup(ref ts) => 10u8.iter_bytes(lsb0, f) && ts.iter_bytes(lsb0, f),
 
-          ty_bare_fn(ref ft) =>
-          to_bytes::iter_bytes_2(&12u8, ft, lsb0, f),
+            ty_bare_fn(ref ft) => 12u8.iter_bytes(lsb0, f) && ft.iter_bytes(lsb0, f),
 
-          ty_self(ref did) => to_bytes::iter_bytes_2(&13u8, did, lsb0, f),
+            ty_self(ref did) => 13u8.iter_bytes(lsb0, f) && did.iter_bytes(lsb0, f),
 
-          ty_infer(ref v) =>
-          to_bytes::iter_bytes_2(&14u8, v, lsb0, f),
+            ty_infer(ref v) => 14u8.iter_bytes(lsb0, f) && v.iter_bytes(lsb0, f),
 
-          ty_param(ref p) =>
-          to_bytes::iter_bytes_2(&15u8, p, lsb0, f),
+            ty_param(ref p) => 15u8.iter_bytes(lsb0, f) && p.iter_bytes(lsb0, f),
 
-          ty_type => 16u8.iter_bytes(lsb0, f),
-          ty_bot => 17u8.iter_bytes(lsb0, f),
+            ty_type => 16u8.iter_bytes(lsb0, f),
+            ty_bot => 17u8.iter_bytes(lsb0, f),
 
-          ty_ptr(ref mt) =>
-          to_bytes::iter_bytes_2(&18u8, mt, lsb0, f),
+            ty_ptr(ref mt) => 18u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
 
-          ty_uniq(ref mt) =>
-          to_bytes::iter_bytes_2(&19u8, mt, lsb0, f),
+            ty_uniq(ref mt) => 19u8.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f),
 
-          ty_trait(ref did, ref substs, ref v, ref mutbl) =>
-          to_bytes::iter_bytes_5(&20u8, did, substs, v, mutbl, lsb0, f),
+            ty_trait(ref did, ref substs, ref v, ref mutbl) => {
+                20u8.iter_bytes(lsb0, f) &&
+                did.iter_bytes(lsb0, f) &&
+                substs.iter_bytes(lsb0, f) &&
+                v.iter_bytes(lsb0, f) &&
+                mutbl.iter_bytes(lsb0, f)
+            }
 
-          ty_opaque_closure_ptr(ref ck) =>
-          to_bytes::iter_bytes_2(&21u8, ck, lsb0, f),
+            ty_opaque_closure_ptr(ref ck) => 21u8.iter_bytes(lsb0, f) && ck.iter_bytes(lsb0, f),
 
-          ty_opaque_box => 22u8.iter_bytes(lsb0, f),
+            ty_opaque_box => 22u8.iter_bytes(lsb0, f),
 
-          ty_struct(ref did, ref substs) =>
-          to_bytes::iter_bytes_3(&23u8, did, substs, lsb0, f),
+            ty_struct(ref did, ref substs) => {
+                23u8.iter_bytes(lsb0, f) && did.iter_bytes(lsb0, f) && substs.iter_bytes(lsb0, f)
+            }
 
-          ty_rptr(ref r, ref mt) =>
-          to_bytes::iter_bytes_3(&24u8, r, mt, lsb0, f),
+            ty_rptr(ref r, ref mt) => {
+                24u8.iter_bytes(lsb0, f) && r.iter_bytes(lsb0, f) && mt.iter_bytes(lsb0, f)
+            }
 
-          ty_err => 25u8.iter_bytes(lsb0, f),
+            ty_err => 25u8.iter_bytes(lsb0, f),
 
-          ty_closure(ref ct) =>
-          to_bytes::iter_bytes_2(&26u8, ct, lsb0, f),
+            ty_closure(ref ct) => 26u8.iter_bytes(lsb0, f) && ct.iter_bytes(lsb0, f),
         }
     }
 }

branches/auto/src/librustc/middle/typeck/infer/region_inference.rs

@@ -564,14 +564,23 @@ enum Constraint {
 impl to_bytes::IterBytes for Constraint {
    fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         match *self {
-          ConstrainVarSubVar(ref v0, ref v1) =>
-          to_bytes::iter_bytes_3(&0u8, v0, v1, lsb0, f),
+            ConstrainVarSubVar(ref v0, ref v1) => {
+                0u8.iter_bytes(lsb0, f) &&
+                v0.iter_bytes(lsb0, f) &&
+                v1.iter_bytes(lsb0, f)
+            }
 
-          ConstrainRegSubVar(ref ra, ref va) =>
-          to_bytes::iter_bytes_3(&1u8, ra, va, lsb0, f),
+            ConstrainRegSubVar(ref ra, ref va) => {
+                1u8.iter_bytes(lsb0, f) &&
+                ra.iter_bytes(lsb0, f) &&
+                va.iter_bytes(lsb0, f)
+            }
 
-          ConstrainVarSubReg(ref va, ref ra) =>
-          to_bytes::iter_bytes_3(&2u8, va, ra, lsb0, f)
+            ConstrainVarSubReg(ref va, ref ra) => {
+                2u8.iter_bytes(lsb0, f) &&
+                va.iter_bytes(lsb0, f) &&
+                ra.iter_bytes(lsb0, f)
+            }
         }
     }
 }

branches/auto/src/libstd/to_bytes.rs

@@ -236,42 +236,6 @@ impl<A:IterBytes> IterBytes for @[A] {
     }
 }
 
-// NOTE: remove all of these after a snapshot, the new for-loop iteration
-//       protocol makes these unnecessary.
-
-#[inline(always)]
-pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
-                                             lsb0: bool, z: Cb) -> bool {
-    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z)
-}
-
-pub fn iter_bytes_3<A: IterBytes,
-                    B: IterBytes,
-                    C: IterBytes>(a: &A, b: &B, c: &C, lsb0: bool, z: Cb) -> bool {
-    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z)
-}
-
-pub fn iter_bytes_4<A: IterBytes,
-                B: IterBytes,
-                C: IterBytes,
-                D: IterBytes>(a: &A, b: &B, c: &C,
-                              d: &D,
-                              lsb0: bool, z: Cb) -> bool {
-    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
-        d.iter_bytes(lsb0, z)
-}
-
-pub fn iter_bytes_5<A: IterBytes,
-                B: IterBytes,
-                C: IterBytes,
-                D: IterBytes,
-                E: IterBytes>(a: &A, b: &B, c: &C,
-                              d: &D, e: &E,
-                              lsb0: bool, z: Cb) -> bool {
-    a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z) && c.iter_bytes(lsb0, z) &&
-        d.iter_bytes(lsb0, z) && e.iter_bytes(lsb0, z)
-}
-
 impl<'self> IterBytes for &'self str {
     #[inline(always)]
     fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {