Merge pull request #4081 from graydon/iterbytes-and-workcache

libs: Remove transitionary material on iter_bytes, add workcache to buil...

Author: graydon

src/libcore/to_bytes.rs

@@ -424,14 +424,6 @@ impl root_map_key : cmp::Eq {
     }
 }
 
-#[cfg(stage0)]
-impl root_map_key : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl root_map_key : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);

src/librustc/middle/borrowck/mod.rs

@@ -1170,22 +1170,6 @@ impl mono_id_ : cmp::Eq {
     pure fn ne(&self, other: &mono_id_) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl mono_param_id : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        match self {
-          mono_precise(t, mids) =>
-          to_bytes::iter_bytes_3(&0u8, &ty::type_id(t), &mids, 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)
-        }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl mono_param_id : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
@@ -1200,14 +1184,6 @@ impl mono_param_id : to_bytes::IterBytes {
     }
 }
 
-#[cfg(stage0)]
-impl mono_id_ : core::to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl mono_id_ : core::to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);

src/librustc/middle/trans/common.rs

@@ -145,14 +145,6 @@ impl DatumMode: cmp::Eq {
     pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl DatumMode: to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as uint).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl DatumMode: to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f)

src/librustc/middle/trans/datum.rs

@@ -488,23 +488,6 @@ impl Constraint : cmp::Eq {
     pure fn ne(&self, other: &Constraint) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl Constraint : to_bytes::IterBytes {
-   pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        match self {
-          ConstrainVarSubVar(ref v0, ref v1) =>
-          to_bytes::iter_bytes_3(&0u8, v0, v1, lsb0, f),
-
-          ConstrainRegSubVar(ref ra, ref va) =>
-          to_bytes::iter_bytes_3(&1u8, ra, va, lsb0, f),
-
-          ConstrainVarSubReg(ref va, ref ra) =>
-          to_bytes::iter_bytes_3(&2u8, va, ra, lsb0, f)
-        }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl Constraint : to_bytes::IterBytes {
    pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
@@ -532,14 +515,6 @@ impl TwoRegions : cmp::Eq {
     pure fn ne(&self, other: &TwoRegions) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl TwoRegions : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.a, &self.b, lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl TwoRegions : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.a, &self.b, lsb0, f)

src/librustc/middle/ty.rs

@@ -737,15 +737,6 @@ impl Url : Eq {
     }
 }
 
-#[cfg(stage0)]
-impl Url: IterBytes {
-    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
-        unsafe { self.to_str() }.iter_bytes(lsb0, f)
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl Url: IterBytes {
     pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
         unsafe { self.to_str() }.iter_bytes(lsb0, f)

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

@@ -85,7 +85,7 @@ pub mod par;
 pub mod cmp;
 pub mod base64;
 pub mod rl;
-// pub mod workcache;
+pub mod workcache;
 
 #[cfg(unicode)]
 mod unicode;

src/libstd/net_url.rs

@@ -74,19 +74,6 @@ struct WorkKey {
     name: ~str
 }
 
-#[cfg(stage0)]
-impl WorkKey: to_bytes::IterBytes {
-    #[inline(always)]
-    pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {
-        let mut flag = true;
-        self.kind.iter_bytes(lsb0, |bytes| {flag = f(bytes); flag});
-        if !flag { return; }
-        self.name.iter_bytes(lsb0, f);
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl WorkKey: to_bytes::IterBytes {
     #[inline(always)]
     pure fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) {

src/libstd/std.rc

@@ -54,15 +54,6 @@ impl ident: cmp::Eq {
     pure fn ne(&self, other: &ident) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl ident: to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        self.repr.iter_bytes(lsb0, f)
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl ident: to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.repr.iter_bytes(lsb0, f)
@@ -311,25 +302,6 @@ enum binding_mode {
     bind_by_implicit_ref
 }
 
-#[cfg(stage0)]
-impl binding_mode : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        match self {
-          bind_by_value => 0u8.iter_bytes(lsb0, f),
-
-          bind_by_move => 1u8.iter_bytes(lsb0, f),
-
-          bind_by_ref(ref m) =>
-          to_bytes::iter_bytes_2(&2u8, m, lsb0, f),
-
-          bind_by_implicit_ref =>
-          3u8.iter_bytes(lsb0, f),
-        }
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl binding_mode : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
@@ -406,15 +378,6 @@ enum pat_ {
 #[auto_deserialize]
 enum mutability { m_mutbl, m_imm, m_const, }
 
-#[cfg(stage0)]
-impl mutability : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl mutability : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -444,15 +407,6 @@ impl Proto : cmp::Eq {
     pure fn ne(&self, other: &Proto) -> bool { !(*self).eq(other) }
 }
 
-#[cfg(stage0)]
-impl Proto : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as uint).iter_bytes(lsb0, f);
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl Proto : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f);
@@ -576,21 +530,6 @@ enum inferable<T> {
     infer(node_id)
 }
 
-#[cfg(stage0)]
-impl<T: to_bytes::IterBytes> inferable<T> : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        match self {
-          expl(ref t) =>
-          to_bytes::iter_bytes_2(&0u8, t, lsb0, f),
-
-          infer(ref n) =>
-          to_bytes::iter_bytes_2(&1u8, n, lsb0, f),
-        }
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl<T: to_bytes::IterBytes> inferable<T> : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
@@ -628,14 +567,6 @@ impl<T:cmp::Eq> inferable<T> : cmp::Eq {
 #[auto_deserialize]
 enum rmode { by_ref, by_val, by_move, by_copy }
 
-#[cfg(stage0)]
-impl rmode : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl rmode : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -985,14 +916,6 @@ enum trait_method {
 #[auto_deserialize]
 enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
 
-#[cfg(stage0)]
-impl int_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl int_ty : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -1023,14 +946,6 @@ impl int_ty : cmp::Eq {
 #[auto_deserialize]
 enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
 
-#[cfg(stage0)]
-impl uint_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl uint_ty : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -1059,14 +974,6 @@ impl uint_ty : cmp::Eq {
 #[auto_deserialize]
 enum float_ty { ty_f, ty_f32, ty_f64, }
 
-#[cfg(stage0)]
-impl float_ty : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl float_ty : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -1212,15 +1119,6 @@ impl Ty : cmp::Eq {
     }
 }
 
-#[cfg(stage0)]
-impl Ty : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl Ty : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
@@ -1248,15 +1146,6 @@ enum purity {
     extern_fn, // declared with "extern fn"
 }
 
-#[cfg(stage0)]
-impl purity : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl purity : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -1278,14 +1167,6 @@ enum ret_style {
     return_val, // everything else
 }
 
-#[cfg(stage0)]
-impl ret_style : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl ret_style : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
@@ -1635,14 +1516,6 @@ enum item_ {
 #[auto_deserialize]
 enum class_mutability { class_mutable, class_immutable }
 
-#[cfg(stage0)]
-impl class_mutability : to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as u8).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl class_mutability : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)

src/libstd/workcache.rs

@@ -252,15 +252,6 @@ pure fn is_call_expr(e: @expr) -> bool {
 }
 
 // This makes def_id hashable
-#[cfg(stage0)]
-impl def_id : core::to_bytes::IterBytes {
-    #[inline(always)]
-    pure fn iter_bytes(+lsb0: bool, f: core::to_bytes::Cb) {
-        core::to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f);
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl def_id : core::to_bytes::IterBytes {
     #[inline(always)]
     pure fn iter_bytes(&self, +lsb0: bool, f: core::to_bytes::Cb) {

src/libsyntax/ast.rs

@@ -72,15 +72,6 @@ impl BytePos: Num {
     static pure fn from_int(+n: int) -> BytePos { BytePos(n as uint) }
 }
 
-#[cfg(stage0)]
-impl BytePos: to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (*self).iter_bytes(lsb0, f)
-    }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl BytePos: to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (**self).iter_bytes(lsb0, f)
@@ -127,14 +118,6 @@ impl CharPos: Num {
     static pure fn from_int(+n: int) -> CharPos { CharPos(n as uint) }
 }
 
-#[cfg(stage0)]
-impl CharPos: to_bytes::IterBytes {
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (*self).iter_bytes(lsb0, f)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl CharPos: to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (**self).iter_bytes(lsb0, f)

src/libsyntax/ast_util.rs

@@ -36,15 +36,6 @@ impl ObsoleteSyntax : cmp::Eq {
     }
 }
 
-#[cfg(stage0)]
-impl ObsoleteSyntax: to_bytes::IterBytes {
-    #[inline(always)]
-    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
-        (self as uint).iter_bytes(lsb0, f);
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl ObsoleteSyntax: to_bytes::IterBytes {
     #[inline(always)]
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {