diff --git a/src/libcore/extfmt.rs b/src/libcore/extfmt.rs
index 850d1ea84277..0910975e481a 100644
--- a/src/libcore/extfmt.rs
+++ b/src/libcore/extfmt.rs
@@ -499,12 +499,6 @@ pub mod rt {
 
     pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
 
-    #[cfg(stage0)]
-    pub type Conv = {flags: u32, width: Count, precision: Count, ty: Ty};
-
-    #[cfg(stage1)]
-    #[cfg(stage2)]
-    #[cfg(stage3)]
     pub struct Conv {
         flags: u32,
         width: Count,
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index 052daeaeb2a8..2dde9a9508b2 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -142,10 +142,6 @@ pub fn BufferHeader() -> BufferHeader {
 
 // This is for protocols to associate extra data to thread around.
 #[doc(hidden)]
-#[cfg(stage0)]
-#[cfg(stage1)]
-type Buffer<T> = { header: BufferHeader, data: T };
-#[cfg(stage2)]
 pub struct Buffer<T> {
     header: BufferHeader,
     data: T,
@@ -207,14 +203,6 @@ impl PacketHeader {
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub struct Packet<T: Owned> {
-    header: PacketHeader,
-    mut payload: Option<T>,
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub struct Packet<T> {
     header: PacketHeader,
     mut payload: Option<T>,
@@ -223,16 +211,12 @@ pub struct Packet<T> {
 #[doc(hidden)]
 pub trait HasBuffer {
     fn set_buffer(b: *libc::c_void);
-    // FIXME #4421 remove after snapshot
-    fn set_buffer_(b: *libc::c_void);
 }
 
 impl<T: Owned> Packet<T>: HasBuffer {
     fn set_buffer(b: *libc::c_void) {
         self.header.buffer = b;
     }
-    // FIXME #4421 remove after snapshot
-    fn set_buffer_(b: *libc::c_void) { self.set_buffer(b) }
 }
 
 #[doc(hidden)]
@@ -243,38 +227,6 @@ pub fn mk_packet<T: Owned>() -> Packet<T> {
     }
 }
 #[doc(hidden)]
-#[cfg(stage0)]
-fn unibuffer<T: Owned>() -> ~Buffer<Packet<T>> {
-    let b = ~{
-        header: BufferHeader(),
-        data: Packet {
-            header: PacketHeader(),
-            payload: None,
-        }
-    };
-
-    unsafe {
-        b.data.header.buffer = reinterpret_cast(&b);
-    }
-    move b
-}
-#[cfg(stage1)]
-fn unibuffer<T>() -> ~Buffer<Packet<T>> {
-    let b = ~{
-        header: BufferHeader(),
-        data: Packet {
-            header: PacketHeader(),
-            payload: None,
-        }
-    };
-
-    unsafe {
-        b.data.header.buffer = reinterpret_cast(&b);
-    }
-    move b
-}
-#[doc(hidden)]
-#[cfg(stage2)]
 fn unibuffer<T>() -> ~Buffer<Packet<T>> {
     let b = ~Buffer {
         header: BufferHeader(),
@@ -291,17 +243,6 @@ fn unibuffer<T>() -> ~Buffer<Packet<T>> {
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub fn packet<T: Owned>() -> *Packet<T> {
-    let b = unibuffer();
-    let p = ptr::addr_of(&(b.data));
-    // We'll take over memory management from here.
-    unsafe { forget(move b) }
-    p
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn packet<T>() -> *Packet<T> {
     let b = unibuffer();
     let p = ptr::addr_of(&(b.data));
@@ -412,42 +353,11 @@ fn swap_state_rel(dst: &mut State, src: State) -> State {
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub unsafe fn get_buffer<T: Owned>(p: *PacketHeader) -> ~Buffer<T> {
-    transmute((*p).buf_header())
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub unsafe fn get_buffer<T>(p: *PacketHeader) -> ~Buffer<T> {
     transmute((*p).buf_header())
 }
 
 // This could probably be done with SharedMutableState to avoid move_it!().
-#[cfg(stage0)]
-struct BufferResource<T: Owned> {
-    buffer: ~Buffer<T>,
-
-    drop {
-        unsafe {
-            let b = move_it!(self.buffer);
-            //let p = ptr::addr_of(*b);
-            //error!("drop %?", p);
-            let old_count = atomic_sub_rel(&mut b.header.ref_count, 1);
-            //let old_count = atomic_xchng_rel(b.header.ref_count, 0);
-            if old_count == 1 {
-                // The new count is 0.
-
-                // go go gadget drop glue
-            }
-            else {
-                forget(move b)
-            }
-        }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 struct BufferResource<T> {
     buffer: ~Buffer<T>,
 
@@ -470,19 +380,6 @@ struct BufferResource<T> {
     }
 }
 
-#[cfg(stage0)]
-fn BufferResource<T: Owned>(b: ~Buffer<T>) -> BufferResource<T> {
-    //let p = ptr::addr_of(*b);
-    //error!("take %?", p);
-    atomic_add_acq(&mut b.header.ref_count, 1);
-
-    BufferResource {
-        // tjc: ????
-        buffer: move b
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 fn BufferResource<T>(b: ~Buffer<T>) -> BufferResource<T> {
     //let p = ptr::addr_of(*b);
     //error!("take %?", p);
@@ -495,51 +392,6 @@ fn BufferResource<T>(b: ~Buffer<T>) -> BufferResource<T> {
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub fn send<T: Owned, Tbuffer: Owned>(p: SendPacketBuffered<T, Tbuffer>,
-                                    payload: T) -> bool {
-    let header = p.header();
-    let p_ = p.unwrap();
-    let p = unsafe { &*p_ };
-    assert ptr::addr_of(&(p.header)) == header;
-    assert p.payload.is_none();
-    p.payload = move Some(move payload);
-    let old_state = swap_state_rel(&mut p.header.state, Full);
-    match old_state {
-        Empty => {
-            // Yay, fastpath.
-
-            // The receiver will eventually clean this up.
-            //unsafe { forget(p); }
-            return true;
-        }
-        Full => fail ~"duplicate send",
-        Blocked => {
-            debug!("waking up task for %?", p_);
-            let old_task = swap_task(&mut p.header.blocked_task, ptr::null());
-            if !old_task.is_null() {
-                unsafe {
-                    rustrt::task_signal_event(
-                        old_task,
-                        ptr::addr_of(&(p.header)) as *libc::c_void);
-                    rustrt::rust_task_deref(old_task);
-                }
-            }
-
-            // The receiver will eventually clean this up.
-            //unsafe { forget(p); }
-            return true;
-        }
-        Terminated => {
-            // The receiver will never receive this. Rely on drop_glue
-            // to clean everything up.
-            return false;
-        }
-    }
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn send<T,Tbuffer>(p: SendPacketBuffered<T,Tbuffer>, payload: T) -> bool {
     let header = p.header();
     let p_ = p.unwrap();
@@ -925,44 +777,13 @@ pub fn select<T: Owned, Tb: Owned>(endpoints: ~[RecvPacketBuffered<T, Tb>])
 message.
 
 */
-#[cfg(stage0)]
-pub type SendPacket<T: Owned> = SendPacketBuffered<T, Packet<T>>;
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub type SendPacket<T> = SendPacketBuffered<T, Packet<T>>;
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub fn SendPacket<T: Owned>(p: *Packet<T>) -> SendPacket<T> {
-    SendPacketBuffered(p)
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn SendPacket<T>(p: *Packet<T>) -> SendPacket<T> {
     SendPacketBuffered(p)
 }
 
-#[cfg(stage0)]
-pub struct SendPacketBuffered<T: Owned, Tbuffer: Owned> {
-    mut p: Option<*Packet<T>>,
-    mut buffer: Option<BufferResource<Tbuffer>>,
-    drop {
-        //if self.p != none {
-        //    debug!("drop send %?", option::get(self.p));
-        //}
-        if self.p != None {
-            let mut p = None;
-            p <-> self.p;
-            sender_terminate(option::unwrap(move p))
-        }
-        //unsafe { error!("send_drop: %?",
-        //                if self.buffer == none {
-        //                    "none"
-        //                } else { "some" }); }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub struct SendPacketBuffered<T, Tbuffer> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
@@ -985,20 +806,6 @@ impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> : ::ops::Drop {
     }
 }
 
-#[cfg(stage0)]
-pub fn SendPacketBuffered<T: Owned, Tbuffer: Owned>(p: *Packet<T>)
-    -> SendPacketBuffered<T, Tbuffer> {
-        //debug!("take send %?", p);
-    SendPacketBuffered {
-        p: Some(p),
-        buffer: unsafe {
-            Some(BufferResource(
-                get_buffer(ptr::addr_of(&((*p).header)))))
-        }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn SendPacketBuffered<T,Tbuffer>(p: *Packet<T>)
     -> SendPacketBuffered<T, Tbuffer> {
         //debug!("take send %?", p);
@@ -1011,35 +818,6 @@ pub fn SendPacketBuffered<T,Tbuffer>(p: *Packet<T>)
     }
 }
 
-#[cfg(stage0)]
-impl<T:Owned,Tbuffer:Owned> SendPacketBuffered<T,Tbuffer> {
-    fn unwrap() -> *Packet<T> {
-        let mut p = None;
-        p <-> self.p;
-        option::unwrap(move p)
-    }
-
-    pure fn header() -> *PacketHeader {
-        match self.p {
-          Some(packet) => unsafe {
-            let packet = &*packet;
-            let header = ptr::addr_of(&(packet.header));
-            //forget(packet);
-            header
-          },
-          None => fail ~"packet already consumed"
-        }
-    }
-
-    fn reuse_buffer() -> BufferResource<Tbuffer> {
-        //error!("send reuse_buffer");
-        let mut tmp = None;
-        tmp <-> self.buffer;
-        option::unwrap(move tmp)
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
     fn unwrap() -> *Packet<T> {
         let mut p = None;
@@ -1069,45 +847,12 @@ impl<T,Tbuffer> SendPacketBuffered<T,Tbuffer> {
 
 /// Represents the receive end of a pipe. It can receive exactly one
 /// message.
-#[cfg(stage0)]
-pub type RecvPacket<T: Owned> = RecvPacketBuffered<T, Packet<T>>;
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub type RecvPacket<T> = RecvPacketBuffered<T, Packet<T>>;
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub fn RecvPacket<T: Owned>(p: *Packet<T>) -> RecvPacket<T> {
-    RecvPacketBuffered(p)
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn RecvPacket<T>(p: *Packet<T>) -> RecvPacket<T> {
     RecvPacketBuffered(p)
 }
-
-#[cfg(stage0)]
-pub struct RecvPacketBuffered<T: Owned, Tbuffer: Owned> {
-    mut p: Option<*Packet<T>>,
-    mut buffer: Option<BufferResource<Tbuffer>>,
-    drop {
-        //if self.p != none {
-        //    debug!("drop recv %?", option::get(self.p));
-        //}
-        if self.p != None {
-            let mut p = None;
-            p <-> self.p;
-            receiver_terminate(option::unwrap(move p))
-        }
-        //unsafe { error!("recv_drop: %?",
-        //                if self.buffer == none {
-        //                    "none"
-        //                } else { "some" }); }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub struct RecvPacketBuffered<T, Tbuffer> {
     mut p: Option<*Packet<T>>,
     mut buffer: Option<BufferResource<Tbuffer>>,
@@ -1159,20 +904,6 @@ impl<T: Owned, Tbuffer: Owned> RecvPacketBuffered<T, Tbuffer> : Selectable {
     }
 }
 
-#[cfg(stage0)]
-pub fn RecvPacketBuffered<T: Owned, Tbuffer: Owned>(p: *Packet<T>)
-    -> RecvPacketBuffered<T, Tbuffer> {
-    //debug!("take recv %?", p);
-    RecvPacketBuffered {
-        p: Some(p),
-        buffer: unsafe {
-            Some(BufferResource(
-                get_buffer(ptr::addr_of(&((*p).header)))))
-        }
-    }
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn RecvPacketBuffered<T,Tbuffer>(p: *Packet<T>)
     -> RecvPacketBuffered<T,Tbuffer> {
     //debug!("take recv %?", p);
@@ -1186,14 +917,6 @@ pub fn RecvPacketBuffered<T,Tbuffer>(p: *Packet<T>)
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-pub fn entangle<T: Owned>() -> (SendPacket<T>, RecvPacket<T>) {
-    let p = packet();
-    (SendPacket(p), RecvPacket(p))
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub fn entangle<T>() -> (SendPacket<T>, RecvPacket<T>) {
     let p = packet();
     (SendPacket(p), RecvPacket(p))
@@ -1289,47 +1012,21 @@ pub trait Peekable<T> {
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-struct Chan_<T:Owned> {
-    mut endp: Option<streamp::client::Open<T>>
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 struct Chan_<T> {
     mut endp: Option<streamp::client::Open<T>>
 }
 
 /// An endpoint that can send many messages.
-#[cfg(stage0)]
-pub enum Chan<T:Owned> {
-    Chan_(Chan_<T>)
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub enum Chan<T> {
     Chan_(Chan_<T>)
 }
 
 #[doc(hidden)]
-#[cfg(stage0)]
-struct Port_<T:Owned> {
-    mut endp: Option<streamp::server::Open<T>>,
-}
-#[doc(hidden)]
-#[cfg(stage1)]
-#[cfg(stage2)]
 struct Port_<T> {
     mut endp: Option<streamp::server::Open<T>>,
 }
 
 /// An endpoint that can receive many messages.
-#[cfg(stage0)]
-pub enum Port<T:Owned> {
-    Port_(Port_<T>)
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub enum Port<T> {
     Port_(Port_<T>)
 }
@@ -1418,12 +1115,6 @@ impl<T: Owned> Port<T>: Selectable {
 }
 
 /// Treat many ports as one.
-#[cfg(stage0)]
-pub struct PortSet<T: Owned> {
-    mut ports: ~[pipes::Port<T>],
-}
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub struct PortSet<T> {
     mut ports: ~[pipes::Port<T>],
 }
@@ -1489,10 +1180,6 @@ impl<T: Owned> PortSet<T> : Peekable<T> {
 }
 
 /// A channel that can be shared between many senders.
-#[cfg(stage0)]
-pub type SharedChan<T: Owned> = private::Exclusive<Chan<T>>;
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub type SharedChan<T> = private::Exclusive<Chan<T>>;
 
 impl<T: Owned> SharedChan<T>: GenericChan<T> {
@@ -1561,16 +1248,8 @@ proto! oneshot (
 )
 
 /// The send end of a oneshot pipe.
-#[cfg(stage0)]
-pub type ChanOne<T: Owned> = oneshot::client::Oneshot<T>;
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub type ChanOne<T> = oneshot::client::Oneshot<T>;
 /// The receive end of a oneshot pipe.
-#[cfg(stage0)]
-pub type PortOne<T: Owned> = oneshot::server::Oneshot<T>;
-#[cfg(stage1)]
-#[cfg(stage2)]
 pub type PortOne<T> = oneshot::server::Oneshot<T>;
 
 /// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
diff --git a/src/libcore/reflect.rs b/src/libcore/reflect.rs
index 94fc9e37a751..dcbb70676704 100644
--- a/src/libcore/reflect.rs
+++ b/src/libcore/reflect.rs
@@ -75,434 +75,6 @@ impl<V: TyVisitor MovePtr> MovePtrAdaptor<V> {
 }
 
 /// Abstract type-directed pointer-movement using the MovePtr trait
-#[cfg(stage0)]
-impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
-    fn visit_bot() -> bool {
-        self.align_to::<()>();
-        if ! self.inner.visit_bot() { return false; }
-        self.bump_past::<()>();
-        true
-    }
-
-    fn visit_nil() -> bool {
-        self.align_to::<()>();
-        if ! self.inner.visit_nil() { return false; }
-        self.bump_past::<()>();
-        true
-    }
-
-    fn visit_bool() -> bool {
-        self.align_to::<bool>();
-        if ! self.inner.visit_bool() { return false; }
-        self.bump_past::<bool>();
-        true
-    }
-
-    fn visit_int() -> bool {
-        self.align_to::<int>();
-        if ! self.inner.visit_int() { return false; }
-        self.bump_past::<int>();
-        true
-    }
-
-    fn visit_i8() -> bool {
-        self.align_to::<i8>();
-        if ! self.inner.visit_i8() { return false; }
-        self.bump_past::<i8>();
-        true
-    }
-
-    fn visit_i16() -> bool {
-        self.align_to::<i16>();
-        if ! self.inner.visit_i16() { return false; }
-        self.bump_past::<i16>();
-        true
-    }
-
-    fn visit_i32() -> bool {
-        self.align_to::<i32>();
-        if ! self.inner.visit_i32() { return false; }
-        self.bump_past::<i32>();
-        true
-    }
-
-    fn visit_i64() -> bool {
-        self.align_to::<i64>();
-        if ! self.inner.visit_i64() { return false; }
-        self.bump_past::<i64>();
-        true
-    }
-
-    fn visit_uint() -> bool {
-        self.align_to::<uint>();
-        if ! self.inner.visit_uint() { return false; }
-        self.bump_past::<uint>();
-        true
-    }
-
-    fn visit_u8() -> bool {
-        self.align_to::<u8>();
-        if ! self.inner.visit_u8() { return false; }
-        self.bump_past::<u8>();
-        true
-    }
-
-    fn visit_u16() -> bool {
-        self.align_to::<u16>();
-        if ! self.inner.visit_u16() { return false; }
-        self.bump_past::<u16>();
-        true
-    }
-
-    fn visit_u32() -> bool {
-        self.align_to::<u32>();
-        if ! self.inner.visit_u32() { return false; }
-        self.bump_past::<u32>();
-        true
-    }
-
-    fn visit_u64() -> bool {
-        self.align_to::<u64>();
-        if ! self.inner.visit_u64() { return false; }
-        self.bump_past::<u64>();
-        true
-    }
-
-    fn visit_float() -> bool {
-        self.align_to::<float>();
-        if ! self.inner.visit_float() { return false; }
-        self.bump_past::<float>();
-        true
-    }
-
-    fn visit_f32() -> bool {
-        self.align_to::<f32>();
-        if ! self.inner.visit_f32() { return false; }
-        self.bump_past::<f32>();
-        true
-    }
-
-    fn visit_f64() -> bool {
-        self.align_to::<f64>();
-        if ! self.inner.visit_f64() { return false; }
-        self.bump_past::<f64>();
-        true
-    }
-
-    fn visit_char() -> bool {
-        self.align_to::<char>();
-        if ! self.inner.visit_char() { return false; }
-        self.bump_past::<char>();
-        true
-    }
-
-    fn visit_str() -> bool {
-        self.align_to::<~str>();
-        if ! self.inner.visit_str() { return false; }
-        self.bump_past::<~str>();
-        true
-    }
-
-    fn visit_estr_box() -> bool {
-        self.align_to::<@str>();
-        if ! self.inner.visit_estr_box() { return false; }
-        self.bump_past::<@str>();
-        true
-    }
-
-    fn visit_estr_uniq() -> bool {
-        self.align_to::<~str>();
-        if ! self.inner.visit_estr_uniq() { return false; }
-        self.bump_past::<~str>();
-        true
-    }
-
-    fn visit_estr_slice() -> bool {
-        self.align_to::<&static/str>();
-        if ! self.inner.visit_estr_slice() { return false; }
-        self.bump_past::<&static/str>();
-        true
-    }
-
-    fn visit_estr_fixed(n: uint,
-                        sz: uint,
-                        align: uint) -> bool {
-        self.align(align);
-        if ! self.inner.visit_estr_fixed(n, sz, align) { return false; }
-        self.bump(sz);
-        true
-    }
-
-    fn visit_box(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<@u8>();
-        if ! self.inner.visit_box(mtbl, inner) { return false; }
-        self.bump_past::<@u8>();
-        true
-    }
-
-    fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<~u8>();
-        if ! self.inner.visit_uniq(mtbl, inner) { return false; }
-        self.bump_past::<~u8>();
-        true
-    }
-
-    fn visit_ptr(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<*u8>();
-        if ! self.inner.visit_ptr(mtbl, inner) { return false; }
-        self.bump_past::<*u8>();
-        true
-    }
-
-    fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<&static/u8>();
-        if ! self.inner.visit_rptr(mtbl, inner) { return false; }
-        self.bump_past::<&static/u8>();
-        true
-    }
-
-    fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<vec::UnboxedVecRepr>();
-        if ! self.inner.visit_vec(mtbl, inner) { return false; }
-        true
-    }
-
-    fn visit_vec(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<~[u8]>();
-        if ! self.inner.visit_vec(mtbl, inner) { return false; }
-        self.bump_past::<~[u8]>();
-        true
-    }
-
-    fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<@[u8]>();
-        if ! self.inner.visit_evec_box(mtbl, inner) { return false; }
-        self.bump_past::<@[u8]>();
-        true
-    }
-
-    fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<~[u8]>();
-        if ! self.inner.visit_evec_uniq(mtbl, inner) { return false; }
-        self.bump_past::<~[u8]>();
-        true
-    }
-
-    fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool {
-        self.align_to::<&static/[u8]>();
-        if ! self.inner.visit_evec_slice(mtbl, inner) { return false; }
-        self.bump_past::<&static/[u8]>();
-        true
-    }
-
-    fn visit_evec_fixed(n: uint, sz: uint, align: uint,
-                        mtbl: uint, inner: *TyDesc) -> bool {
-        self.align(align);
-        if ! self.inner.visit_evec_fixed(n, sz, align, mtbl, inner) {
-            return false;
-        }
-        self.bump(sz);
-        true
-    }
-
-    fn visit_enter_rec(n_fields: uint, sz: uint, align: uint) -> bool {
-        self.align(align);
-        if ! self.inner.visit_enter_rec(n_fields, sz, align) { return false; }
-        true
-    }
-
-    fn visit_rec_field(i: uint, name: &str,
-                       mtbl: uint, inner: *TyDesc) -> bool {
-        unsafe { self.align((*inner).align); }
-        if ! self.inner.visit_rec_field(i, name, mtbl, inner) {
-            return false;
-        }
-        unsafe { self.bump((*inner).size); }
-        true
-    }
-
-    fn visit_leave_rec(n_fields: uint, sz: uint, align: uint) -> bool {
-        if ! self.inner.visit_leave_rec(n_fields, sz, align) { return false; }
-        true
-    }
-
-    fn visit_enter_class(n_fields: uint, sz: uint, align: uint)
-                      -> bool {
-        self.align(align);
-        if ! self.inner.visit_enter_class(n_fields, sz, align) {
-            return false;
-        }
-        true
-    }
-
-    fn visit_class_field(i: uint, name: &str,
-                         mtbl: uint, inner: *TyDesc) -> bool {
-        unsafe { self.align((*inner).align); }
-        if ! self.inner.visit_class_field(i, name, mtbl, inner) {
-            return false;
-        }
-        unsafe { self.bump((*inner).size); }
-        true
-    }
-
-    fn visit_leave_class(n_fields: uint, sz: uint, align: uint)
-                      -> bool {
-        if ! self.inner.visit_leave_class(n_fields, sz, align) {
-            return false;
-        }
-        true
-    }
-
-    fn visit_enter_tup(n_fields: uint, sz: uint, align: uint) -> bool {
-        self.align(align);
-        if ! self.inner.visit_enter_tup(n_fields, sz, align) { return false; }
-        true
-    }
-
-    fn visit_tup_field(i: uint, inner: *TyDesc) -> bool {
-        unsafe { self.align((*inner).align); }
-        if ! self.inner.visit_tup_field(i, inner) { return false; }
-        unsafe { self.bump((*inner).size); }
-        true
-    }
-
-    fn visit_leave_tup(n_fields: uint, sz: uint, align: uint) -> bool {
-        if ! self.inner.visit_leave_tup(n_fields, sz, align) { return false; }
-        true
-    }
-
-    fn visit_enter_fn(purity: uint, proto: uint,
-                      n_inputs: uint, retstyle: uint) -> bool {
-        if ! self.inner.visit_enter_fn(purity, proto, n_inputs, retstyle) {
-            return false
-        }
-        true
-    }
-
-    fn visit_fn_input(i: uint, mode: uint, inner: *TyDesc) -> bool {
-        if ! self.inner.visit_fn_input(i, mode, inner) { return false; }
-        true
-    }
-
-    fn visit_fn_output(retstyle: uint, inner: *TyDesc) -> bool {
-        if ! self.inner.visit_fn_output(retstyle, inner) { return false; }
-        true
-    }
-
-    fn visit_leave_fn(purity: uint, proto: uint,
-                      n_inputs: uint, retstyle: uint) -> bool {
-        if ! self.inner.visit_leave_fn(purity, proto, n_inputs, retstyle) {
-            return false;
-        }
-        true
-    }
-
-    fn visit_enter_enum(n_variants: uint, sz: uint, align: uint)
-                     -> bool {
-        self.align(align);
-        if ! self.inner.visit_enter_enum(n_variants, sz, align) {
-            return false;
-        }
-        true
-    }
-
-    fn visit_enter_enum_variant(variant: uint,
-                                disr_val: int,
-                                n_fields: uint,
-                                name: &str) -> bool {
-        self.inner.push_ptr();
-        if ! self.inner.visit_enter_enum_variant(variant, disr_val,
-                                                 n_fields, name) {
-            return false;
-        }
-        true
-    }
-
-    fn visit_enum_variant_field(i: uint, inner: *TyDesc) -> bool {
-        unsafe { self.align((*inner).align); }
-        if ! self.inner.visit_enum_variant_field(i, inner) { return false; }
-        unsafe { self.bump((*inner).size); }
-        true
-    }
-
-    fn visit_leave_enum_variant(variant: uint,
-                                disr_val: int,
-                                n_fields: uint,
-                                name: &str) -> bool {
-        if ! self.inner.visit_leave_enum_variant(variant, disr_val,
-                                                 n_fields, name) {
-            return false;
-        }
-        self.inner.pop_ptr();
-        true
-    }
-
-    fn visit_leave_enum(n_variants: uint, sz: uint, align: uint)
-                     -> bool {
-        if ! self.inner.visit_leave_enum(n_variants, sz, align) {
-            return false;
-        }
-        self.bump(sz);
-        true
-    }
-
-    fn visit_trait() -> bool {
-        self.align_to::<TyVisitor>();
-        if ! self.inner.visit_trait() { return false; }
-        self.bump_past::<TyVisitor>();
-        true
-    }
-
-    fn visit_var() -> bool {
-        if ! self.inner.visit_var() { return false; }
-        true
-    }
-
-    fn visit_var_integral() -> bool {
-        if ! self.inner.visit_var_integral() { return false; }
-        true
-    }
-
-    fn visit_param(i: uint) -> bool {
-        if ! self.inner.visit_param(i) { return false; }
-        true
-    }
-
-    fn visit_self() -> bool {
-        self.align_to::<&static/u8>();
-        if ! self.inner.visit_self() { return false; }
-        self.align_to::<&static/u8>();
-        true
-    }
-
-    fn visit_type() -> bool {
-        if ! self.inner.visit_type() { return false; }
-        true
-    }
-
-    fn visit_opaque_box() -> bool {
-        self.align_to::<@u8>();
-        if ! self.inner.visit_opaque_box() { return false; }
-        self.bump_past::<@u8>();
-        true
-    }
-
-    fn visit_constr(inner: *TyDesc) -> bool {
-        if ! self.inner.visit_constr(inner) { return false; }
-        true
-    }
-
-    fn visit_closure_ptr(ck: uint) -> bool {
-        self.align_to::<fn@()>();
-        if ! self.inner.visit_closure_ptr(ck) { return false; }
-        self.bump_past::<fn@()>();
-        true
-    }
-}
-
-/// Abstract type-directed pointer-movement using the MovePtr trait
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl<V: TyVisitor MovePtr> MovePtrAdaptor<V>: TyVisitor {
     fn visit_bot(&self) -> bool {
         self.align_to::<()>();
diff --git a/src/libcore/repr.rs b/src/libcore/repr.rs
index 75a572fa4644..cce5cac8683e 100644
--- a/src/libcore/repr.rs
+++ b/src/libcore/repr.rs
@@ -265,303 +265,6 @@ impl ReprVisitor {
 
 }
 
-#[cfg(stage0)]
-impl ReprVisitor : TyVisitor {
-    fn visit_bot() -> bool {
-        self.writer.write_str("!");
-        true
-    }
-    fn visit_nil() -> bool { self.write::<()>() }
-    fn visit_bool() -> bool { self.write::<bool>() }
-    fn visit_int() -> bool { self.write::<int>() }
-    fn visit_i8() -> bool { self.write::<i8>() }
-    fn visit_i16() -> bool { self.write::<i16>() }
-    fn visit_i32() -> bool { self.write::<i32>()  }
-    fn visit_i64() -> bool { self.write::<i64>() }
-
-    fn visit_uint() -> bool { self.write::<uint>() }
-    fn visit_u8() -> bool { self.write::<u8>() }
-    fn visit_u16() -> bool { self.write::<u16>() }
-    fn visit_u32() -> bool { self.write::<u32>() }
-    fn visit_u64() -> bool { self.write::<u64>() }
-
-    fn visit_float() -> bool { self.write::<float>() }
-    fn visit_f32() -> bool { self.write::<f32>() }
-    fn visit_f64() -> bool { self.write::<f64>() }
-
-    fn visit_char() -> bool {
-        do self.get::<char> |&ch| {
-            self.writer.write_char('\'');
-            self.writer.write_escaped_char(ch);
-            self.writer.write_char('\'');
-        }
-    }
-
-    // Type no longer exists, vestigial function.
-    fn visit_str() -> bool { fail; }
-
-    fn visit_estr_box() -> bool {
-        do self.get::<@str> |s| {
-            self.writer.write_char('@');
-            self.write_escaped_slice(*s);
-        }
-    }
-    fn visit_estr_uniq() -> bool {
-        do self.get::<~str> |s| {
-            self.writer.write_char('~');
-            self.write_escaped_slice(*s);
-        }
-    }
-    fn visit_estr_slice() -> bool {
-        do self.get::<&str> |s| {
-            self.write_escaped_slice(*s);
-        }
-    }
-
-    // Type no longer exists, vestigial function.
-    fn visit_estr_fixed(_n: uint, _sz: uint,
-                        _align: uint) -> bool { fail; }
-
-    fn visit_box(mtbl: uint, inner: *TyDesc) -> bool {
-        self.writer.write_char('@');
-        self.write_mut_qualifier(mtbl);
-        do self.get::<&managed::raw::BoxRepr> |b| {
-            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
-            self.visit_ptr_inner(p, inner);
-        }
-    }
-
-    fn visit_uniq(mtbl: uint, inner: *TyDesc) -> bool {
-        self.writer.write_char('~');
-        self.write_mut_qualifier(mtbl);
-        do self.get::<&managed::raw::BoxRepr> |b| {
-            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
-            self.visit_ptr_inner(p, inner);
-        }
-    }
-
-    fn visit_ptr(_mtbl: uint, _inner: *TyDesc) -> bool {
-        do self.get::<*c_void> |p| {
-            self.writer.write_str(fmt!("(0x%x as *())",
-                                       *p as uint));
-        }
-    }
-
-    fn visit_rptr(mtbl: uint, inner: *TyDesc) -> bool {
-        self.writer.write_char('&');
-        self.write_mut_qualifier(mtbl);
-        do self.get::<*c_void> |p| {
-            self.visit_ptr_inner(*p, inner);
-        }
-    }
-
-    // Type no longer exists, vestigial function.
-    fn visit_vec(_mtbl: uint, _inner: *TyDesc) -> bool { fail; }
-
-
-    fn visit_unboxed_vec(mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<vec::UnboxedVecRepr> |b| {
-            self.write_unboxed_vec_repr(mtbl, b, inner);
-        }
-    }
-
-    fn visit_evec_box(mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<&VecRepr> |b| {
-            self.writer.write_char('@');
-            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
-        }
-    }
-
-    fn visit_evec_uniq(mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<&VecRepr> |b| {
-            self.writer.write_char('~');
-            self.write_unboxed_vec_repr(mtbl, &b.unboxed, inner);
-        }
-    }
-
-    fn visit_evec_slice(mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<SliceRepr> |s| {
-            self.writer.write_char('&');
-            self.write_vec_range(mtbl, s.data, s.len, inner);
-        }
-    }
-
-    fn visit_evec_fixed(_n: uint, sz: uint, _align: uint,
-                        mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<u8> |b| {
-            self.write_vec_range(mtbl, ptr::to_unsafe_ptr(b), sz, inner);
-        }
-    }
-
-    fn visit_enter_rec(_n_fields: uint,
-                       _sz: uint, _align: uint) -> bool {
-        self.writer.write_char('{');
-        true
-    }
-
-    fn visit_rec_field(i: uint, name: &str,
-                       mtbl: uint, inner: *TyDesc) -> bool {
-        if i != 0 {
-            self.writer.write_str(", ");
-        }
-        self.write_mut_qualifier(mtbl);
-        self.writer.write_str(name);
-        self.writer.write_str(": ");
-        self.visit_inner(inner);
-        true
-    }
-
-    fn visit_leave_rec(_n_fields: uint,
-                       _sz: uint, _align: uint) -> bool {
-        self.writer.write_char('}');
-        true
-    }
-
-    fn visit_enter_class(_n_fields: uint,
-                         _sz: uint, _align: uint) -> bool {
-        self.writer.write_char('{');
-        true
-    }
-    fn visit_class_field(i: uint, name: &str,
-                         mtbl: uint, inner: *TyDesc) -> bool {
-        if i != 0 {
-            self.writer.write_str(", ");
-        }
-        self.write_mut_qualifier(mtbl);
-        self.writer.write_str(name);
-        self.writer.write_str(": ");
-        self.visit_inner(inner);
-        true
-    }
-    fn visit_leave_class(_n_fields: uint,
-                         _sz: uint, _align: uint) -> bool {
-        self.writer.write_char('}');
-        true
-    }
-
-    fn visit_enter_tup(_n_fields: uint,
-                       _sz: uint, _align: uint) -> bool {
-        self.writer.write_char('(');
-        true
-    }
-    fn visit_tup_field(i: uint, inner: *TyDesc) -> bool {
-        if i != 0 {
-            self.writer.write_str(", ");
-        }
-        self.visit_inner(inner);
-        true
-    }
-    fn visit_leave_tup(_n_fields: uint,
-                       _sz: uint, _align: uint) -> bool {
-        self.writer.write_char(')');
-        true
-    }
-
-    fn visit_enter_enum(n_variants: uint,
-                        _sz: uint, _align: uint) -> bool {
-        if n_variants == 1 {
-            self.var_stk.push(Degenerate)
-        } else {
-            self.var_stk.push(TagMatch)
-        }
-        true
-    }
-    fn visit_enter_enum_variant(_variant: uint,
-                                disr_val: int,
-                                n_fields: uint,
-                                name: &str) -> bool {
-        let mut write = false;
-        match self.var_stk.pop() {
-            Degenerate => {
-                write = true;
-                self.var_stk.push(Degenerate);
-            }
-            TagMatch | TagMismatch => {
-                do self.get::<int>() |t| {
-                    if disr_val == *t {
-                        write = true;
-                        self.var_stk.push(TagMatch);
-                    } else {
-                        self.var_stk.push(TagMismatch);
-                    }
-                };
-                self.bump_past::<int>();
-            }
-        }
-
-        if write {
-            self.writer.write_str(name);
-            if n_fields > 0 {
-                self.writer.write_char('(');
-            }
-        }
-        true
-    }
-    fn visit_enum_variant_field(i: uint, inner: *TyDesc) -> bool {
-        match self.var_stk.last() {
-            Degenerate | TagMatch => {
-                if i != 0 {
-                    self.writer.write_str(", ");
-                }
-                if ! self.visit_inner(inner) {
-                    return false;
-                }
-            }
-            TagMismatch => ()
-        }
-        true
-    }
-    fn visit_leave_enum_variant(_variant: uint,
-                                _disr_val: int,
-                                n_fields: uint,
-                                _name: &str) -> bool {
-        match self.var_stk.last() {
-            Degenerate | TagMatch => {
-                if n_fields > 0 {
-                    self.writer.write_char(')');
-                }
-            }
-            TagMismatch => ()
-        }
-        true
-    }
-    fn visit_leave_enum(_n_variants: uint,
-                        _sz: uint, _align: uint) -> bool {
-        self.var_stk.pop();
-        true
-    }
-
-    fn visit_enter_fn(_purity: uint, _proto: uint,
-                      _n_inputs: uint, _retstyle: uint) -> bool { true }
-    fn visit_fn_input(_i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_fn_output(_retstyle: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_fn(_purity: uint, _proto: uint,
-                      _n_inputs: uint, _retstyle: uint) -> bool { true }
-
-
-    fn visit_trait() -> bool { true }
-    fn visit_var() -> bool { true }
-    fn visit_var_integral() -> bool { true }
-    fn visit_param(_i: uint) -> bool { true }
-    fn visit_self() -> bool { true }
-    fn visit_type() -> bool { true }
-
-    fn visit_opaque_box() -> bool {
-        self.writer.write_char('@');
-        do self.get::<&managed::raw::BoxRepr> |b| {
-            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
-            self.visit_ptr_inner(p, b.header.type_desc);
-        }
-    }
-
-    // Type no longer exists, vestigial function.
-    fn visit_constr(_inner: *TyDesc) -> bool { fail; }
-
-    fn visit_closure_ptr(_ck: uint) -> bool { true }
-}
-
-#[cfg(stage1)]
-#[cfg(stage2)]
 impl ReprVisitor : TyVisitor {
     fn visit_bot(&self) -> bool {
         self.writer.write_str("!");