Merge remote-tracking branch 'mozilla/master' into incoming

Conflicts:
	src/librustc/middle/astencode.rs
	src/librustc/middle/check_const.rs

137 files changed, 2265 insertions, 1572 deletions

diff --git a/Makefile.in b/Makefile.in
index baae56c4f40..fa6c7806581 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -239,29 +239,29 @@ $(foreach target,$(CFG_TARGET_TRIPLES),\
 # Standard library variables
 ######################################################################
 
-STDLIB_CRATE := $(S)src/libstd/core.rc
+STDLIB_CRATE := $(S)src/libstd/std.rs
 STDLIB_INPUTS := $(wildcard $(addprefix $(S)src/libstd/,        \
-                                           core.rc *.rs */*.rs */*/*rs */*/*/*rs))
+                                           *.rs */*.rs */*/*rs */*/*/*rs))
 
 ######################################################################
 # Extra library variables
 ######################################################################
 
-EXTRALIB_CRATE := $(S)src/libextra/std.rc
+EXTRALIB_CRATE := $(S)src/libextra/extra.rs
 EXTRALIB_INPUTS := $(wildcard $(addprefix $(S)src/libextra/,          \
-                                          std.rc *.rs */*.rs))
+                                          *.rs */*.rs))
 
 ######################################################################
 # rustc crate variables
 ######################################################################
 
-COMPILER_CRATE := $(S)src/librustc/rustc.rc
+COMPILER_CRATE := $(S)src/librustc/rustc.rs
 COMPILER_INPUTS := $(wildcard $(addprefix $(S)src/librustc/,      \
-                           rustc.rc *.rs */*.rs */*/*.rs */*/*/*.rs))
+                           *.rs */*.rs */*/*.rs */*/*/*.rs))
 
-LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rc
+LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rs
 LIBSYNTAX_INPUTS := $(wildcard $(addprefix $(S)src/libsyntax/, \
-                            syntax.rc *.rs */*.rs */*/*.rs))
+                           *.rs */*.rs */*/*.rs))
 
 DRIVER_CRATE := $(S)src/driver/driver.rs
 
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 9c61a04930a..9e54622688b 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -1552,13 +1552,6 @@ fn each(v: &[int], op: &fn(v: &int)) {
 }
 ~~~~
 
-As an aside, the reason we pass in a *pointer* to an integer rather
-than the integer itself is that this is how the actual `each()`
-function for vectors works. `vec::each` though is a
-[generic](#generics) function, so must be efficient to use for all
-types. Passing the elements by pointer avoids copying potentially
-large objects.
-
 As a caller, if we use a closure to provide the final operator
 argument, we can write it in a way that has a pleasant, block-like
 structure.
@@ -1616,6 +1609,9 @@ To enable `debug!` logging, set the RUST_LOG environment variable to the name of
 
 ## For loops
 
+> ***Note:*** The closure-based protocol used `for` loop is on the way out. The `for` loop will
+> use iterator objects in the future instead.
+
 The most common way to express iteration in Rust is with a `for`
 loop. Like `do`, `for` is a nice syntax for describing control flow
 with closures.  Additionally, within a `for` loop, `break`, `loop`,
@@ -1640,7 +1636,16 @@ fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
 And using this function to iterate over a vector:
 
 ~~~~
-# use each = std::vec::each;
+# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
+#    let mut n = 0;
+#    while n < v.len() {
+#        if !op(&v[n]) {
+#            return false;
+#        }
+#        n += 1;
+#    }
+#    return true;
+# }
 each([2, 4, 8, 5, 16], |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1656,7 +1661,16 @@ out of the loop, you just write `break`. To skip ahead
 to the next iteration, write `loop`.
 
 ~~~~
-# use each = std::vec::each;
+# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
+#    let mut n = 0;
+#    while n < v.len() {
+#        if !op(&v[n]) {
+#            return false;
+#        }
+#        n += 1;
+#    }
+#    return true;
+# }
 for each([2, 4, 8, 5, 16]) |n| {
     if *n % 2 != 0 {
         println("found odd number!");
@@ -1671,7 +1685,16 @@ normally allowed in closures, in a block that appears as the body of a
 the enclosing function, not just the loop body.
 
 ~~~~
-# use each = std::vec::each;
+# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
+#    let mut n = 0;
+#    while n < v.len() {
+#        if !op(&v[n]) {
+#            return false;
+#        }
+#        n += 1;
+#    }
+#    return true;
+# }
 fn contains(v: &[int], elt: int) -> bool {
     for each(v) |x| {
         if (*x == elt) { return true; }
@@ -1686,7 +1709,16 @@ In these situations it can be convenient to lean on Rust's
 argument patterns to bind `x` to the actual value, not the pointer.
 
 ~~~~
-# use each = std::vec::each;
+# fn each(v: &[int], op: &fn(v: &int) -> bool) -> bool {
+#    let mut n = 0;
+#    while n < v.len() {
+#        if !op(&v[n]) {
+#            return false;
+#        }
+#        n += 1;
+#    }
+#    return true;
+# }
 # fn contains(v: &[int], elt: int) -> bool {
     for each(v) |&x| {
         if (x == elt) { return true; }
@@ -1841,10 +1873,9 @@ vector consisting of the result of applying `function` to each element
 of `vector`:
 
 ~~~~
-# use std::vec;
 fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {
     let mut accumulator = ~[];
-    for vec::each(vector) |element| {
+    for vector.iter().advance |element| {
         accumulator.push(function(element));
     }
     return accumulator;
diff --git a/mk/tools.mk b/mk/tools.mk
index 8319d8d4e48..7b50441b3c7 100644
--- a/mk/tools.mk
+++ b/mk/tools.mk
@@ -12,23 +12,23 @@
 # and host architectures
 
 # The test runner that runs the cfail/rfail/rpass and bxench tests
-COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rc
-COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*rs)
+COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rs
+COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*.rs)
 
 # Rustpkg, the package manager and build system
-RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rc
-RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*rs)
+RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rs
+RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*.rs)
 
 # Rustdoc, the documentation tool
-RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rc
+RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rs
 RUSTDOC_INPUTS := $(wildcard $(S)src/librustdoc/*.rs)
 
 # Rusti, the JIT REPL
-RUSTI_LIB := $(S)src/librusti/rusti.rc
+RUSTI_LIB := $(S)src/librusti/rusti.rs
 RUSTI_INPUTS := $(wildcard $(S)src/librusti/*.rs)
 
 # Rust, the convenience tool
-RUST_LIB := $(S)src/librust/rust.rc
+RUST_LIB := $(S)src/librust/rust.rs
 RUST_INPUTS := $(wildcard $(S)src/librust/*.rs)
 
 # FIXME: These are only built for the host arch. Eventually we'll
diff --git a/src/compiletest/compiletest.rc b/src/compiletest/compiletest.rs
index 527e472b0b7..527e472b0b7 100644
--- a/src/compiletest/compiletest.rc
+++ b/src/compiletest/compiletest.rs
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index fd56031ccf9..3e2f484ee53 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -529,7 +529,7 @@ fn compose_and_run_compiler(
     let extra_link_args = ~[~"-L",
                             aux_output_dir_name(config, testfile).to_str()];
 
-    for vec::each(props.aux_builds) |rel_ab| {
+    for props.aux_builds.iter().advance |rel_ab| {
         let abs_ab = config.aux_base.push_rel(&Path(*rel_ab));
         let aux_args =
             make_compile_args(config, props, ~[~"--lib"] + extra_link_args,
diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index 81bae296e7b..d1fe08b2e87 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -521,6 +521,7 @@ mod tests {
     use core::cell::Cell;
     use core::comm;
     use core::task;
+    use core::uint;
 
     #[test]
     fn manually_share_arc() {
@@ -790,18 +791,20 @@ mod tests {
                 }
                 assert_eq!(*state, 42);
                 *state = 31337;
+                // FIXME: #7372: hits type inference bug with iterators
                 // send to other readers
-                for vec::each(reader_convos) |x| {
-                    match *x {
+                for uint::range(0, reader_convos.len()) |i| {
+                    match reader_convos[i] {
                         (ref rc, _) => rc.send(()),
                     }
                 }
             }
             let read_mode = arc.downgrade(write_mode);
             do (&read_mode).read |state| {
+                // FIXME: #7372: hits type inference bug with iterators
                 // complete handshake with other readers
-                for vec::each(reader_convos) |x| {
-                    match *x {
+                for uint::range(0, reader_convos.len()) |i| {
+                    match reader_convos[i] {
                         (_, ref rp) => rp.recv(),
                     }
                 }
diff --git a/src/libextra/arena.rs b/src/libextra/arena.rs
index 302f1fbeb04..4d37c244b13 100644
--- a/src/libextra/arena.rs
+++ b/src/libextra/arena.rs
@@ -41,30 +41,21 @@ use list::{MutList, MutCons, MutNil};
 use core::at_vec;
 use core::cast::{transmute, transmute_mut, transmute_mut_region};
 use core::cast;
-use core::libc::size_t;
 use core::ptr;
-use core::sys::TypeDesc;
 use core::sys;
 use core::uint;
 use core::vec;
 use core::unstable::intrinsics;
+use core::unstable::intrinsics::{TyDesc};
 
-pub mod rustrt {
-    use core::libc::size_t;
-    use core::sys::TypeDesc;
+#[cfg(not(stage0))]
+use core::unstable::intrinsics::{get_tydesc};
 
-    pub extern {
-        #[rust_stack]
-        unsafe fn rust_call_tydesc_glue(root: *u8,
-                                        tydesc: *TypeDesc,
-                                        field: size_t);
-    }
+#[cfg(stage0)]
+unsafe fn get_tydesc<T>() -> *TyDesc {
+    intrinsics::get_tydesc::<T>() as *TyDesc
 }
 
-// This probably belongs somewhere else. Needs to be kept in sync with
-// changes to glue...
-static tydesc_drop_glue_index: size_t = 3 as size_t;
-
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
 // will always stay at 0.
@@ -125,6 +116,19 @@ fn round_up_to(base: uint, align: uint) -> uint {
     (base + (align - 1)) & !(align - 1)
 }
 
+#[inline]
+#[cfg(not(stage0))]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    // This function should be inlined when stage0 is gone
+    ((*tydesc).drop_glue)(data);
+}
+
+#[inline]
+#[cfg(stage0)]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    ((*tydesc).drop_glue)(0 as **TyDesc, data);
+}
+
 // Walk down a chunk, running the destructors for any objects stored
 // in it.
 unsafe fn destroy_chunk(chunk: &Chunk) {
@@ -137,19 +141,18 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
-        let after_tydesc = idx + sys::size_of::<*TypeDesc>();
+        let after_tydesc = idx + sys::size_of::<*TyDesc>();
 
         let start = round_up_to(after_tydesc, align);
 
         //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b",
         //       start, size, align, is_done);
         if is_done {
-            rustrt::rust_call_tydesc_glue(
-                ptr::offset(buf, start), tydesc, tydesc_drop_glue_index);
+            call_drop_glue(tydesc, ptr::offset(buf, start) as *i8);
         }
 
         // Find where the next tydesc lives
-        idx = round_up_to(start + size, sys::pref_align_of::<*TypeDesc>());
+        idx = round_up_to(start + size, sys::pref_align_of::<*TyDesc>());
     }
 }
 
@@ -158,12 +161,12 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
 // is necessary in order to properly do cleanup if a failure occurs
 // during an initializer.
 #[inline]
-unsafe fn bitpack_tydesc_ptr(p: *TypeDesc, is_done: bool) -> uint {
+unsafe fn bitpack_tydesc_ptr(p: *TyDesc, is_done: bool) -> uint {
     let p_bits: uint = transmute(p);
     p_bits | (is_done as uint)
 }
 #[inline]
-unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
+unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TyDesc, bool) {
     (transmute(p & !1), p & 1 == 1)
 }
 
@@ -203,7 +206,7 @@ impl Arena {
     #[inline]
     fn alloc_pod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
-            let tydesc = sys::get_type_desc::<T>();
+            let tydesc = get_tydesc::<T>();
             let ptr = self.alloc_pod_inner((*tydesc).size, (*tydesc).align);
             let ptr: *mut T = transmute(ptr);
             intrinsics::move_val_init(&mut (*ptr), op());
@@ -231,13 +234,13 @@ impl Arena {
             let head = transmute_mut_region(&mut self.head);
 
             let tydesc_start = head.fill;
-            let after_tydesc = head.fill + sys::size_of::<*TypeDesc>();
+            let after_tydesc = head.fill + sys::size_of::<*TyDesc>();
             let start = round_up_to(after_tydesc, align);
             let end = start + n_bytes;
             if end > at_vec::capacity(head.data) {
                 return self.alloc_nonpod_grow(n_bytes, align);
             }
-            head.fill = round_up_to(end, sys::pref_align_of::<*TypeDesc>());
+            head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>());
 
             //debug!("idx = %u, size = %u, align = %u, fill = %u",
             //       start, n_bytes, align, head.fill);
@@ -250,7 +253,7 @@ impl Arena {
     #[inline]
     fn alloc_nonpod<'a, T>(&'a mut self, op: &fn() -> T) -> &'a T {
         unsafe {
-            let tydesc = sys::get_type_desc::<T>();
+            let tydesc = get_tydesc::<T>();
             let (ty_ptr, ptr) =
                 self.alloc_nonpod_inner((*tydesc).size, (*tydesc).align);
             let ty_ptr: *mut uint = transmute(ty_ptr);
diff --git a/src/libextra/dbg.rs b/src/libextra/dbg.rs
index cbd7cb5e3c0..43c4aecdd27 100644
--- a/src/libextra/dbg.rs
+++ b/src/libextra/dbg.rs
@@ -13,56 +13,62 @@
 #[allow(missing_doc)];
 
 use core::cast::transmute;
-use core::sys;
+#[cfg(stage0)]
+use intrinsic::{get_tydesc};
+#[cfg(not(stage0))]
+use core::unstable::intrinsics::{get_tydesc};
 
 pub mod rustrt {
-    use core::sys;
+    #[cfg(stage0)]
+    use intrinsic::{TyDesc};
+    #[cfg(not(stage0))]
+    use core::unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]
     pub extern {
-        pub unsafe fn debug_tydesc(td: *sys::TypeDesc);
-        pub unsafe fn debug_opaque(td: *sys::TypeDesc, x: *());
-        pub unsafe fn debug_box(td: *sys::TypeDesc, x: *());
-        pub unsafe fn debug_tag(td: *sys::TypeDesc, x: *());
-        pub unsafe fn debug_fn(td: *sys::TypeDesc, x: *());
-        pub unsafe fn debug_ptrcast(td: *sys::TypeDesc, x: *()) -> *();
+        pub unsafe fn debug_tydesc(td: *TyDesc);
+        pub unsafe fn debug_opaque(td: *TyDesc, x: *());
+        pub unsafe fn debug_box(td: *TyDesc, x: *());
+        pub unsafe fn debug_tag(td: *TyDesc, x: *());
+        pub unsafe fn debug_fn(td: *TyDesc, x: *());
+        pub unsafe fn debug_ptrcast(td: *TyDesc, x: *()) -> *();
         pub unsafe fn rust_dbg_breakpoint();
     }
 }
 
 pub fn debug_tydesc<T>() {
     unsafe {
-        rustrt::debug_tydesc(sys::get_type_desc::<T>());
+        rustrt::debug_tydesc(get_tydesc::<T>());
     }
 }
 
 pub fn debug_opaque<T>(x: T) {
     unsafe {
-        rustrt::debug_opaque(sys::get_type_desc::<T>(), transmute(&x));
+        rustrt::debug_opaque(get_tydesc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_box<T>(x: @T) {
     unsafe {
-        rustrt::debug_box(sys::get_type_desc::<T>(), transmute(&x));
+        rustrt::debug_box(get_tydesc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_tag<T>(x: T) {
     unsafe {
-        rustrt::debug_tag(sys::get_type_desc::<T>(), transmute(&x));
+        rustrt::debug_tag(get_tydesc::<T>(), transmute(&x));
     }
 }
 
 pub fn debug_fn<T>(x: T) {
     unsafe {
-        rustrt::debug_fn(sys::get_type_desc::<T>(), transmute(&x));
+        rustrt::debug_fn(get_tydesc::<T>(), transmute(&x));
     }
 }
 
 pub unsafe fn ptr_cast<T, U>(x: @T) -> @U {
     transmute(
-        rustrt::debug_ptrcast(sys::get_type_desc::<T>(), transmute(x)))
+        rustrt::debug_ptrcast(get_tydesc::<T>(), transmute(x)))
 }
 
 /// Triggers a debugger breakpoint
diff --git a/src/libextra/std.rc b/src/libextra/extra.rs
index 11aebdf467f..11aebdf467f 100644
--- a/src/libextra/std.rc
+++ b/src/libextra/extra.rs
diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs
index d97804722f2..9c416550eb7 100644
--- a/src/libextra/getopts.rs
+++ b/src/libextra/getopts.rs
@@ -418,10 +418,11 @@ pub fn opts_str(mm: &Matches, names: &[~str]) -> ~str {
  */
 pub fn opt_strs(mm: &Matches, nm: &str) -> ~[~str] {
     let mut acc: ~[~str] = ~[];
-    for vec::each(opt_vals(mm, nm)) |v| {
+    let r = opt_vals(mm, nm);
+    for r.iter().advance |v| {
         match *v { Val(ref s) => acc.push(copy *s), _ => () }
     }
-    return acc;
+    acc
 }
 
 /// Returns the string argument supplied to a matching option or none
diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index 24c4c5b27c4..15553b035f6 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -1123,7 +1123,7 @@ impl Eq for Json {
                     &Object(ref d1) => {
                         if d0.len() == d1.len() {
                             let mut equal = true;
-                            for d0.each |k, v0| {
+                            for d0.iter().advance |(k, v0)| {
                                 match d1.find(k) {
                                     Some(v1) if v0 == v1 => { },
                                     _ => { equal = false; break }
@@ -1186,12 +1186,12 @@ impl Ord for Json {
                         let mut d1_flat = ~[];
 
                         // FIXME #4430: this is horribly inefficient...
-                        for d0.each |k, v| {
+                        for d0.iter().advance |(k, v)| {
                              d0_flat.push((@copy *k, @copy *v));
                         }
                         d0_flat.qsort();
 
-                        for d1.each |k, v| {
+                        for d1.iter().advance |(k, v)| {
                             d1_flat.push((@copy *k, @copy *v));
                         }
                         d1_flat.qsort();
@@ -1326,7 +1326,7 @@ impl<A:ToJson> ToJson for ~[A] {
 impl<A:ToJson + Copy> ToJson for HashMap<~str, A> {
     fn to_json(&self) -> Json {
         let mut d = HashMap::new();
-        for self.each |key, value| {
+        for self.iter().advance |(key, value)| {
             d.insert(copy *key, value.to_json());
         }
         Object(~d)
diff --git a/src/libextra/net_url.rs b/src/libextra/net_url.rs
index dda4b85df4b..5d3d31fdec4 100644
--- a/src/libextra/net_url.rs
+++ b/src/libextra/net_url.rs
@@ -207,7 +207,7 @@ pub fn encode_form_urlencoded(m: &HashMap<~str, ~[~str]>) -> ~str {
     let mut out = ~"";
     let mut first = true;
 
-    for m.each |key, values| {
+    for m.iter().advance |(key, values)| {
         let key = encode_plus(*key);
 
         for values.iter().advance |value| {
diff --git a/src/libextra/rc.rs b/src/libextra/rc.rs
index b90b0983dc2..555cceb5b44 100644
--- a/src/libextra/rc.rs
+++ b/src/libextra/rc.rs
@@ -70,10 +70,12 @@ impl<T> Rc<T> {
 impl<T> Drop for Rc<T> {
     fn finalize(&self) {
         unsafe {
-            (*self.ptr).count -= 1;
-            if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, intrinsics::uninit());
-                free(self.ptr as *c_void)
+            if self.ptr.is_not_null() {
+                (*self.ptr).count -= 1;
+                if (*self.ptr).count == 0 {
+                    ptr::replace_ptr(self.ptr, intrinsics::uninit());
+                    free(self.ptr as *c_void)
+                }
             }
         }
     }
@@ -220,10 +222,12 @@ impl<T> RcMut<T> {
 impl<T> Drop for RcMut<T> {
     fn finalize(&self) {
         unsafe {
-            (*self.ptr).count -= 1;
-            if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, uninit());
-                free(self.ptr as *c_void)
+            if self.ptr.is_not_null() {
+                (*self.ptr).count -= 1;
+                if (*self.ptr).count == 0 {
+                    ptr::replace_ptr(self.ptr, uninit());
+                    free(self.ptr as *c_void)
+                }
             }
         }
     }
diff --git a/src/libextra/serialize.rs b/src/libextra/serialize.rs
index 34fd7e9f1ec..345b217871c 100644
--- a/src/libextra/serialize.rs
+++ b/src/libextra/serialize.rs
@@ -710,7 +710,7 @@ impl<
     fn encode(&self, e: &mut E) {
         do e.emit_map(self.len()) |e| {
             let mut i = 0;
-            for self.each |key, val| {
+            for self.iter().advance |(key, val)| {
                 e.emit_map_elt_key(i, |e| key.encode(e));
                 e.emit_map_elt_val(i, |e| val.encode(e));
                 i += 1;
@@ -744,7 +744,7 @@ impl<
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
             let mut i = 0;
-            for self.each |e| {
+            for self.iter().advance |e| {
                 s.emit_seq_elt(i, |s| e.encode(s));
                 i += 1;
             }
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 17126f0d32b..1d163922955 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -56,38 +56,6 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         self.find(key).is_some()
     }
 
-    /// Visit all key-value pairs in order
-    fn each<'a>(&'a self, it: &fn(&uint, &'a V) -> bool) -> bool {
-        for uint::range(0, self.v.len()) |i| {
-            match self.v[i] {
-              Some(ref elt) => if !it(&i, elt) { return false; },
-              None => ()
-            }
-        }
-        return true;
-    }
-
-    /// Visit all keys in order
-    fn each_key(&self, blk: &fn(key: &uint) -> bool) -> bool {
-        self.each(|k, _| blk(k))
-    }
-
-    /// Visit all values in order
-    fn each_value<'a>(&'a self, blk: &fn(value: &'a V) -> bool) -> bool {
-        self.each(|_, v| blk(v))
-    }
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, it: &fn(&uint, &mut V) -> bool) -> bool {
-        for uint::range(0, self.v.len()) |i| {
-            match self.v[i] {
-              Some(ref mut elt) => if !it(&i, elt) { return false; },
-              None => ()
-            }
-        }
-        return true;
-    }
-
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &uint) -> Option<&'a V> {
         if *key < self.v.len() {
@@ -156,6 +124,38 @@ impl<V> SmallIntMap<V> {
     /// Create an empty SmallIntMap
     pub fn new() -> SmallIntMap<V> { SmallIntMap{v: ~[]} }
 
+    /// Visit all key-value pairs in order
+    pub fn each<'a>(&'a self, it: &fn(&uint, &'a V) -> bool) -> bool {
+        for uint::range(0, self.v.len()) |i| {
+            match self.v[i] {
+              Some(ref elt) => if !it(&i, elt) { return false; },
+              None => ()
+            }
+        }
+        return true;
+    }
+
+    /// Visit all keys in order
+    pub fn each_key(&self, blk: &fn(key: &uint) -> bool) -> bool {
+        self.each(|k, _| blk(k))
+    }
+
+    /// Visit all values in order
+    pub fn each_value<'a>(&'a self, blk: &fn(value: &'a V) -> bool) -> bool {
+        self.each(|_, v| blk(v))
+    }
+
+    /// Iterate over the map and mutate the contained values
+    pub fn mutate_values(&mut self, it: &fn(&uint, &mut V) -> bool) -> bool {
+        for uint::range(0, self.v.len()) |i| {
+            match self.v[i] {
+              Some(ref mut elt) => if !it(&i, elt) { return false; },
+              None => ()
+            }
+        }
+        return true;
+    }
+
     /// Visit all key-value pairs in reverse order
     pub fn each_reverse<'a>(&'a self, it: &fn(uint, &'a V) -> bool) -> bool {
         for uint::range_rev(self.v.len(), 0) |i| {
diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs
index 6990d35f061..5cb52a7b9df 100644
--- a/src/libextra/sync.rs
+++ b/src/libextra/sync.rs
@@ -1094,7 +1094,8 @@ mod tests {
         };
         assert!(result.is_err());
         // child task must have finished by the time try returns
-        for vec::each(p.recv()) |p| { p.recv(); } // wait on all its siblings
+        let r = p.recv();
+        for r.iter().advance |p| { p.recv(); } // wait on all its siblings
         do m.lock_cond |cond| {
             let woken = cond.broadcast();
             assert_eq!(woken, 0);
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 4929dea9045..fd83fd19916 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -107,26 +107,6 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         self.find(key).is_some()
     }
 
-    /// Visit all key-value pairs in order
-    fn each<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) -> bool {
-        each(&self.root, f)
-    }
-
-    /// Visit all keys in order
-    fn each_key(&self, f: &fn(&K) -> bool) -> bool {
-        self.each(|k, _| f(k))
-    }
-
-    /// Visit all values in order
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool {
-        self.each(|_, v| f(v))
-    }
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool {
-        mutate_values(&mut self.root, f)
-    }
-
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
         let mut current: &'a Option<~TreeNode<K, V>> = &self.root;
@@ -184,6 +164,26 @@ impl<K: TotalOrd, V> TreeMap<K, V> {
     /// Create an empty TreeMap
     pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
 
+    /// Visit all key-value pairs in order
+    pub fn each<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) -> bool {
+        each(&self.root, f)
+    }
+
+    /// Visit all keys in order
+    pub fn each_key(&self, f: &fn(&K) -> bool) -> bool {
+        self.each(|k, _| f(k))
+    }
+
+    /// Visit all values in order
+    pub fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool {
+        self.each(|_, v| f(v))
+    }
+
+    /// Iterate over the map and mutate the contained values
+    pub fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool {
+        mutate_values(&mut self.root, f)
+    }
+
     /// Visit all key-value pairs in reverse order
     pub fn each_reverse<'a>(&'a self, f: &fn(&'a K, &'a V) -> bool) -> bool {
         each_reverse(&self.root, f)
diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs
index ed675bf99e9..a014293f063 100644
--- a/src/libextra/workcache.rs
+++ b/src/libextra/workcache.rs
@@ -146,7 +146,7 @@ impl WorkMap {
 impl<S:Encoder> Encodable<S> for WorkMap {
     fn encode(&self, s: &mut S) {
         let mut d = ~[];
-        for self.each |k, v| {
+        for self.iter().advance |(k, v)| {
             d.push((copy *k, copy *v))
         }
         sort::tim_sort(d);
@@ -320,7 +320,7 @@ impl TPrep for Prep {
     }
 
     fn all_fresh(&self, cat: &str, map: &WorkMap) -> bool {
-        for map.each |k, v| {
+        for map.iter().advance |(k, v)| {
             if ! self.is_fresh(cat, k.kind, k.name, *v) {
                 return false;
             }
diff --git a/src/librust/rust.rc b/src/librust/rust.rs
index 68427745ff5..68427745ff5 100644
--- a/src/librust/rust.rc
+++ b/src/librust/rust.rs
diff --git a/src/librustc/back/abi.rs b/src/librustc/back/abi.rs
index 65db2d4701c..05b6e90c682 100644
--- a/src/librustc/back/abi.rs
+++ b/src/librustc/back/abi.rs
@@ -8,9 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
-
-
 pub static rc_base_field_refcnt: uint = 0u;
 
 pub static task_field_refcnt: uint = 0u;
@@ -49,9 +46,7 @@ pub static tydesc_field_take_glue: uint = 2u;
 pub static tydesc_field_drop_glue: uint = 3u;
 pub static tydesc_field_free_glue: uint = 4u;
 pub static tydesc_field_visit_glue: uint = 5u;
-pub static tydesc_field_shape: uint = 6u;
-pub static tydesc_field_shape_tables: uint = 7u;
-pub static n_tydesc_fields: uint = 8u;
+pub static n_tydesc_fields: uint = 6u;
 
 // The two halves of a closure: code and environment.
 pub static fn_field_code: uint = 0u;
@@ -71,6 +66,4 @@ pub static vec_elt_elems: uint = 2u;
 pub static slice_elt_base: uint = 0u;
 pub static slice_elt_len: uint = 1u;
 
-pub static worst_case_glue_call_args: uint = 7u;
-
 pub static abi_version: uint = 1u;
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 1a7041c0884..fbb273450df 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -206,9 +206,6 @@ pub fn compile_rest(sess: Session,
     let mut crate = crate_opt.unwrap();
 
     let (llcx, llmod, link_meta) = {
-    crate = time(time_passes, ~"intrinsic injection", ||
-                 front::intrinsic_inject::inject_intrinsic(sess, crate));
-
         crate = time(time_passes, ~"extra injection", ||
                      front::std_inject::maybe_inject_libstd_ref(sess, crate));
 
diff --git a/src/librustc/front/intrinsic.rs b/src/librustc/front/intrinsic.rs
deleted file mode 100644
index fcb08180a5e..00000000000
--- a/src/librustc/front/intrinsic.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// NB: this file is include_str!'ed into the compiler, re-parsed
-// and injected into each crate the compiler builds. Keep it small.
-
-pub mod intrinsic {
-    #[allow(missing_doc)];
-
-    pub use intrinsic::rusti::visit_tydesc;
-
-    // FIXME (#3727): remove this when the interface has settled and the
-    // version in sys is no longer present.
-    pub fn get_tydesc<T>() -> *TyDesc {
-        unsafe {
-            rusti::get_tydesc::<T>() as *TyDesc
-        }
-    }
-
-    pub struct TyDesc {
-        size: uint,
-        align: uint
-        // Remaining fields not listed
-    }
-
-    pub enum Opaque { }
-
-    pub trait TyVisitor {
-        fn visit_bot(&self) -> bool;
-        fn visit_nil(&self) -> bool;
-        fn visit_bool(&self) -> bool;
-
-        fn visit_int(&self) -> bool;
-        fn visit_i8(&self) -> bool;
-        fn visit_i16(&self) -> bool;
-        fn visit_i32(&self) -> bool;
-        fn visit_i64(&self) -> bool;
-
-        fn visit_uint(&self) -> bool;
-        fn visit_u8(&self) -> bool;
-        fn visit_u16(&self) -> bool;
-        fn visit_u32(&self) -> bool;
-        fn visit_u64(&self) -> bool;
-
-        fn visit_float(&self) -> bool;
-        fn visit_f32(&self) -> bool;
-        fn visit_f64(&self) -> bool;
-
-        fn visit_char(&self) -> bool;
-        fn visit_str(&self) -> bool;
-
-        fn visit_estr_box(&self) -> bool;
-        fn visit_estr_uniq(&self) -> bool;
-        fn visit_estr_slice(&self) -> bool;
-        fn visit_estr_fixed(&self, n: uint, sz: uint, align: uint) -> bool;
-
-        fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_ptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
-
-        fn visit_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_evec_fixed(&self, n: uint, sz: uint, align: uint,
-                            mtbl: uint, inner: *TyDesc) -> bool;
-
-        fn visit_enter_rec(&self, n_fields: uint,
-                           sz: uint, align: uint) -> bool;
-        fn visit_rec_field(&self, i: uint, name: &str,
-                           mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_rec(&self, n_fields: uint,
-                           sz: uint, align: uint) -> bool;
-
-        fn visit_enter_class(&self, n_fields: uint,
-                             sz: uint, align: uint) -> bool;
-        fn visit_class_field(&self, i: uint, name: &str,
-                             mtbl: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_class(&self, n_fields: uint,
-                             sz: uint, align: uint) -> bool;
-
-        fn visit_enter_tup(&self, n_fields: uint,
-                           sz: uint, align: uint) -> bool;
-        fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_tup(&self, n_fields: uint,
-                           sz: uint, align: uint) -> bool;
-
-        fn visit_enter_enum(&self, n_variants: uint,
-                            get_disr: extern unsafe fn(ptr: *Opaque) -> int,
-                            sz: uint, align: uint) -> bool;
-        fn visit_enter_enum_variant(&self, variant: uint,
-                                    disr_val: int,
-                                    n_fields: uint,
-                                    name: &str) -> bool;
-        fn visit_enum_variant_field(&self, i: uint, offset: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_enum_variant(&self, variant: uint,
-                                    disr_val: int,
-                                    n_fields: uint,
-                                    name: &str) -> bool;
-        fn visit_leave_enum(&self, n_variants: uint,
-                            get_disr: extern unsafe fn(ptr: *Opaque) -> int,
-                            sz: uint, align: uint) -> bool;
-
-        fn visit_enter_fn(&self, purity: uint, proto: uint,
-                          n_inputs: uint, retstyle: uint) -> bool;
-        fn visit_fn_input(&self, i: uint, mode: uint, inner: *TyDesc) -> bool;
-        fn visit_fn_output(&self, retstyle: uint, inner: *TyDesc) -> bool;
-        fn visit_leave_fn(&self, purity: uint, proto: uint,
-                          n_inputs: uint, retstyle: uint) -> bool;
-
-        fn visit_trait(&self) -> bool;
-        fn visit_var(&self) -> bool;
-        fn visit_var_integral(&self) -> bool;
-        fn visit_param(&self, i: uint) -> bool;
-        fn visit_self(&self) -> bool;
-        fn visit_type(&self) -> bool;
-        fn visit_opaque_box(&self) -> bool;
-        fn visit_constr(&self, inner: *TyDesc) -> bool;
-        fn visit_closure_ptr(&self, ck: uint) -> bool;
-    }
-
-    pub mod rusti {
-        use super::{TyDesc, TyVisitor};
-
-        #[abi = "rust-intrinsic"]
-        pub extern "rust-intrinsic" {
-            pub fn get_tydesc<T>() -> *();
-            pub fn visit_tydesc(td: *TyDesc, tv: @TyVisitor);
-        }
-    }
-}
diff --git a/src/librustc/front/intrinsic_inject.rs b/src/librustc/front/intrinsic_inject.rs
deleted file mode 100644
index 0caadc8572e..00000000000
--- a/src/librustc/front/intrinsic_inject.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use core::prelude::*;
-
-use core::vec;
-use driver::session::Session;
-use syntax::parse;
-use syntax::ast;
-use syntax::codemap::spanned;
-
-pub fn inject_intrinsic(sess: Session, crate: @ast::crate) -> @ast::crate {
-    let intrinsic_module = include_str!("intrinsic.rs").to_managed();
-
-    let item = parse::parse_item_from_source_str(@"<intrinsic>",
-                                                 intrinsic_module,
-                                                 /*bad*/copy sess.opts.cfg,
-                                                 ~[],
-                                                 sess.parse_sess);
-    let item =
-        match item {
-          Some(i) => i,
-          None => {
-            sess.fatal("no item found in intrinsic module");
-          }
-        };
-
-    let items = vec::append(~[item], crate.node.module.items);
-
-    @spanned {
-        node: ast::crate_ {
-            module: ast::_mod {
-                items: items,
-                .. /*bad*/copy crate.node.module
-            },
-            .. /*bad*/copy crate.node
-        },
-        .. /*bad*/copy *crate
-    }
-}
diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs
index c6c1ac720e8..b0a955fef8f 100644
--- a/src/librustc/metadata/cstore.rs
+++ b/src/librustc/metadata/cstore.rs
@@ -86,7 +86,7 @@ pub fn have_crate_data(cstore: &CStore, cnum: ast::crate_num) -> bool {
 
 pub fn iter_crate_data(cstore: &CStore,
                        i: &fn(ast::crate_num, @crate_metadata)) {
-    for cstore.metas.each |&k, &v| {
+    for cstore.metas.iter().advance |(&k, &v)| {
         i(k, v);
     }
 }
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 2604028ecdb..d2b939dc0fc 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -35,7 +35,6 @@ use extra::ebml;
 use extra::serialize::Decodable;
 use syntax::ast_map;
 use syntax::attr;
-use syntax::diagnostic::span_handler;
 use syntax::parse::token::{ident_interner, special_idents};
 use syntax::print::pprust;
 use syntax::{ast, ast_util};
@@ -97,7 +96,8 @@ fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
 
 #[deriving(Eq)]
 enum Family {
-    Const,                 // c
+    ImmStatic,             // c
+    MutStatic,             // b
     Fn,                    // f
     UnsafeFn,              // u
     StaticMethod,          // F
@@ -120,7 +120,8 @@ enum Family {
 fn item_family(item: ebml::Doc) -> Family {
     let fam = reader::get_doc(item, tag_items_data_item_family);
     match reader::doc_as_u8(fam) as char {
-      'c' => Const,
+      'c' => ImmStatic,
+      'b' => MutStatic,
       'f' => Fn,
       'u' => UnsafeFn,
       'F' => StaticMethod,
@@ -317,7 +318,8 @@ fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
     -> def_like {
     let fam = item_family(item);
     match fam {
-        Const     => dl_def(ast::def_const(did)),
+        ImmStatic => dl_def(ast::def_static(did, false)),
+        MutStatic => dl_def(ast::def_static(did, true)),
         Struct    => dl_def(ast::def_struct(did)),
         UnsafeFn  => dl_def(ast::def_fn(did, ast::unsafe_fn)),
         Fn        => dl_def(ast::def_fn(did, ast::impure_fn)),
@@ -890,8 +892,8 @@ pub fn get_item_visibility(cdata: cmd, id: ast::node_id)
 
 fn family_has_type_params(fam: Family) -> bool {
     match fam {
-      Const | ForeignType | Mod | ForeignMod | PublicField | PrivateField
-      | ForeignFn => false,
+      ImmStatic | ForeignType | Mod | ForeignMod | PublicField | PrivateField
+      | ForeignFn | MutStatic => false,
       _           => true
     }
 }
@@ -921,7 +923,8 @@ fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
 
 fn item_family_to_str(fam: Family) -> ~str {
     match fam {
-      Const => ~"const",
+      ImmStatic => ~"static",
+      MutStatic => ~"static mut",
       Fn => ~"fn",
       UnsafeFn => ~"unsafe fn",
       StaticMethod => ~"static method",
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 9480a509b90..f6d620df80a 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -731,8 +731,8 @@ fn encode_info_for_method(ecx: &EncodeContext,
     }
 
     let mut combined_ty_params = opt_vec::Empty;
-    for owner_generics.ty_params.each |x| { combined_ty_params.push(copy *x) }
-    for method_generics.ty_params.each |x| { combined_ty_params.push(copy *x) }
+    for owner_generics.ty_params.iter().advance |x| { combined_ty_params.push(copy *x) }
+    for method_generics.ty_params.iter().advance |x| { combined_ty_params.push(copy *x) }
     let len = combined_ty_params.len();
     encode_type_param_bounds(ebml_w, ecx, &combined_ty_params);
 
@@ -783,7 +783,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
     let must_write =
         match item.node {
           item_enum(_, _) | item_impl(*) | item_trait(*) | item_struct(*) |
-          item_mod(*) | item_foreign_mod(*) | item_const(*) => true,
+          item_mod(*) | item_foreign_mod(*) | item_static(*) => true,
           _ => false
         };
     if !must_write && !reachable(ecx, item.id) { return; }
@@ -798,11 +798,15 @@ fn encode_info_for_item(ecx: &EncodeContext,
            ecx.tcx.sess.codemap.span_to_str(item.span));
 
     match item.node {
-      item_const(_, _) => {
+      item_static(_, m, _) => {
         add_to_index();
         ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
-        encode_family(ebml_w, 'c');
+        if m == ast::m_mutbl {
+            encode_family(ebml_w, 'b');
+        } else {
+            encode_family(ebml_w, 'c');
+        }
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_symbol(ecx, ebml_w, item.id);
         encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
@@ -1105,9 +1109,13 @@ fn encode_info_for_foreign_item(ecx: &EncodeContext,
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
       }
-      foreign_item_const(*) => {
+      foreign_item_static(_, mutbl) => {
         encode_def_id(ebml_w, local_def(nitem.id));
-        encode_family(ebml_w, 'c');
+        if mutbl {
+            encode_family(ebml_w, 'b');
+        } else {
+            encode_family(ebml_w, 'c');
+        }
         encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id));
         encode_symbol(ecx, ebml_w, nitem.id);
         encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index d405dc0bc20..fb8238b84d6 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -373,7 +373,7 @@ impl tr for ast::def {
           ast::def_self(nid, i) => ast::def_self(xcx.tr_id(nid), i),
           ast::def_mod(did) => ast::def_mod(did.tr(xcx)),
           ast::def_foreign_mod(did) => ast::def_foreign_mod(did.tr(xcx)),
-          ast::def_const(did) => ast::def_const(did.tr(xcx)),
+          ast::def_static(did, m) => ast::def_static(did.tr(xcx), m),
           ast::def_arg(nid, b) => ast::def_arg(xcx.tr_id(nid), b),
           ast::def_local(nid, b) => ast::def_local(xcx.tr_id(nid), b),
           ast::def_variant(e_did, v_did) => {
diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs
index 3f020a5b3a6..2fa25b10f60 100644
--- a/src/librustc/middle/check_const.rs
+++ b/src/librustc/middle/check_const.rs
@@ -43,7 +43,7 @@ pub fn check_item(sess: Session,
                   (_is_const, v): (bool,
                                    visit::vt<bool>)) {
     match it.node {
-      item_const(_, ex) => {
+      item_static(_, _, ex) => {
         (v.visit_expr)(ex, (true, v));
         check_item_recursion(sess, ast_map, def_map, it);
       }
@@ -124,7 +124,7 @@ pub fn check_expr(sess: Session,
                              items without type parameters");
             }
             match def_map.find(&e.id) {
-              Some(&def_const(_)) |
+              Some(&def_static(*)) |
               Some(&def_fn(_, _)) |
               Some(&def_variant(_, _)) |
               Some(&def_struct(_)) => { }
@@ -236,7 +236,7 @@ pub fn check_item_recursion(sess: Session,
     fn visit_expr(e: @expr, (env, v): (env, visit::vt<env>)) {
         match e.node {
             expr_path(*) => match env.def_map.find(&e.id) {
-                Some(&def_const(def_id)) if ast_util::is_local(def_id) =>
+                Some(&def_static(def_id, _)) if ast_util::is_local(def_id) =>
                     match env.ast_map.get_copy(&def_id.node) {
                         ast_map::node_item(it, _) => {
                             (v.visit_item)(it, (env, v));
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index a2532405870..b4c8a6b19c2 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -304,7 +304,7 @@ pub fn pat_ctor_id(cx: @MatchCheckCtxt, p: @pat) -> Option<ctor> {
       pat_ident(_, _, _) | pat_enum(_, _) => {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&def_variant(_, id)) => Some(variant(id)),
-          Some(&def_const(did)) => {
+          Some(&def_static(did, false)) => {
             let const_expr = lookup_const_by_id(cx.tcx, did).get();
             Some(val(eval_const_expr(cx.tcx, const_expr)))
           }
@@ -339,7 +339,7 @@ pub fn is_wild(cx: @MatchCheckCtxt, p: @pat) -> bool {
       pat_wild => { true }
       pat_ident(_, _, _) => {
         match cx.tcx.def_map.find(&pat.id) {
-          Some(&def_variant(_, _)) | Some(&def_const(*)) => { false }
+          Some(&def_variant(_, _)) | Some(&def_static(*)) => { false }
           _ => { true }
         }
       }
@@ -499,7 +499,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
                             None
                         }
                     }
-                    Some(&def_const(did)) => {
+                    Some(&def_static(did, _)) => {
                         let const_expr =
                             lookup_const_by_id(cx.tcx, did).get();
                         let e_v = eval_const_expr(cx.tcx, const_expr);
@@ -549,7 +549,7 @@ pub fn specialize(cx: @MatchCheckCtxt,
             }
             pat_enum(_, args) => {
                 match cx.tcx.def_map.get_copy(&pat_id) {
-                    def_const(did) => {
+                    def_static(did, _) => {
                         let const_expr =
                             lookup_const_by_id(cx.tcx, did).get();
                         let e_v = eval_const_expr(cx.tcx, const_expr);
@@ -790,7 +790,7 @@ pub fn is_refutable(cx: @MatchCheckCtxt, pat: &pat) -> bool {
             return true;
         }
       }
-      Some(&def_const(*)) => return true,
+      Some(&def_static(*)) => return true,
       _ => ()
     }
 
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index 78bc59c5647..299d71b2567 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -166,7 +166,7 @@ pub fn classify(e: @expr,
 
 pub fn lookup_const(tcx: ty::ctxt, e: @expr) -> Option<@expr> {
     match tcx.def_map.find(&e.id) {
-        Some(&ast::def_const(def_id)) => lookup_const_by_id(tcx, def_id),
+        Some(&ast::def_static(def_id, false)) => lookup_const_by_id(tcx, def_id),
         _ => None
     }
 }
@@ -178,7 +178,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
         match tcx.items.find(&def_id.node) {
             None => None,
             Some(&ast_map::node_item(it, _)) => match it.node {
-                item_const(_, const_expr) => Some(const_expr),
+                item_static(_, ast::m_imm, const_expr) => Some(const_expr),
                 _ => None
             },
             Some(_) => None
@@ -195,7 +195,7 @@ pub fn lookup_const_by_id(tcx: ty::ctxt,
         match csearch::maybe_get_item_ast(tcx, def_id,
             |a, b, c, d| astencode::decode_inlined_item(a, b, maps, /*bar*/ copy c, d)) {
             csearch::found(ast::ii_item(item)) => match item.node {
-                item_const(_, const_expr) => Some(const_expr),
+                item_static(_, ast::m_imm, const_expr) => Some(const_expr),
                 _ => None
             },
             _ => None
diff --git a/src/librustc/middle/effect.rs b/src/librustc/middle/effect.rs
index d9481c26dad..513b2015a83 100644
--- a/src/librustc/middle/effect.rs
+++ b/src/librustc/middle/effect.rs
@@ -17,7 +17,7 @@ use middle::typeck::method_map;
 use util::ppaux;
 
 use syntax::ast::{deref, expr_call, expr_inline_asm, expr_method_call};
-use syntax::ast::{expr_unary, node_id, unsafe_blk, unsafe_fn};
+use syntax::ast::{expr_unary, node_id, unsafe_blk, unsafe_fn, expr_path};
 use syntax::ast;
 use syntax::codemap::span;
 use syntax::visit::{fk_item_fn, fk_method};
@@ -143,6 +143,14 @@ pub fn check_crate(tcx: ty::ctxt,
                 expr_inline_asm(*) => {
                     require_unsafe(expr.span, "use of inline assembly")
                 }
+                expr_path(*) => {
+                    match ty::resolve_expr(tcx, expr) {
+                        ast::def_static(_, true) => {
+                            require_unsafe(expr.span, "use of mutable static")
+                        }
+                        _ => {}
+                    }
+                }
                 _ => {}
             }
 
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index 7f7a81fa974..b0b2a16cf89 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -240,7 +240,8 @@ fn check_fn(
 
     // Check kinds on free variables:
     do with_appropriate_checker(cx, fn_id) |chk| {
-        for vec::each(*freevars::get_freevars(cx.tcx, fn_id)) |fv| {
+        let r = freevars::get_freevars(cx.tcx, fn_id);
+        for r.iter().advance |fv| {
             chk(cx, *fv);
         }
     }
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index 3a8d369469b..9d4064e99bd 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -76,16 +76,20 @@ pub enum LangItem {
     UnrecordBorrowFnLangItem,   // 36
 
     StartFnLangItem,            // 37
+
+    TyDescStructLangItem,       // 38
+    TyVisitorTraitLangItem,     // 39
+    OpaqueStructLangItem,       // 40
 }
 
 pub struct LanguageItems {
-    items: [Option<def_id>, ..38]
+    items: [Option<def_id>, ..41]
 }
 
 impl LanguageItems {
     pub fn new() -> LanguageItems {
         LanguageItems {
-            items: [ None, ..38 ]
+            items: [ None, ..41 ]
         }
     }
 
@@ -138,6 +142,10 @@ impl LanguageItems {
 
             37 => "start",
 
+            38 => "ty_desc",
+            39 => "ty_visitor",
+            40 => "opaque",
+
             _ => "???"
         }
     }
@@ -262,6 +270,15 @@ impl LanguageItems {
     pub fn start_fn(&const self) -> def_id {
         self.items[StartFnLangItem as uint].get()
     }
+    pub fn ty_desc(&const self) -> def_id {
+        self.items[TyDescStructLangItem as uint].get()
+    }
+    pub fn ty_visitor(&const self) -> def_id {
+        self.items[TyVisitorTraitLangItem as uint].get()
+    }
+    pub fn opaque(&const self) -> def_id {
+        self.items[OpaqueStructLangItem as uint].get()
+    }
 }
 
 fn LanguageItemCollector(crate: @crate,
@@ -313,6 +330,9 @@ fn LanguageItemCollector(crate: @crate,
     item_refs.insert(@"record_borrow", RecordBorrowFnLangItem as uint);
     item_refs.insert(@"unrecord_borrow", UnrecordBorrowFnLangItem as uint);
     item_refs.insert(@"start", StartFnLangItem as uint);
+    item_refs.insert(@"ty_desc", TyDescStructLangItem as uint);
+    item_refs.insert(@"ty_visitor", TyVisitorTraitLangItem as uint);
+    item_refs.insert(@"opaque", OpaqueStructLangItem as uint);
 
     LanguageItemCollector {
         crate: crate,
@@ -416,7 +436,7 @@ impl LanguageItemCollector {
     }
 
     pub fn check_completeness(&self) {
-        for self.item_refs.each |&key, &item_ref| {
+        for self.item_refs.iter().advance |(&key, &item_ref)| {
             match self.items.items[item_ref] {
                 None => {
                     self.session.err(fmt!("no item found for `%s`", key));
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 821aed731c2..6da10b7c277 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -96,6 +96,8 @@ pub enum lint {
 
     missing_doc,
     unreachable_code,
+
+    warnings,
 }
 
 pub fn level_to_str(lv: level) -> &'static str {
@@ -280,6 +282,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "detects unreachable code",
         default: warn
     }),
+
+    ("warnings",
+     LintSpec {
+        lint: warnings,
+        desc: "mass-change the level for lints which produce warnings",
+        default: warn
+    }),
 ];
 
 /*
@@ -352,7 +361,7 @@ impl Context {
     }
 
     fn lint_to_str(&self, lint: lint) -> &'static str {
-        for self.dict.each |k, v| {
+        for self.dict.iter().advance |(k, v)| {
             if v.lint == lint {
                 return *k;
             }
@@ -362,10 +371,11 @@ impl Context {
 
     fn span_lint(&self, lint: lint, span: span, msg: &str) {
         let (level, src) = match self.curr.find(&(lint as uint)) {
+            None => { return }
+            Some(&(warn, src)) => (self.get_level(warnings), src),
             Some(&pair) => pair,
-            None => { return; }
         };
-        if level == allow { return; }
+        if level == allow { return }
 
         let mut note = None;
         let msg = match src {
@@ -709,28 +719,32 @@ fn check_item_default_methods(cx: &Context, item: @ast::item) {
 }
 
 fn check_item_ctypes(cx: &Context, it: @ast::item) {
-
-    fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) {
-        let tys = vec::map(decl.inputs, |a| a.ty );
-        for vec::each(vec::append_one(tys, decl.output)) |ty| {
-            match ty.node {
-              ast::ty_path(_, _, id) => {
+    fn check_ty(cx: &Context, ty: @ast::Ty) {
+        match ty.node {
+            ast::ty_path(_, _, id) => {
                 match cx.tcx.def_map.get_copy(&id) {
-                  ast::def_prim_ty(ast::ty_int(ast::ty_i)) => {
-                    cx.span_lint(ctypes, ty.span,
-                        "found rust type `int` in foreign module, while \
-                         libc::c_int or libc::c_long should be used");
-                  }
-                  ast::def_prim_ty(ast::ty_uint(ast::ty_u)) => {
-                    cx.span_lint(ctypes, ty.span,
-                        "found rust type `uint` in foreign module, while \
-                         libc::c_uint or libc::c_ulong should be used");
-                  }
-                  _ => ()
+                    ast::def_prim_ty(ast::ty_int(ast::ty_i)) => {
+                        cx.span_lint(ctypes, ty.span,
+                                "found rust type `int` in foreign module, while \
+                                libc::c_int or libc::c_long should be used");
+                    }
+                    ast::def_prim_ty(ast::ty_uint(ast::ty_u)) => {
+                        cx.span_lint(ctypes, ty.span,
+                                "found rust type `uint` in foreign module, while \
+                                libc::c_uint or libc::c_ulong should be used");
+                    }
+                    _ => ()
                 }
-              }
-              _ => ()
             }
+            _ => ()
+        }
+    }
+
+    fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) {
+        let tys = vec::map(decl.inputs, |a| a.ty );
+        let r = vec::append_one(tys, decl.output);
+        for r.iter().advance |ty| {
+            check_ty(cx, *ty);
         }
     }
 
@@ -738,11 +752,10 @@ fn check_item_ctypes(cx: &Context, it: @ast::item) {
       ast::item_foreign_mod(ref nmod) if !nmod.abis.is_intrinsic() => {
         for nmod.items.iter().advance |ni| {
             match ni.node {
-              ast::foreign_item_fn(ref decl, _, _) => {
-                check_foreign_fn(cx, decl);
-              }
-              // FIXME #4622: Not implemented.
-              ast::foreign_item_const(*) => {}
+                ast::foreign_item_fn(ref decl, _, _) => {
+                    check_foreign_fn(cx, decl);
+                }
+                ast::foreign_item_static(t, _) => { check_ty(cx, t); }
             }
         }
       }
@@ -1159,7 +1172,7 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
 
     // If we missed any lints added to the session, then there's a bug somewhere
     // in the iteration code.
-    for tcx.sess.lints.each |_, v| {
+    for tcx.sess.lints.iter().advance |(_, v)| {
         for v.iter().advance |t| {
             match *t {
                 (lint, span, ref msg) =>
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index 2ced57dc885..f93cb265d78 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -447,19 +447,29 @@ impl mem_categorization_ctxt {
                    -> cmt {
         match def {
           ast::def_fn(*) | ast::def_static_method(*) | ast::def_mod(_) |
-          ast::def_foreign_mod(_) | ast::def_const(_) |
+          ast::def_foreign_mod(_) | ast::def_static(_, false) |
           ast::def_use(_) | ast::def_variant(*) |
           ast::def_trait(_) | ast::def_ty(_) | ast::def_prim_ty(_) |
           ast::def_ty_param(*) | ast::def_struct(*) |
           ast::def_typaram_binder(*) | ast::def_region(_) |
           ast::def_label(_) | ast::def_self_ty(*) => {
-            @cmt_ {
-                id:id,
-                span:span,
-                cat:cat_static_item,
-                mutbl: McImmutable,
-                ty:expr_ty
-            }
+              @cmt_ {
+                  id:id,
+                  span:span,
+                  cat:cat_static_item,
+                  mutbl: McImmutable,
+                  ty:expr_ty
+              }
+          }
+
+          ast::def_static(_, true) => {
+              @cmt_ {
+                  id:id,
+                  span:span,
+                  cat:cat_static_item,
+                  mutbl: McDeclared,
+                  ty:expr_ty
+              }
           }
 
           ast::def_arg(vid, mutbl) => {
@@ -894,7 +904,7 @@ impl mem_categorization_ctxt {
                         self.cat_pattern(cmt_field, subpat, op);
                     }
                 }
-                Some(&ast::def_const(*)) => {
+                Some(&ast::def_static(*)) => {
                     for subpats.iter().advance |&subpat| {
                         self.cat_pattern(cmt, subpat, op);
                     }
diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs
index 1237e9fb4a2..5bd39e85863 100644
--- a/src/librustc/middle/pat_util.rs
+++ b/src/librustc/middle/pat_util.rs
@@ -45,7 +45,7 @@ pub fn pat_is_const(dm: resolve::DefMap, pat: &pat) -> bool {
     match pat.node {
         pat_ident(_, _, None) | pat_enum(*) => {
             match dm.find(&pat.id) {
-                Some(&def_const(*)) => true,
+                Some(&def_static(_, false)) => true,
                 _ => false
             }
         }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 0e6d8617ba4..7d3e895a0ed 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -948,7 +948,7 @@ pub fn determine_rp_in_crate(sess: Session,
     debug!("%s", {
         debug!("Region variance results:");
         let region_paramd_items = cx.region_paramd_items;
-        for region_paramd_items.each |&key, &value| {
+        for region_paramd_items.iter().advance |(&key, &value)| {
             debug!("item %? (%s) is parameterized with variance %?",
                    key,
                    ast_map::node_id_to_str(ast_map, key,
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 562bbca6929..a8626ca89aa 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -101,6 +101,14 @@ pub enum Namespace {
     ValueNS
 }
 
+#[deriving(Eq)]
+pub enum NamespaceError {
+    NoError,
+    ModuleError,
+    TypeError,
+    ValueError
+}
+
 /// A NamespaceResult represents the result of resolving an import in
 /// a particular namespace. The result is either definitely-resolved,
 /// definitely- unresolved, or unknown.
@@ -759,10 +767,12 @@ pub fn PrimitiveTypeTable() -> PrimitiveTypeTable {
 }
 
 
-pub fn namespace_to_str(ns: Namespace) -> ~str {
+pub fn namespace_error_to_str(ns: NamespaceError) -> &'static str {
     match ns {
-        TypeNS  => ~"type",
-        ValueNS => ~"value",
+        NoError     => "",
+        ModuleError => "module",
+        TypeError   => "type",
+        ValueError  => "value",
     }
 }
 
@@ -993,21 +1003,25 @@ impl Resolver {
                 // * If no duplicate checking was requested at all, do
                 //   nothing.
 
-                let mut is_duplicate = false;
+                let mut duplicate_type = NoError;
                 let ns = match duplicate_checking_mode {
                     ForbidDuplicateModules => {
-                        is_duplicate = child.get_module_if_available().is_some();
+                        if (child.get_module_if_available().is_some()) {
+                            duplicate_type = ModuleError;
+                        }
                         Some(TypeNS)
                     }
                     ForbidDuplicateTypes => {
                         match child.def_for_namespace(TypeNS) {
                             Some(def_mod(_)) | None => {}
-                            Some(_) => is_duplicate = true
+                            Some(_) => duplicate_type = TypeError
                         }
                         Some(TypeNS)
                     }
                     ForbidDuplicateValues => {
-                        is_duplicate = child.defined_in_namespace(ValueNS);
+                        if child.defined_in_namespace(ValueNS) {
+                            duplicate_type = ValueError;
+                        }
                         Some(ValueNS)
                     }
                     ForbidDuplicateTypesAndValues => {
@@ -1016,31 +1030,31 @@ impl Resolver {
                             Some(def_mod(_)) | None => {}
                             Some(_) => {
                                 n = Some(TypeNS);
-                                is_duplicate = true;
+                                duplicate_type = TypeError;
                             }
                         };
                         if child.defined_in_namespace(ValueNS) {
-                            is_duplicate = true;
+                            duplicate_type = ValueError;
                             n = Some(ValueNS);
                         }
                         n
                     }
                     OverwriteDuplicates => None
                 };
-                if is_duplicate {
+                if (duplicate_type != NoError) {
                     // Return an error here by looking up the namespace that
                     // had the duplicate.
                     let ns = ns.unwrap();
                     self.session.span_err(sp,
                         fmt!("duplicate definition of %s `%s`",
-                             namespace_to_str(ns),
+                             namespace_error_to_str(duplicate_type),
                              self.session.str_of(name)));
                     {
                         let r = child.span_for_namespace(ns);
                         for r.iter().advance |sp| {
                             self.session.span_note(*sp,
-                                 fmt!("first definition of %s %s here:",
-                                      namespace_to_str(ns),
+                                 fmt!("first definition of %s `%s` here",
+                                      namespace_error_to_str(duplicate_type),
                                       self.session.str_of(name)));
                         }
                     }
@@ -1146,12 +1160,13 @@ impl Resolver {
             }
 
             // These items live in the value namespace.
-            item_const(*) => {
+            item_static(_, m, _) => {
                 let (name_bindings, _) =
                     self.add_child(ident, parent, ForbidDuplicateValues, sp);
+                let mutbl = m == ast::m_mutbl;
 
                 name_bindings.define_value
-                    (privacy, def_const(local_def(item.id)), sp);
+                    (privacy, def_static(local_def(item.id), mutbl), sp);
             }
             item_fn(_, purity, _, _, _) => {
               let (name_bindings, new_parent) =
@@ -1385,7 +1400,7 @@ impl Resolver {
                 }
 
                 let def_id = local_def(item.id);
-                for method_names.each |name, _| {
+                for method_names.iter().advance |(name, _)| {
                     if !self.method_map.contains_key(name) {
                         self.method_map.insert(*name, HashSet::new());
                     }
@@ -1565,8 +1580,8 @@ impl Resolver {
                     visit_foreign_item(foreign_item, (new_parent, visitor));
                 }
             }
-            foreign_item_const(*) => {
-                let def = def_const(local_def(foreign_item.id));
+            foreign_item_static(_, m) => {
+                let def = def_static(local_def(foreign_item.id), m);
                 name_bindings.define_value(Public, def, foreign_item.span);
 
                 visit_foreign_item(foreign_item, (new_parent, visitor));
@@ -1673,7 +1688,7 @@ impl Resolver {
             let privacy = variant_visibility_to_privacy(visibility, true);
             child_name_bindings.define_value(privacy, def, dummy_sp());
           }
-          def_fn(*) | def_static_method(*) | def_const(*) => {
+          def_fn(*) | def_static_method(*) | def_static(*) => {
             debug!("(building reduced graph for external \
                     crate) building value %s", final_ident);
             child_name_bindings.define_value(privacy, def, dummy_sp());
@@ -1703,7 +1718,7 @@ impl Resolver {
                       interned_method_names.insert(method_name);
                   }
               }
-              for interned_method_names.each |name| {
+              for interned_method_names.iter().advance |name| {
                   if !self.method_map.contains_key(name) {
                       self.method_map.insert(*name, HashSet::new());
                   }
@@ -2469,8 +2484,8 @@ impl Resolver {
         assert_eq!(containing_module.glob_count, 0);
 
         // Add all resolved imports from the containing module.
-        for containing_module.import_resolutions.each
-                |ident, target_import_resolution| {
+        for containing_module.import_resolutions.iter().advance
+                |(ident, target_import_resolution)| {
 
             debug!("(resolving glob import) writing module resolution \
                     %? into `%s`",
@@ -2554,13 +2569,13 @@ impl Resolver {
         };
 
         // Add all children from the containing module.
-        for containing_module.children.each |&ident, name_bindings| {
+        for containing_module.children.iter().advance |(&ident, name_bindings)| {
             merge_import_resolution(ident, *name_bindings);
         }
 
         // Add external module children from the containing module.
-        for containing_module.external_module_children.each
-                |&ident, module| {
+        for containing_module.external_module_children.iter().advance
+                |(&ident, module)| {
             let name_bindings =
                 @mut Resolver::create_name_bindings_from_module(*module);
             merge_import_resolution(ident, name_bindings);
@@ -3250,7 +3265,7 @@ impl Resolver {
     pub fn add_exports_for_module(@mut self,
                                   exports2: &mut ~[Export2],
                                   module_: @mut Module) {
-        for module_.children.each |ident, namebindings| {
+        for module_.children.iter().advance |(ident, namebindings)| {
             debug!("(computing exports) maybe export '%s'",
                    self.session.str_of(*ident));
             self.add_exports_of_namebindings(&mut *exports2,
@@ -3265,7 +3280,7 @@ impl Resolver {
                                              false);
         }
 
-        for module_.import_resolutions.each |ident, importresolution| {
+        for module_.import_resolutions.iter().advance |(ident, importresolution)| {
             if importresolution.privacy != Public {
                 debug!("(computing exports) not reexporting private `%s`",
                        self.session.str_of(*ident));
@@ -3664,7 +3679,7 @@ impl Resolver {
                                     || visit_foreign_item(*foreign_item,
                                                           ((), visitor)));
                             }
-                            foreign_item_const(_) => {
+                            foreign_item_static(*) => {
                                 visit_foreign_item(*foreign_item,
                                                    ((), visitor));
                             }
@@ -3686,7 +3701,7 @@ impl Resolver {
                                       visitor);
             }
 
-            item_const(*) => {
+            item_static(*) => {
                 self.with_constant_rib(|| {
                     visit_item(item, ((), visitor));
                 });
@@ -3833,8 +3848,8 @@ impl Resolver {
     pub fn resolve_type_parameters(@mut self,
                                    type_parameters: &OptVec<TyParam>,
                                    visitor: ResolveVisitor) {
-        for type_parameters.each |type_parameter| {
-            for type_parameter.bounds.each |bound| {
+        for type_parameters.iter().advance |type_parameter| {
+            for type_parameter.bounds.iter().advance |bound| {
                 self.resolve_type_parameter_bound(bound, visitor);
             }
         }
@@ -4038,7 +4053,7 @@ impl Resolver {
         for arm.pats.iter().enumerate().advance |(i, p)| {
             let map_i = self.binding_mode_map(*p);
 
-            for map_0.each |&key, &binding_0| {
+            for map_0.iter().advance |(&key, &binding_0)| {
                 match map_i.find(&key) {
                   None => {
                     self.session.span_err(
@@ -4059,7 +4074,7 @@ impl Resolver {
                 }
             }
 
-            for map_i.each |&key, &binding| {
+            for map_i.iter().advance |(&key, &binding)| {
                 if !map_0.contains_key(&key) {
                     self.session.span_err(
                         binding.span,
@@ -4180,13 +4195,13 @@ impl Resolver {
                     }
                 }
 
-                for bounds.each |bound| {
+                for bounds.iter().advance |bound| {
                     self.resolve_type_parameter_bound(bound, visitor);
                 }
             }
 
             ty_closure(c) => {
-                for c.bounds.each |bound| {
+                for c.bounds.iter().advance |bound| {
                     self.resolve_type_parameter_bound(bound, visitor);
                 }
                 visit_ty(ty, ((), visitor));
@@ -4344,7 +4359,7 @@ impl Resolver {
                                 Some(def @ def_struct(*)) => {
                             self.record_def(pattern.id, def);
                         }
-                        Some(def @ def_const(*)) => {
+                        Some(def @ def_static(*)) => {
                             self.enforce_default_binding_mode(
                                 pattern,
                                 binding_mode,
@@ -4376,7 +4391,7 @@ impl Resolver {
                         Some(def @ def_fn(*))      |
                         Some(def @ def_variant(*)) |
                         Some(def @ def_struct(*))  |
-                        Some(def @ def_const(*)) => {
+                        Some(def @ def_static(*)) => {
                             self.record_def(pattern.id, def);
                         }
                         Some(_) => {
@@ -4459,7 +4474,7 @@ impl Resolver {
                             def @ def_variant(*) | def @ def_struct(*) => {
                                 return FoundStructOrEnumVariant(def);
                             }
-                            def @ def_const(*) => {
+                            def @ def_static(_, false) => {
                                 return FoundConst(def);
                             }
                             _ => {
@@ -5354,7 +5369,7 @@ impl Resolver {
         }
 
         debug!("Import resolutions:");
-        for module_.import_resolutions.each |name, import_resolution| {
+        for module_.import_resolutions.iter().advance |(name, import_resolution)| {
             let value_repr;
             match import_resolution.target_for_namespace(ValueNS) {
                 None => { value_repr = ~""; }
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index ab2f0c84d02..63b39b8fe76 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -820,7 +820,7 @@ pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
                         add_to_set(ccx.tcx, &mut found,
                                    lit(UnitLikeStructLit(cur.id)));
                     }
-                    Some(&ast::def_const(const_did)) => {
+                    Some(&ast::def_static(const_did, false)) => {
                         add_to_set(ccx.tcx, &mut found,
                                    lit(ConstLit(const_did)));
                     }
@@ -836,7 +836,7 @@ pub fn get_options(bcx: block, m: &[@Match], col: uint) -> ~[Opt] {
                         add_to_set(ccx.tcx, &mut found,
                                    variant_opt(bcx, cur.id));
                     }
-                    Some(&ast::def_const(const_did)) => {
+                    Some(&ast::def_static(const_did, false)) => {
                         add_to_set(ccx.tcx, &mut found,
                                    lit(ConstLit(const_did)));
                     }
@@ -1673,7 +1673,7 @@ pub fn trans_match_inner(scope_cx: block,
 
     let mut arm_datas = ~[];
     let mut matches = ~[];
-    for vec::each(arms) |arm| {
+    for arms.iter().advance |arm| {
         let body = scope_block(bcx, arm.body.info(), "case_body");
         let bindings_map = create_bindings_map(bcx, arm.pats[0]);
         let arm_data = @ArmData {bodycx: body,
@@ -1831,8 +1831,9 @@ pub fn bind_irrefutable_pat(bcx: block,
                         }
                     }
                 }
-                Some(&ast::def_const(*)) => {
-                    bcx = bind_irrefutable_pat(bcx, pat, val, make_copy, binding_mode);
+                Some(&ast::def_static(_, false)) => {
+                    bcx = bind_irrefutable_pat(bcx, pat, val, make_copy,
+                                               binding_mode);
                 }
                 _ => {
                     // Nothing to do here.
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 624c6607859..9b7c7037f42 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -135,7 +135,7 @@ fn represent_type_uncached(cx: &mut CrateContext, t: ty::t) -> Repr {
                 ty::lookup_field_type(cx.tcx, def_id, field.id, substs)
             };
             let packed = ty::lookup_packed(cx.tcx, def_id);
-            let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
+            let dtor = ty::ty_dtor(cx.tcx, def_id).has_drop_flag();
             let ftys =
                 if dtor { ftys + [ty::mk_bool()] } else { ftys };
             return Univariant(mk_struct(cx, ftys, packed), dtor)
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index ec77fe359b5..5bf0e596ca0 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -2122,14 +2122,19 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
             trans_enum_def(ccx, enum_definition, item.id, vi, &mut i);
         }
       }
-      ast::item_const(_, expr) => {
-          consts::trans_const(ccx, expr, item.id);
+      ast::item_static(_, m, expr) => {
+          consts::trans_const(ccx, m, item.id);
           // Do static_assert checking. It can't really be done much earlier because we need to get
           // the value of the bool out of LLVM
           for item.attrs.iter().advance |attr| {
               match attr.node.value.node {
                   ast::meta_word(x) => {
                       if x.slice(0, x.len()) == "static_assert" {
+                          if m == ast::m_mutbl {
+                              ccx.sess.span_fatal(expr.span,
+                                                  "cannot have static_assert \
+                                                   on a mutable static");
+                          }
                           let v = ccx.const_values.get_copy(&item.id);
                           unsafe {
                               if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
@@ -2398,13 +2403,14 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::node_id) -> ValueRef {
             let my_path = vec::append(/*bad*/copy *pth,
                                       [path_name(i.ident)]);
             match i.node {
-              ast::item_const(_, expr) => {
+              ast::item_static(_, m, expr) => {
                 let typ = ty::node_id_to_type(ccx.tcx, i.id);
                 let s = mangle_exported_name(ccx, my_path, typ);
                 // We need the translated value here, because for enums the
                 // LLVM type is not fully determined by the Rust type.
                 let v = consts::const_expr(ccx, expr);
                 ccx.const_values.insert(id, v);
+                exprt = m == ast::m_mutbl;
                 unsafe {
                     let llty = llvm::LLVMTypeOf(v);
                     let g = str::as_c_str(s, |buf| {
@@ -2457,7 +2463,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::node_id) -> ValueRef {
                                 ni.id,
                                 ni.attrs)
                 }
-                ast::foreign_item_const(*) => {
+                ast::foreign_item_static(*) => {
                     let typ = ty::node_id_to_type(ccx.tcx, ni.id);
                     let ident = token::ident_to_str(&ni.ident);
                     let g = do str::as_c_str(ident) |buf| {
@@ -2939,7 +2945,7 @@ pub fn trans_crate(sess: session::Session,
     }
 
     if ccx.sess.count_llvm_insns() {
-        for ccx.stats.llvm_insns.each |&k, &v| {
+        for ccx.stats.llvm_insns.iter().advance |(&k, &v)| {
             io::println(fmt!("%-7u %s", v, k));
         }
     }
diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs
index 6120e1e6581..cb475550638 100644
--- a/src/librustc/middle/trans/callee.rs
+++ b/src/librustc/middle/trans/callee.rs
@@ -143,7 +143,7 @@ pub fn trans(bcx: block, expr: @ast::expr) -> Callee {
                 datum_callee(bcx, ref_expr)
             }
             ast::def_mod(*) | ast::def_foreign_mod(*) | ast::def_trait(*) |
-            ast::def_const(*) | ast::def_ty(*) | ast::def_prim_ty(*) |
+            ast::def_static(*) | ast::def_ty(*) | ast::def_prim_ty(*) |
             ast::def_use(*) | ast::def_typaram_binder(*) |
             ast::def_region(*) | ast::def_label(*) | ast::def_ty_param(*) |
             ast::def_self_ty(*) => {
@@ -704,11 +704,11 @@ pub fn trans_args(cx: block,
     // now that all arguments have been successfully built, we can revoke any
     // temporary cleanups, as they are only needed if argument construction
     // should fail (for example, cleanup of copy mode args).
-    for vec::each(temp_cleanups) |c| {
+    for temp_cleanups.iter().advance |c| {
         revoke_clean(bcx, *c)
     }
 
-    return bcx;
+    bcx
 }
 
 pub enum AutorefArg {
diff --git a/src/librustc/middle/trans/consts.rs b/src/librustc/middle/trans/consts.rs
index e40534773c2..98eb858be55 100644
--- a/src/librustc/middle/trans/consts.rs
+++ b/src/librustc/middle/trans/consts.rs
@@ -164,9 +164,9 @@ pub fn get_const_val(cx: @mut CrateContext, mut def_id: ast::def_id) -> ValueRef
         }
         match cx.tcx.items.get_copy(&def_id.node) {
             ast_map::node_item(@ast::item {
-                node: ast::item_const(_, subexpr), _
+                node: ast::item_static(_, ast::m_imm, _), _
             }, _) => {
-                trans_const(cx, subexpr, def_id.node);
+                trans_const(cx, ast::m_imm, def_id.node);
             }
             _ => cx.tcx.sess.bug("expected a const to be an item")
         }
@@ -538,7 +538,7 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: @ast::expr) -> ValueRef {
                         base::get_item_val(cx, def_id.node)
                     }
                 }
-                Some(&ast::def_const(def_id)) => {
+                Some(&ast::def_static(def_id, false)) => {
                     get_const_val(cx, def_id)
                 }
                 Some(&ast::def_variant(enum_did, variant_did)) => {
@@ -587,7 +587,7 @@ fn const_expr_unadjusted(cx: @mut CrateContext, e: @ast::expr) -> ValueRef {
     }
 }
 
-pub fn trans_const(ccx: @mut CrateContext, _e: @ast::expr, id: ast::node_id) {
+pub fn trans_const(ccx: @mut CrateContext, m: ast::mutability, id: ast::node_id) {
     unsafe {
         let _icx = push_ctxt("trans_const");
         let g = base::get_item_val(ccx, id);
@@ -595,6 +595,8 @@ pub fn trans_const(ccx: @mut CrateContext, _e: @ast::expr, id: ast::node_id) {
         // constant's initializer to determine its LLVM type.
         let v = ccx.const_values.get_copy(&id);
         llvm::LLVMSetInitializer(g, v);
-        llvm::LLVMSetGlobalConstant(g, True);
+        if m != ast::m_mutbl {
+            llvm::LLVMSetGlobalConstant(g, True);
+        }
     }
 }
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 7d86f743a8e..1aebf73b81a 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -945,7 +945,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
         let _icx = push_ctxt("trans_def_lvalue");
         let ccx = bcx.ccx();
         match def {
-            ast::def_const(did) => {
+            ast::def_static(did, _) => {
                 let const_ty = expr_ty(bcx, ref_expr);
 
                 fn get_did(ccx: @mut CrateContext, did: ast::def_id)
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index 10e63e6af77..a5a6c1434c6 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -332,7 +332,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
                     }
                 }
             }
-            ast::foreign_item_const(*) => {
+            ast::foreign_item_static(*) => {
                 let ident = token::ident_to_str(&foreign_item.ident);
                 ccx.item_symbols.insert(foreign_item.id, /* bad */ident.to_owned());
             }
@@ -681,9 +681,12 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             let static_ti = get_tydesc(ccx, tp_ty);
             glue::lazily_emit_all_tydesc_glue(ccx, static_ti);
 
-            // FIXME (#3727): change this to ccx.tydesc_ty.ptr_to() when the
-            // core::sys copy of the get_tydesc interface dies off.
-            let td = PointerCast(bcx, static_ti.tydesc, Type::nil().ptr_to());
+            // FIXME (#3730): ideally this shouldn't need a cast,
+            // but there's a circularity between translating rust types to llvm
+            // types and having a tydesc type available. So I can't directly access
+            // the llvm type of intrinsic::TyDesc struct.
+            let userland_tydesc_ty = type_of::type_of(ccx, output_type);
+            let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
             Store(bcx, td, fcx.llretptr.get());
         }
         "init" => {
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index d8ba524b2bd..1f16a735c7c 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -232,7 +232,7 @@ pub fn lazily_emit_tydesc_glue(ccx: @mut CrateContext,
                                field: uint,
                                ti: @mut tydesc_info) {
     let _icx = push_ctxt("lazily_emit_tydesc_glue");
-    let llfnty = type_of_glue_fn(ccx);
+    let llfnty = Type::glue_fn();
 
     if lazily_emit_simplified_tydesc_glue(ccx, field, ti) {
         return;
@@ -338,9 +338,7 @@ pub fn call_tydesc_glue_full(bcx: block,
         }
     };
 
-    Call(bcx, llfn, [C_null(Type::nil().ptr_to()),
-                        C_null(bcx.ccx().tydesc_type.ptr_to().ptr_to()),
-                        llrawptr]);
+    Call(bcx, llfn, [C_null(Type::nil().ptr_to()), llrawptr]);
 }
 
 // See [Note-arg-mode]
@@ -406,13 +404,8 @@ pub fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
     build_return(bcx);
 }
 
-pub fn trans_struct_drop(bcx: block,
-                         t: ty::t,
-                         v0: ValueRef,
-                         dtor_did: ast::def_id,
-                         class_did: ast::def_id,
-                         substs: &ty::substs)
-                      -> block {
+pub fn trans_struct_drop_flag(bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
+                              class_did: ast::def_id, substs: &ty::substs) -> block {
     let repr = adt::represent_type(bcx.ccx(), t);
     let drop_flag = adt::trans_drop_flag_ptr(bcx, repr, v0);
     do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
@@ -454,6 +447,43 @@ pub fn trans_struct_drop(bcx: block,
     }
 }
 
+pub fn trans_struct_drop(mut bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
+                         class_did: ast::def_id, substs: &ty::substs) -> block {
+    let repr = adt::represent_type(bcx.ccx(), t);
+
+    // Find and call the actual destructor
+    let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did,
+                                 class_did, /*bad*/copy substs.tps);
+
+    // The second argument is the "self" argument for drop
+    let params = unsafe {
+        let ty = Type::from_ref(llvm::LLVMTypeOf(dtor_addr));
+        ty.element_type().func_params()
+    };
+
+    // Class dtors have no explicit args, so the params should
+    // just consist of the environment (self)
+    assert_eq!(params.len(), 1);
+
+    // Take a reference to the class (because it's using the Drop trait),
+    // do so now.
+    let llval = alloca(bcx, val_ty(v0));
+    Store(bcx, v0, llval);
+
+    let self_arg = PointerCast(bcx, llval, params[0]);
+    let args = ~[self_arg];
+
+    Call(bcx, dtor_addr, args);
+
+    // Drop the fields
+    let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
+    for field_tys.iter().enumerate().advance |(i, fld)| {
+        let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
+        bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
+    }
+
+    bcx
+}
 
 pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
     // NB: v0 is an *alias* of type t here, not a direct value.
@@ -474,7 +504,10 @@ pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
       ty::ty_struct(did, ref substs) => {
         let tcx = bcx.tcx();
         match ty::ty_dtor(tcx, did) {
-          ty::TraitDtor(dtor) => {
+          ty::TraitDtor(dtor, true) => {
+            trans_struct_drop_flag(bcx, t, v0, dtor, did, substs)
+          }
+          ty::TraitDtor(dtor, false) => {
             trans_struct_drop(bcx, t, v0, dtor, did, substs)
           }
           ty::NoDtor => {
@@ -594,6 +627,23 @@ pub fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
       ty::ty_opaque_closure_ptr(ck) => {
         closure::make_opaque_cbox_take_glue(bcx, ck, v)
       }
+      ty::ty_struct(did, ref substs) => {
+        let tcx = bcx.tcx();
+        let bcx = iter_structural_ty(bcx, v, t, take_ty);
+
+        match ty::ty_dtor(tcx, did) {
+          ty::TraitDtor(dtor, false) => {
+            // Zero out the struct
+            unsafe {
+                let ty = Type::from_ref(llvm::LLVMTypeOf(v));
+                memzero(bcx, v, ty);
+            }
+
+          }
+          _ => { }
+        }
+        bcx
+      }
       _ if ty::type_is_structural(t) => {
         iter_structural_ty(bcx, v, t, take_ty)
       }
@@ -680,7 +730,7 @@ pub fn make_generic_glue_inner(ccx: @mut CrateContext,
 
     let bcx = top_scope_block(fcx, None);
     let lltop = bcx.llbb;
-    let rawptr0_arg = fcx.arg_pos(1u);
+    let rawptr0_arg = fcx.arg_pos(0u);
     let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, rawptr0_arg as c_uint) };
     let llty = type_of(ccx, t);
     let llrawptr0 = PointerCast(bcx, llrawptr0, llty.ptr_to());
@@ -715,7 +765,7 @@ pub fn emit_tydescs(ccx: &mut CrateContext) {
     let _icx = push_ctxt("emit_tydescs");
     // As of this point, allow no more tydescs to be created.
     ccx.finished_tydescs = true;
-    let glue_fn_ty = Type::generic_glue_fn(ccx);
+    let glue_fn_ty = Type::generic_glue_fn(ccx).ptr_to();
     let tyds = &mut ccx.tydescs;
     for tyds.each_value |&val| {
         let ti = val;
@@ -765,19 +815,13 @@ pub fn emit_tydescs(ccx: &mut CrateContext) {
               }
             };
 
-
-        let shape = C_null(Type::i8p());
-        let shape_tables = C_null(Type::i8p());
-
         let tydesc = C_named_struct(ccx.tydesc_type,
-                           [ti.size, // size
-                            ti.align, // align
-                            take_glue, // take_glue
-                            drop_glue, // drop_glue
-                            free_glue, // free_glue
-                            visit_glue, // visit_glue
-                            shape, // shape
-                            shape_tables]); // shape_tables
+                                    [ti.size, // size
+                                    ti.align, // align
+                                    take_glue, // take_glue
+                                    drop_glue, // drop_glue
+                                    free_glue, // free_glue
+                                    visit_glue]); // visit_glue
 
         unsafe {
             let gvar = ti.tydesc;
@@ -788,8 +832,3 @@ pub fn emit_tydescs(ccx: &mut CrateContext) {
         }
     };
 }
-
-fn type_of_glue_fn(ccx: &CrateContext) -> Type {
-    let tydescpp = ccx.tydesc_type.ptr_to().ptr_to();
-    Type::func([ Type::nil().ptr_to(), tydescpp, Type::i8p() ], &Type::void())
-}
diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs
index 6a40c1f75e9..e950c24c49e 100644
--- a/src/librustc/middle/trans/reachable.rs
+++ b/src/librustc/middle/trans/reachable.rs
@@ -146,7 +146,7 @@ fn traverse_public_item(cx: @mut ctx, item: @item) {
                         visit::mk_vt(@visit::Visitor {visit_ty: traverse_ty,
                                                       ..*visit::default_visitor()})))
       }
-      item_const(*) |
+      item_static(*) |
       item_enum(*) | item_trait(*) => (),
       item_mac(*) => fail!("item macros unimplemented")
     }
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index a2c945a13f3..24c73334697 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -274,9 +274,7 @@ impl Reflector {
             let repr = adt::represent_type(bcx.ccx(), t);
             let variants = ty::substd_enum_variants(ccx.tcx, did, substs);
             let llptrty = type_of(ccx, t).ptr_to();
-            let (_, opaquety) =
-                ccx.tcx.intrinsic_defs.find_copy(&ccx.sess.ident_of("Opaque"))
-                .expect("Failed to resolve intrinsic::Opaque");
+            let opaquety = ty::get_opaque_ty(ccx.tcx);
             let opaqueptrty = ty::mk_ptr(ccx.tcx, ty::mt { ty: opaquety, mutbl: ast::m_imm });
 
             let make_get_disr = || {
@@ -373,10 +371,8 @@ pub fn emit_calls_to_trait_visit_ty(bcx: block,
                                     visitor_val: ValueRef,
                                     visitor_trait_id: def_id)
                                  -> block {
-    use syntax::parse::token::special_idents::tydesc;
     let final = sub_block(bcx, "final");
-    assert!(bcx.ccx().tcx.intrinsic_defs.contains_key(&tydesc));
-    let (_, tydesc_ty) = bcx.ccx().tcx.intrinsic_defs.get_copy(&tydesc);
+    let tydesc_ty = ty::get_tydesc_ty(bcx.ccx().tcx);
     let tydesc_ty = type_of(bcx.ccx(), tydesc_ty);
     let mut r = Reflector {
         visitor_val: visitor_val,
diff --git a/src/librustc/middle/trans/type_.rs b/src/librustc/middle/trans/type_.rs
index 34a15033109..64688ac4134 100644
--- a/src/librustc/middle/trans/type_.rs
+++ b/src/librustc/middle/trans/type_.rs
@@ -20,7 +20,6 @@ use middle::trans::base;
 
 use syntax::ast;
 use syntax::abi::{Architecture, X86, X86_64, Arm, Mips};
-use back::abi;
 
 use core::vec;
 use core::cast;
@@ -189,25 +188,26 @@ impl Type {
             None => ()
         }
 
-        let ty = cx.tydesc_type.get_field(abi::tydesc_field_drop_glue);
+        let ty = Type::glue_fn();
         cx.tn.associate_type("glue_fn", &ty);
 
         return ty;
     }
 
+    pub fn glue_fn() -> Type {
+        Type::func([ Type::nil().ptr_to(), Type::i8p() ],
+            &Type::void())
+    }
+
     pub fn tydesc(arch: Architecture) -> Type {
         let mut tydesc = Type::named_struct("tydesc");
-        let tydescpp = tydesc.ptr_to().ptr_to();
-        let pvoid = Type::i8p();
-        let glue_fn_ty = Type::func([ Type::nil().ptr_to(), tydescpp, pvoid ],
-            &Type::void()).ptr_to();
+        let glue_fn_ty = Type::glue_fn().ptr_to();
 
         let int_ty = Type::int(arch);
 
         let elems = [
             int_ty, int_ty,
-            glue_fn_ty, glue_fn_ty, glue_fn_ty, glue_fn_ty,
-            pvoid, pvoid
+            glue_fn_ty, glue_fn_ty, glue_fn_ty, glue_fn_ty
         ];
 
         tydesc.set_struct_body(elems, false);
@@ -265,10 +265,6 @@ impl Type {
         cx.int_type
     }
 
-    pub fn captured_tydescs(ctx: &CrateContext, num: uint) -> Type {
-        Type::struct_(vec::from_elem(num, ctx.tydesc_type.ptr_to()), false)
-    }
-
     pub fn opaque_trait(ctx: &CrateContext, store: ty::TraitStore) -> Type {
         let tydesc_ptr = ctx.tydesc_type.ptr_to();
         match store {
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
index f2446d1a115..8cd776c99d6 100644
--- a/src/librustc/middle/trans/type_use.rs
+++ b/src/librustc/middle/trans/type_use.rs
@@ -213,7 +213,8 @@ pub fn type_needs_inner(cx: Context,
               ty::ty_enum(did, ref substs) => {
                 if list::find(enums_seen, |id| *id == did).is_none() {
                     let seen = @Cons(did, enums_seen);
-                    for vec::each(*ty::enum_variants(cx.ccx.tcx, did)) |v| {
+                    let r = ty::enum_variants(cx.ccx.tcx, did);
+                    for r.iter().advance |v| {
                         for v.args.iter().advance |aty| {
                             let t = ty::subst(cx.ccx.tcx, &(*substs), *aty);
                             type_needs_inner(cx, use_, t, seen);
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 4303ff63015..87b6e61e137 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -21,7 +21,7 @@ use middle::ty;
 use middle::subst::Subst;
 use middle::typeck;
 use middle;
-use util::ppaux::{note_and_explain_region, bound_region_to_str, bound_region_ptr_to_str};
+use util::ppaux::{note_and_explain_region, bound_region_ptr_to_str};
 use util::ppaux::{trait_store_to_str, ty_to_str, vstore_to_str};
 use util::ppaux::{Repr, UserString};
 use util::common::{indenter};
@@ -44,7 +44,6 @@ use syntax::attr;
 use syntax::codemap::span;
 use syntax::codemap;
 use syntax::parse::token;
-use syntax::parse::token::special_idents;
 use syntax::{ast, ast_map};
 use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
@@ -276,8 +275,7 @@ struct ctxt_ {
     trait_defs: @mut HashMap<def_id, @TraitDef>,
 
     items: ast_map::map,
-    intrinsic_defs: @mut HashMap<ast::ident, (ast::def_id, t)>,
-    intrinsic_traits: @mut HashMap<ast::ident, @TraitRef>,
+    intrinsic_defs: @mut HashMap<ast::def_id, t>,
     freevars: freevars::freevar_map,
     tcache: type_cache,
     rcache: creader_cache,
@@ -954,7 +952,6 @@ pub fn mk_ctxt(s: session::Session,
         node_type_substs: @mut HashMap::new(),
         trait_refs: @mut HashMap::new(),
         trait_defs: @mut HashMap::new(),
-        intrinsic_traits: @mut HashMap::new(),
         items: amap,
         intrinsic_defs: @mut HashMap::new(),
         freevars: freevars,
@@ -3269,7 +3266,7 @@ pub fn expr_kind(tcx: ctxt,
                 // Note: there is actually a good case to be made that
                 // def_args, particularly those of immediate type, ought to
                 // considered rvalues.
-                ast::def_const(*) |
+                ast::def_static(*) |
                 ast::def_binding(*) |
                 ast::def_upvar(*) |
                 ast::def_arg(*) |
@@ -3855,7 +3852,7 @@ pub fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str {
 
 pub enum DtorKind {
     NoDtor,
-    TraitDtor(def_id)
+    TraitDtor(def_id, bool)
 }
 
 impl DtorKind {
@@ -3869,13 +3866,24 @@ impl DtorKind {
     pub fn is_present(&const self) -> bool {
         !self.is_not_present()
     }
+
+    pub fn has_drop_flag(&self) -> bool {
+        match self {
+            &NoDtor => false,
+            &TraitDtor(_, flag) => flag
+        }
+    }
 }
 
 /* If struct_id names a struct with a dtor, return Some(the dtor's id).
    Otherwise return none. */
 pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind {
     match cx.destructor_for_type.find(&struct_id) {
-        Some(&method_def_id) => TraitDtor(method_def_id),
+        Some(&method_def_id) => {
+            let flag = !has_attr(cx, struct_id, "no_drop_flag");
+
+            TraitDtor(method_def_id, flag)
+        }
         None => NoDtor,
     }
 }
@@ -4469,10 +4477,26 @@ pub fn get_impl_id(tcx: ctxt, trait_id: def_id, self_ty: t) -> def_id {
     }
 }
 
+pub fn get_tydesc_ty(tcx: ctxt) -> t {
+    let tydesc_lang_item = tcx.lang_items.ty_desc();
+    tcx.intrinsic_defs.find_copy(&tydesc_lang_item)
+        .expect("Failed to resolve TyDesc")
+}
+
+pub fn get_opaque_ty(tcx: ctxt) -> t {
+    let opaque_lang_item = tcx.lang_items.opaque();
+    tcx.intrinsic_defs.find_copy(&opaque_lang_item)
+        .expect("Failed to resolve Opaque")
+}
+
 pub fn visitor_object_ty(tcx: ctxt) -> (@TraitRef, t) {
-    let ty_visitor_name = special_idents::ty_visitor;
-    assert!(tcx.intrinsic_traits.contains_key(&ty_visitor_name));
-    let trait_ref = tcx.intrinsic_traits.get_copy(&ty_visitor_name);
+    let substs = substs {
+        self_r: None,
+        self_ty: None,
+        tps: ~[]
+    };
+    let trait_lang_item = tcx.lang_items.ty_visitor();
+    let trait_ref = @TraitRef { def_id: trait_lang_item, substs: substs };
     (trait_ref,
      mk_trait(tcx, trait_ref.def_id, copy trait_ref.substs,
               BoxTraitStore, ast::m_imm, EmptyBuiltinBounds()))
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 3b651451db8..5e6574850f1 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -752,7 +752,7 @@ fn conv_builtin_bounds(tcx: ty::ctxt,
     //! legal.
 
     let mut builtin_bounds = ty::EmptyBuiltinBounds();
-    for ast_bounds.each |ast_bound| {
+    for ast_bounds.iter().advance |ast_bound| {
         match *ast_bound {
             ast::TraitTyParamBound(b) => {
                 match lookup_def_tcx(tcx, b.path.span, b.ref_id) {
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 23eb8d52e6c..a38a2dced93 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -107,7 +107,7 @@ use middle::typeck::{isr_alist, lookup_def_ccx};
 use middle::typeck::no_params;
 use middle::typeck::{require_same_types, method_map, vtable_map};
 use util::common::{block_query, indenter, loop_query};
-use util::ppaux::{bound_region_to_str,bound_region_ptr_to_str};
+use util::ppaux::{bound_region_ptr_to_str};
 use util::ppaux;
 
 
@@ -585,7 +585,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
     let _indenter = indenter();
 
     match it.node {
-      ast::item_const(_, e) => check_const(ccx, it.span, e, it.id),
+      ast::item_static(_, _, e) => check_const(ccx, it.span, e, it.id),
       ast::item_enum(ref enum_definition, _) => {
         check_enum_variants(ccx,
                             it.span,
@@ -3216,7 +3216,7 @@ pub fn ty_param_bounds_and_ty_for_def(fcx: @mut FnCtxt,
       }
 
       ast::def_fn(id, _) | ast::def_static_method(id, _, _) |
-      ast::def_const(id) | ast::def_variant(_, id) |
+      ast::def_static(id, _) | ast::def_variant(_, id) |
       ast::def_struct(id) => {
         return ty::lookup_item_type(fcx.ccx.tcx, id);
       }
@@ -3506,13 +3506,15 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
             }
 
             "get_tydesc" => {
-              // FIXME (#3730): return *intrinsic::tydesc, not *()
-              (1u, ~[], ty::mk_nil_ptr(ccx.tcx))
+              let tydesc_ty = ty::get_tydesc_ty(ccx.tcx);
+              let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
+                  ty: tydesc_ty,
+                  mutbl: ast::m_imm
+              });
+              (1u, ~[], td_ptr)
             }
             "visit_tydesc" => {
-              let tydesc_name = special_idents::tydesc;
-              assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
-              let (_, tydesc_ty) = tcx.intrinsic_defs.get_copy(&tydesc_name);
+              let tydesc_ty = ty::get_tydesc_ty(ccx.tcx);
               let (_, visitor_object_ty) = ty::visitor_object_ty(tcx);
               let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
                   ty: tydesc_ty,
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index 7ad27077cd8..ae62e768ea2 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -16,10 +16,8 @@
 
 use core::prelude::*;
 
-use driver;
 use metadata::csearch::{each_path, get_impl_trait};
 use metadata::csearch::{get_impls_for_mod};
-use metadata::csearch;
 use metadata::cstore::{CStore, iter_crate_data};
 use metadata::decoder::{dl_def, dl_field, dl_impl};
 use middle::resolve::{Impl, MethodInfo};
@@ -39,7 +37,7 @@ use middle::typeck::infer::combine::Combine;
 use middle::typeck::infer::InferCtxt;
 use middle::typeck::infer::{new_infer_ctxt, resolve_ivar};
 use middle::typeck::infer::{resolve_nested_tvar, resolve_type};
-use syntax::ast::{crate, def_id, def_mod, def_struct, def_trait, def_ty};
+use syntax::ast::{crate, def_id, def_mod, def_struct, def_ty};
 use syntax::ast::{item, item_enum, item_impl, item_mod, item_struct};
 use syntax::ast::{local_crate, method, trait_ref, ty_path};
 use syntax::ast;
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index 7f820d11ac6..7812a0ed0eb 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -62,55 +62,16 @@ use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
 
 pub fn collect_item_types(ccx: @mut CrateCtxt, crate: @ast::crate) {
-
-    // FIXME (#2592): hooking into the "intrinsic" root module is crude.
-    // There ought to be a better approach. Attributes?
-
-    for crate.node.module.items.iter().advance |crate_item| {
-        if crate_item.ident
-            == ::syntax::parse::token::special_idents::intrinsic {
-
-            match crate_item.node {
-              ast::item_mod(ref m) => {
-                for m.items.iter().advance |intrinsic_item| {
-                    let def_id = ast::def_id { crate: ast::local_crate,
-                                               node: intrinsic_item.id };
-                    let substs = substs {
-                        self_r: None,
-                        self_ty: None,
-                        tps: ~[]
-                    };
-
-                    match intrinsic_item.node {
-                      ast::item_trait(*) => {
-                          let tref = @ty::TraitRef {def_id: def_id,
-                                                    substs: substs};
-                          ccx.tcx.intrinsic_traits.insert
-                              (intrinsic_item.ident, tref);
-                      }
-
-                      ast::item_enum(*) => {
-                        let ty = ty::mk_enum(ccx.tcx, def_id, substs);
-                        ccx.tcx.intrinsic_defs.insert
-                            (intrinsic_item.ident, (def_id, ty));
-                      }
-
-                      ast::item_struct(*) => {
-                        let ty = ty::mk_struct(ccx.tcx, def_id, substs);
-                        ccx.tcx.intrinsic_defs.insert
-                            (intrinsic_item.ident, (def_id, ty));
-                      }
-
-                      _ => {}
-                    }
-                }
-              }
-              _ => { }
-            }
-            break;
-        }
+    fn collect_intrinsic_type(ccx: @mut CrateCtxt,
+                              lang_item: ast::def_id) {
+        let ty::ty_param_bounds_and_ty { ty: ty, _ } =
+            ccx.get_item_ty(lang_item);
+        ccx.tcx.intrinsic_defs.insert(lang_item, ty);
     }
 
+    collect_intrinsic_type(ccx, ccx.tcx.lang_items.ty_desc());
+    collect_intrinsic_type(ccx, ccx.tcx.lang_items.opaque());
+
     visit::visit_crate(
         crate, ((),
         visit::mk_simple_visitor(@visit::SimpleVisitor {
@@ -814,7 +775,7 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt,
                                  span: span,
                                  generics: &ast::Generics,
                                  thing: &'static str) {
-    for generics.ty_params.each |ty_param| {
+    for generics.ty_params.iter().advance |ty_param| {
         if ty_param.bounds.len() > 0 {
             ccx.tcx.sess.span_err(
                 span,
@@ -1060,7 +1021,7 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: @ast::item)
     }
     let rp = tcx.region_paramd_items.find(&it.id).map_consume(|x| *x);
     match it.node {
-      ast::item_const(t, _) => {
+      ast::item_static(t, _, _) => {
         let typ = ccx.to_ty(&empty_rscope, t);
         let tpt = no_params(typ);
         tcx.tcache.insert(local_def(it.id), tpt);
@@ -1153,7 +1114,7 @@ pub fn ty_of_foreign_item(ccx: &CrateCtxt,
                                   generics,
                                   abis)
         }
-        ast::foreign_item_const(t) => {
+        ast::foreign_item_static(t, _) => {
             ty::ty_param_bounds_and_ty {
                 generics: ty::Generics {
                     type_param_defs: @~[],
@@ -1211,7 +1172,7 @@ pub fn ty_generics(ccx: &CrateCtxt,
             builtin_bounds: ty::EmptyBuiltinBounds(),
             trait_bounds: ~[]
         };
-        for ast_bounds.each |ast_bound| {
+        for ast_bounds.iter().advance |ast_bound| {
             match *ast_bound {
                 TraitTyParamBound(b) => {
                     let ty = ty::mk_param(ccx.tcx, param_ty.idx, param_ty.def_id);
diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs
index d9add22479c..0aad161a678 100644
--- a/src/librustc/middle/typeck/infer/region_inference.rs
+++ b/src/librustc/middle/typeck/infer/region_inference.rs
@@ -1285,7 +1285,7 @@ impl RegionVarBindings {
 
         // It would be nice to write this using map():
         let mut edges = vec::with_capacity(num_edges);
-        for self.constraints.each |constraint, span| {
+        for self.constraints.iter().advance |(constraint, span)| {
             edges.push(GraphEdge {
                 next_edge: [uint::max_value, uint::max_value],
                 constraint: *constraint,
diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs
index 16b490cd478..dc9fc264f85 100644
--- a/src/librustc/middle/typeck/rscope.rs
+++ b/src/librustc/middle/typeck/rscope.rs
@@ -57,7 +57,7 @@ impl RegionParamNames {
     }
 
     fn has_ident(&self, ident: ast::ident) -> bool {
-        for self.each |region_param_name| {
+        for self.iter().advance |region_param_name| {
             if *region_param_name == ident {
                 return true;
             }
diff --git a/src/librustc/rustc.rc b/src/librustc/rustc.rs
index d59a308beb5..ca49d143d48 100644
--- a/src/librustc/rustc.rc
+++ b/src/librustc/rustc.rs
@@ -86,7 +86,6 @@ pub mod front {
     pub mod config;
     pub mod test;
     pub mod std_inject;
-    pub mod intrinsic_inject;
 }
 
 pub mod back {
@@ -167,7 +166,7 @@ Available lint options:
                      padded(max_key, "name"), "default", "meaning"));
     io::println(fmt!("    %s  %7.7s  %s\n",
                      padded(max_key, "----"), "-------", "-------"));
-    for lint_dict.each |k, v| {
+    for lint_dict.iter().advance |(k, v)| {
         let k = k.replace("_", "-");
         io::println(fmt!("    %s  %7.7s  %s",
                          padded(max_key, k),
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index e25267f4441..3194df269c0 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -32,7 +32,6 @@ use syntax::parse::token;
 use syntax::print::pprust;
 use syntax::{ast, ast_util};
 
-use core::str;
 use core::vec;
 
 /// Produces a string suitable for debugging output.
diff --git a/src/librustdoc/extract.rs b/src/librustdoc/extract.rs
index b6131dce9c8..b7b2b70769b 100644
--- a/src/librustdoc/extract.rs
+++ b/src/librustdoc/extract.rs
@@ -102,7 +102,7 @@ fn moddoc_from_mod(
                     fndoc_from_fn(ItemDoc)
                 ))
               }
-              ast::item_const(_, _) => {
+              ast::item_static(*) => {
                 Some(doc::ConstTag(
                     constdoc_from_const(ItemDoc)
                 ))
@@ -150,7 +150,7 @@ fn nmoddoc_from_mod(
           ast::foreign_item_fn(*) => {
             fns.push(fndoc_from_fn(ItemDoc));
           }
-          ast::foreign_item_const(*) => {} // XXX: Not implemented.
+          ast::foreign_item_static(*) => {} // XXX: Not implemented.
         }
     }
     doc::NmodDoc {
diff --git a/src/librustdoc/rustdoc.rc b/src/librustdoc/rustdoc.rs
index d02620229f5..d02620229f5 100644
--- a/src/librustdoc/rustdoc.rc
+++ b/src/librustdoc/rustdoc.rs
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index e3abe6e926a..459daaa468f 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -96,7 +96,7 @@ fn fold_const(
             do astsrv::exec(srv) |ctxt| {
                 match ctxt.ast_map.get_copy(&doc.id()) {
                     ast_map::node_item(@ast::item {
-                        node: ast::item_const(ty, _), _
+                        node: ast::item_static(ty, _, _), _
                     }, _) => {
                         pprust::ty_to_str(ty, extract::interner())
                     }
diff --git a/src/librusti/program.rs b/src/librusti/program.rs
index 91fde3e21ae..f17777559de 100644
--- a/src/librusti/program.rs
+++ b/src/librusti/program.rs
@@ -96,7 +96,7 @@ impl Program {
 
         code.push_str("fn main() {\n");
         // It's easy to initialize things if we don't run things...
-        for self.local_vars.each |name, var| {
+        for self.local_vars.iter().advance |(name, var)| {
             let mt = var.mt();
             code.push_str(fmt!("let%s %s: %s = fail!();\n", mt, *name, var.ty));
             var.alter(*name, &mut code);
@@ -149,7 +149,7 @@ impl Program {
 
         // Using this __tls_map handle, deserialize each variable binding that
         // we know about
-        for self.local_vars.each |name, var| {
+        for self.local_vars.iter().advance |(name, var)| {
             let mt = var.mt();
             code.push_str(fmt!("let%s %s: %s = {
                 let data = __tls_map.get_copy(&~\"%s\");
@@ -175,7 +175,7 @@ impl Program {
 
         // After the input code is run, we can re-serialize everything back out
         // into tls map (to be read later on by this task)
-        for self.local_vars.each |name, var| {
+        for self.local_vars.iter().advance |(name, var)| {
             code.push_str(fmt!("{
                 let local: %s = %s;
                 let bytes = do ::std::io::with_bytes_writer |io| {
@@ -237,7 +237,7 @@ impl Program {
     /// program starts
     pub fn set_cache(&self) {
         let map = @mut HashMap::new();
-        for self.local_vars.each |name, value| {
+        for self.local_vars.iter().advance |(name, value)| {
             map.insert(copy *name, @copy value.data);
         }
         unsafe {
diff --git a/src/librusti/rusti.rc b/src/librusti/rusti.rs
index 57a2a48a0f6..57a2a48a0f6 100644
--- a/src/librusti/rusti.rc
+++ b/src/librusti/rusti.rs
diff --git a/src/librustpkg/rustpkg.rc b/src/librustpkg/rustpkg.rs
index 9242e450e24..9242e450e24 100644
--- a/src/librustpkg/rustpkg.rc
+++ b/src/librustpkg/rustpkg.rs
diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index b871ed3d57a..5a2f948600a 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -25,13 +25,16 @@ use vec::ImmutableVector;
 
 pub mod rustrt {
     use libc;
-    use sys;
     use vec;
+    #[cfg(stage0)]
+    use intrinsic::{TyDesc};
+    #[cfg(not(stage0))]
+    use unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]
     #[link_name = "rustrt"]
     pub extern {
-        pub unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
+        pub unsafe fn vec_reserve_shared_actual(t: *TyDesc,
                                                 v: **vec::raw::VecRepr,
                                                 n: libc::size_t);
     }
@@ -197,6 +200,10 @@ pub mod raw {
     use uint;
     use unstable::intrinsics::{move_val_init};
     use vec;
+    #[cfg(stage0)]
+    use intrinsic::{get_tydesc};
+    #[cfg(not(stage0))]
+    use unstable::intrinsics::{get_tydesc};
 
     pub type VecRepr = vec::raw::VecRepr;
     pub type SliceRepr = vec::raw::SliceRepr;
@@ -258,7 +265,7 @@ pub mod raw {
         // Only make the (slow) call into the runtime if we have to
         if capacity(*v) < n {
             let ptr: **VecRepr = transmute(v);
-            rustrt::vec_reserve_shared_actual(sys::get_type_desc::<T>(),
+            rustrt::vec_reserve_shared_actual(get_tydesc::<T>(),
                                               ptr, n as libc::size_t);
         }
     }
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index d1460b7a3c9..ee9fdd3c620 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -10,24 +10,19 @@
 
 #[doc(hidden)];
 
-use libc::{c_char, c_void, intptr_t, uintptr_t};
-use ptr::mut_null;
+use libc::{c_char, intptr_t, uintptr_t};
+use ptr::{mut_null};
 use repr::BoxRepr;
-use sys::TypeDesc;
 use cast::transmute;
+use unstable::intrinsics::TyDesc;
 #[cfg(not(test))] use unstable::lang::clear_task_borrow_list;
 
-#[cfg(not(test))] use ptr::to_unsafe_ptr;
-
 /**
  * Runtime structures
  *
  * NB: These must match the representation in the C++ runtime.
  */
 
-type DropGlue<'self> = &'self fn(**TypeDesc, *c_void);
-type FreeGlue<'self> = &'self fn(**TypeDesc, *c_void);
-
 type TaskID = uintptr_t;
 
 struct StackSegment { priv opaque: () }
@@ -164,6 +159,19 @@ fn debug_mem() -> bool {
     false
 }
 
+#[inline]
+#[cfg(not(stage0))]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    // This function should be inlined when stage0 is gone
+    ((*tydesc).drop_glue)(data);
+}
+
+#[inline]
+#[cfg(stage0)]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    ((*tydesc).drop_glue)(0 as **TyDesc, data);
+}
+
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
 #[cfg(not(test))]
 #[lang="annihilate"]
@@ -205,9 +213,9 @@ pub unsafe fn annihilate() {
     // callback, as the original value may have been freed.
     for each_live_alloc(false) |box, uniq| {
         if !uniq {
-            let tydesc: *TypeDesc = transmute(copy (*box).header.type_desc);
-            let drop_glue: DropGlue = transmute(((*tydesc).drop_glue, 0));
-            drop_glue(to_unsafe_ptr(&tydesc), transmute(&(*box).data));
+            let tydesc = (*box).header.type_desc;
+            let data = transmute(&(*box).data);
+            call_drop_glue(tydesc, data);
         }
     }
 
diff --git a/src/libstd/container.rs b/src/libstd/container.rs
index c1b656f1cd9..d6f4c26715a 100644
--- a/src/libstd/container.rs
+++ b/src/libstd/container.rs
@@ -34,18 +34,6 @@ pub trait Map<K, V>: Mutable {
     /// Return true if the map contains a value for the specified key
     fn contains_key(&self, key: &K) -> bool;
 
-    /// Visits all keys and values
-    fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool) -> bool;
-
-    /// Visit all keys
-    fn each_key(&self, f: &fn(&K) -> bool) -> bool;
-
-    /// Visit all values
-    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool;
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool;
-
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
 
diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs
index 611b95a7745..c9e33219fa5 100644
--- a/src/libstd/gc.rs
+++ b/src/libstd/gc.rs
@@ -40,12 +40,13 @@ with destructors.
 use cast;
 use container::{Map, Set};
 use io;
-use libc::{size_t, uintptr_t};
+use libc::{uintptr_t};
 use option::{None, Option, Some};
 use ptr;
 use hashmap::HashSet;
 use stackwalk::walk_stack;
 use sys;
+use unstable::intrinsics::{TyDesc};
 
 pub use stackwalk::Word;
 
@@ -58,18 +59,12 @@ pub struct StackSegment {
 }
 
 pub mod rustrt {
-    use libc::size_t;
     use stackwalk::Word;
     use super::StackSegment;
 
     #[link_name = "rustrt"]
     pub extern {
         #[rust_stack]
-        pub unsafe fn rust_call_tydesc_glue(root: *Word,
-                                            tydesc: *Word,
-                                            field: size_t);
-
-        #[rust_stack]
         pub unsafe fn rust_gc_metadata() -> *Word;
 
         pub unsafe fn rust_get_stack_segment() -> *StackSegment;
@@ -125,7 +120,7 @@ unsafe fn is_safe_point(pc: *Word) -> Option<SafePoint> {
     return None;
 }
 
-type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
+type Visitor<'self> = &'self fn(root: **Word, tydesc: *TyDesc) -> bool;
 
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
@@ -139,7 +134,7 @@ unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
     let stack_roots: *u32 = bump(sp_meta, 2);
     let reg_roots: *u8 = bump(stack_roots, num_stack_roots);
     let addrspaces: *Word = align_to_pointer(bump(reg_roots, num_reg_roots));
-    let tydescs: ***Word = bump(addrspaces, num_stack_roots);
+    let tydescs: ***TyDesc = bump(addrspaces, num_stack_roots);
 
     // Stack roots
     let mut sri = 0;
@@ -321,6 +316,19 @@ fn expect_sentinel() -> bool { true }
 #[cfg(nogc)]
 fn expect_sentinel() -> bool { false }
 
+#[inline]
+#[cfg(not(stage0))]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    // This function should be inlined when stage0 is gone
+    ((*tydesc).drop_glue)(data);
+}
+
+#[inline]
+#[cfg(stage0)]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    ((*tydesc).drop_glue)(0 as **TyDesc, data);
+}
+
 // Entry point for GC-based cleanup. Walks stack looking for exchange
 // heap and stack allocations requiring drop, and runs all
 // destructors.
@@ -364,7 +372,7 @@ pub fn cleanup_stack_for_failure() {
                 // FIXME #4420: Destroy this box
                 // FIXME #4330: Destroy this box
             } else {
-                rustrt::rust_call_tydesc_glue(*root, tydesc, 3 as size_t);
+                call_drop_glue(tydesc, *root as *i8);
             }
         }
     }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index 7d55947e818..bfa0f2fa124 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -307,34 +307,6 @@ impl<K:Hash + Eq,V> Map<K, V> for HashMap<K, V> {
         }
     }
 
-    /// Visit all key-value pairs
-    fn each<'a>(&'a self, blk: &fn(&K, &'a V) -> bool) -> bool {
-        self.iter().advance(|(k, v)| blk(k, v))
-    }
-
-    /// Visit all keys
-    fn each_key(&self, blk: &fn(k: &K) -> bool) -> bool {
-        self.iter().advance(|(k, _)| blk(k))
-    }
-
-    /// Visit all values
-    fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) -> bool {
-        self.iter().advance(|(_, v)| blk(v))
-    }
-
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, blk: &fn(&K, &mut V) -> bool) -> bool {
-        for uint::range(0, self.buckets.len()) |i| {
-            match self.buckets[i] {
-              Some(Bucket{key: ref key, value: ref mut value, _}) => {
-                if !blk(key, value) { return false; }
-              }
-              None => ()
-            }
-        }
-        return true;
-    }
-
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, k: &K) -> Option<&'a V> {
         match self.bucket_for_key(k) {
@@ -516,6 +488,29 @@ impl<K: Hash + Eq, V> HashMap<K, V> {
         }
     }
 
+    /// Visit all keys
+    pub fn each_key(&self, blk: &fn(k: &K) -> bool) -> bool {
+        self.iter().advance(|(k, _)| blk(k))
+    }
+
+    /// Visit all values
+    pub fn each_value<'a>(&'a self, blk: &fn(v: &'a V) -> bool) -> bool {
+        self.iter().advance(|(_, v)| blk(v))
+    }
+
+    /// Iterate over the map and mutate the contained values
+    pub fn mutate_values(&mut self, blk: &fn(&K, &mut V) -> bool) -> bool {
+        for uint::range(0, self.buckets.len()) |i| {
+            match self.buckets[i] {
+              Some(Bucket{key: ref key, value: ref mut value, _}) => {
+                if !blk(key, value) { return false; }
+              }
+              None => ()
+            }
+        }
+        return true;
+    }
+
     /// An iterator visiting all key-value pairs in arbitrary order.
     /// Iterator element type is (&'a K, &'a V).
     pub fn iter<'a>(&'a self) -> HashMapIterator<'a, K, V> {
@@ -718,12 +713,6 @@ impl<T:Hash + Eq> HashSet<T> {
       self.map.contains_key_equiv(value)
     }
 
-    /// Visit all elements in arbitrary order
-    /// FIXME: #6978: Remove when all callers are converted
-    pub fn each(&self, f: &fn(&T) -> bool) -> bool {
-        self.iter().advance(f)
-    }
-
     /// An iterator visiting all elements in arbitrary order.
     /// Iterator element type is &'a T.
     pub fn iter<'a>(&'a self) -> HashSetIterator<'a, T> {
diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index d96191f296d..9177ecabed6 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -43,7 +43,6 @@ pub trait Iterator<A> {
     /// Return a lower bound and upper bound on the remaining length of the iterator.
     ///
     /// The common use case for the estimate is pre-allocating space to store the results.
-    #[cfg(not(stage0))]
     fn size_hint(&self) -> (Option<uint>, Option<uint>) { (None, None) }
 }
 
@@ -610,7 +609,6 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for ChainIterator<A, T, U> {
     }
 
     #[inline]
-    #[cfg(not(stage0))]
     fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (a_lower, a_upper) = self.a.size_hint();
         let (b_lower, b_upper) = self.b.size_hint();
@@ -664,7 +662,6 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for MapIterator<'self, A, B, T> {
     }
 
     #[inline]
-    #[cfg(not(stage0))]
     fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         self.iter.size_hint()
     }
@@ -690,7 +687,6 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for FilterIterator<'self, A, T> {
     }
 
     #[inline]
-    #[cfg(not(stage0))]
     fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (_, upper) = self.iter.size_hint();
         (None, upper) // can't know a lower bound, due to the predicate
@@ -716,7 +712,6 @@ impl<'self, A, B, T: Iterator<A>> Iterator<B> for FilterMapIterator<'self, A, B,
     }
 
     #[inline]
-    #[cfg(not(stage0))]
     fn size_hint(&self) -> (Option<uint>, Option<uint>) {
         let (_, upper) = self.iter.size_hint();
         (None, upper) // can't know a lower bound, due to the predicate
diff --git a/src/libstd/libc.rs b/src/libstd/libc.rs
index 988fb5cc9b1..523645e69a5 100644
--- a/src/libstd/libc.rs
+++ b/src/libstd/libc.rs
@@ -102,10 +102,12 @@ pub use libc::funcs::posix88::stdio::*;
 pub use libc::funcs::posix88::fcntl::*;
 pub use libc::funcs::posix88::dirent::*;
 pub use libc::funcs::posix88::unistd::*;
+pub use libc::funcs::posix88::mman::*;
 
 pub use libc::funcs::posix01::stat_::*;
 pub use libc::funcs::posix01::unistd::*;
 pub use libc::funcs::posix01::glob::*;
+pub use libc::funcs::posix01::mman::*;
 pub use libc::funcs::posix08::unistd::*;
 
 pub use libc::funcs::bsd44::*;
@@ -285,7 +287,7 @@ pub mod types {
             #[cfg(target_arch = "x86")]
             #[cfg(target_arch = "mips")]
             pub mod posix01 {
-                use libc::types::os::arch::c95::{c_short, c_long, c_ulong, time_t};
+                use libc::types::os::arch::c95::{c_short, c_long, time_t};
                 use libc::types::os::arch::posix88::{dev_t, gid_t, ino_t};
                 use libc::types::os::arch::posix88::{mode_t, off_t};
                 use libc::types::os::arch::posix88::{uid_t};
@@ -903,52 +905,56 @@ pub mod consts {
     #[cfg(target_os = "win32")]
     pub mod os {
         pub mod c95 {
-            pub static EXIT_FAILURE : int = 1;
-            pub static EXIT_SUCCESS : int = 0;
-            pub static RAND_MAX : int = 32767;
-            pub static EOF : int = -1;
-            pub static SEEK_SET : int = 0;
-            pub static SEEK_CUR : int = 1;
-            pub static SEEK_END : int = 2;
-            pub static _IOFBF : int = 0;
-            pub static _IONBF : int = 4;
-            pub static _IOLBF : int = 64;
-            pub static BUFSIZ : uint = 512_u;
-            pub static FOPEN_MAX : uint = 20_u;
-            pub static FILENAME_MAX : uint = 260_u;
-            pub static L_tmpnam : uint = 16_u;
-            pub static TMP_MAX : uint = 32767_u;
+            use libc::types::os::arch::c95::{c_int, c_uint};
+
+            pub static EXIT_FAILURE : c_int = 1;
+            pub static EXIT_SUCCESS : c_int = 0;
+            pub static RAND_MAX : c_int = 32767;
+            pub static EOF : c_int = -1;
+            pub static SEEK_SET : c_int = 0;
+            pub static SEEK_CUR : c_int = 1;
+            pub static SEEK_END : c_int = 2;
+            pub static _IOFBF : c_int = 0;
+            pub static _IONBF : c_int = 4;
+            pub static _IOLBF : c_int = 64;
+            pub static BUFSIZ : c_uint = 512_u32;
+            pub static FOPEN_MAX : c_uint = 20_u32;
+            pub static FILENAME_MAX : c_uint = 260_u32;
+            pub static L_tmpnam : c_uint = 16_u32;
+            pub static TMP_MAX : c_uint = 32767_u32;
         }
         pub mod c99 {
         }
         pub mod posix88 {
-            pub static O_RDONLY : int = 0;
-            pub static O_WRONLY : int = 1;
-            pub static O_RDWR : int = 2;
-            pub static O_APPEND : int = 8;
-            pub static O_CREAT : int = 256;
-            pub static O_EXCL : int = 1024;
-            pub static O_TRUNC : int = 512;
-            pub static S_IFIFO : int = 4096;
-            pub static S_IFCHR : int = 8192;
-            pub static S_IFBLK : int = 12288;
-            pub static S_IFDIR : int = 16384;
-            pub static S_IFREG : int = 32768;
-            pub static S_IFMT : int = 61440;
-            pub static S_IEXEC : int = 64;
-            pub static S_IWRITE : int = 128;
-            pub static S_IREAD : int = 256;
-            pub static S_IRWXU : int = 448;
-            pub static S_IXUSR : int = 64;
-            pub static S_IWUSR : int = 128;
-            pub static S_IRUSR : int = 256;
-            pub static F_OK : int = 0;
-            pub static R_OK : int = 4;
-            pub static W_OK : int = 2;
-            pub static X_OK : int = 1;
-            pub static STDIN_FILENO : int = 0;
-            pub static STDOUT_FILENO : int = 1;
-            pub static STDERR_FILENO : int = 2;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_RDONLY : c_int = 0;
+            pub static O_WRONLY : c_int = 1;
+            pub static O_RDWR : c_int = 2;
+            pub static O_APPEND : c_int = 8;
+            pub static O_CREAT : c_int = 256;
+            pub static O_EXCL : c_int = 1024;
+            pub static O_TRUNC : c_int = 512;
+            pub static S_IFIFO : c_int = 4096;
+            pub static S_IFCHR : c_int = 8192;
+            pub static S_IFBLK : c_int = 12288;
+            pub static S_IFDIR : c_int = 16384;
+            pub static S_IFREG : c_int = 32768;
+            pub static S_IFMT : c_int = 61440;
+            pub static S_IEXEC : c_int = 64;
+            pub static S_IWRITE : c_int = 128;
+            pub static S_IREAD : c_int = 256;
+            pub static S_IRWXU : c_int = 448;
+            pub static S_IXUSR : c_int = 64;
+            pub static S_IWUSR : c_int = 128;
+            pub static S_IRUSR : c_int = 256;
+            pub static F_OK : c_int = 0;
+            pub static R_OK : c_int = 4;
+            pub static W_OK : c_int = 2;
+            pub static X_OK : c_int = 1;
+            pub static STDIN_FILENO : c_int = 0;
+            pub static STDOUT_FILENO : c_int = 1;
+            pub static STDERR_FILENO : c_int = 2;
         }
         pub mod posix01 {
         }
@@ -957,18 +963,19 @@ pub mod consts {
         pub mod bsd44 {
         }
         pub mod extra {
+            use libc::types::os::arch::c95::c_int;
             use libc::types::os::arch::extra::{DWORD, BOOL};
 
             pub static TRUE : BOOL = 1;
             pub static FALSE : BOOL = 0;
 
-            pub static O_TEXT : int = 16384;
-            pub static O_BINARY : int = 32768;
-            pub static O_NOINHERIT: int = 128;
+            pub static O_TEXT : c_int = 16384;
+            pub static O_BINARY : c_int = 32768;
+            pub static O_NOINHERIT: c_int = 128;
 
-            pub static ERROR_SUCCESS : int = 0;
-            pub static ERROR_INSUFFICIENT_BUFFER : int = 122;
-            pub static INVALID_HANDLE_VALUE: int = -1;
+            pub static ERROR_SUCCESS : c_int = 0;
+            pub static ERROR_INSUFFICIENT_BUFFER : c_int = 122;
+            pub static INVALID_HANDLE_VALUE: c_int = -1;
 
             pub static DELETE : DWORD = 0x00010000;
             pub static READ_CONTROL : DWORD = 0x00020000;
@@ -1021,21 +1028,23 @@ pub mod consts {
     #[cfg(target_os = "android")]
     pub mod os {
         pub mod c95 {
-            pub static EXIT_FAILURE : int = 1;
-            pub static EXIT_SUCCESS : int = 0;
-            pub static RAND_MAX : int = 2147483647;
-            pub static EOF : int = -1;
-            pub static SEEK_SET : int = 0;
-            pub static SEEK_CUR : int = 1;
-            pub static SEEK_END : int = 2;
-            pub static _IOFBF : int = 0;
-            pub static _IONBF : int = 2;
-            pub static _IOLBF : int = 1;
-            pub static BUFSIZ : uint = 8192_u;
-            pub static FOPEN_MAX : uint = 16_u;
-            pub static FILENAME_MAX : uint = 4096_u;
-            pub static L_tmpnam : uint = 20_u;
-            pub static TMP_MAX : uint = 238328_u;
+            use libc::types::os::arch::c95::{c_int, c_uint};
+
+            pub static EXIT_FAILURE : c_int = 1;
+            pub static EXIT_SUCCESS : c_int = 0;
+            pub static RAND_MAX : c_int = 2147483647;
+            pub static EOF : c_int = -1;
+            pub static SEEK_SET : c_int = 0;
+            pub static SEEK_CUR : c_int = 1;
+            pub static SEEK_END : c_int = 2;
+            pub static _IOFBF : c_int = 0;
+            pub static _IONBF : c_int = 2;
+            pub static _IOLBF : c_int = 1;
+            pub static BUFSIZ : c_uint = 8192_u32;
+            pub static FOPEN_MAX : c_uint = 16_u32;
+            pub static FILENAME_MAX : c_uint = 4096_u32;
+            pub static L_tmpnam : c_uint = 20_u32;
+            pub static TMP_MAX : c_uint = 238328_u32;
         }
         pub mod c99 {
         }
@@ -1043,309 +1052,791 @@ pub mod consts {
         #[cfg(target_arch = "x86_64")]
         #[cfg(target_arch = "arm")]
         pub mod posix88 {
-            pub static O_RDONLY : int = 0;
-            pub static O_WRONLY : int = 1;
-            pub static O_RDWR : int = 2;
-            pub static O_APPEND : int = 1024;
-            pub static O_CREAT : int = 64;
-            pub static O_EXCL : int = 128;
-            pub static O_TRUNC : int = 512;
-            pub static S_IFIFO : int = 4096;
-            pub static S_IFCHR : int = 8192;
-            pub static S_IFBLK : int = 24576;
-            pub static S_IFDIR : int = 16384;
-            pub static S_IFREG : int = 32768;
-            pub static S_IFMT : int = 61440;
-            pub static S_IEXEC : int = 64;
-            pub static S_IWRITE : int = 128;
-            pub static S_IREAD : int = 256;
-            pub static S_IRWXU : int = 448;
-            pub static S_IXUSR : int = 64;
-            pub static S_IWUSR : int = 128;
-            pub static S_IRUSR : int = 256;
-            pub static F_OK : int = 0;
-            pub static R_OK : int = 4;
-            pub static W_OK : int = 2;
-            pub static X_OK : int = 1;
-            pub static STDIN_FILENO : int = 0;
-            pub static STDOUT_FILENO : int = 1;
-            pub static STDERR_FILENO : int = 2;
-            pub static F_LOCK : int = 1;
-            pub static F_TEST : int = 3;
-            pub static F_TLOCK : int = 2;
-            pub static F_ULOCK : int = 0;
-            pub static SIGHUP : int = 1;
-            pub static SIGINT : int = 2;
-            pub static SIGQUIT : int = 3;
-            pub static SIGILL : int = 4;
-            pub static SIGABRT : int = 6;
-            pub static SIGFPE : int = 8;
-            pub static SIGKILL : int = 9;
-            pub static SIGSEGV : int = 11;
-            pub static SIGPIPE : int = 13;
-            pub static SIGALRM : int = 14;
-            pub static SIGTERM : int = 15;
+            use libc::types::os::arch::c95::c_int;
+            use libc::types::common::c95::c_void;
+
+            pub static O_RDONLY : c_int = 0;
+            pub static O_WRONLY : c_int = 1;
+            pub static O_RDWR : c_int = 2;
+            pub static O_APPEND : c_int = 1024;
+            pub static O_CREAT : c_int = 64;
+            pub static O_EXCL : c_int = 128;
+            pub static O_TRUNC : c_int = 512;
+            pub static S_IFIFO : c_int = 4096;
+            pub static S_IFCHR : c_int = 8192;
+            pub static S_IFBLK : c_int = 24576;
+            pub static S_IFDIR : c_int = 16384;
+            pub static S_IFREG : c_int = 32768;
+            pub static S_IFMT : c_int = 61440;
+            pub static S_IEXEC : c_int = 64;
+            pub static S_IWRITE : c_int = 128;
+            pub static S_IREAD : c_int = 256;
+            pub static S_IRWXU : c_int = 448;
+            pub static S_IXUSR : c_int = 64;
+            pub static S_IWUSR : c_int = 128;
+            pub static S_IRUSR : c_int = 256;
+            pub static F_OK : c_int = 0;
+            pub static R_OK : c_int = 4;
+            pub static W_OK : c_int = 2;
+            pub static X_OK : c_int = 1;
+            pub static STDIN_FILENO : c_int = 0;
+            pub static STDOUT_FILENO : c_int = 1;
+            pub static STDERR_FILENO : c_int = 2;
+            pub static F_LOCK : c_int = 1;
+            pub static F_TEST : c_int = 3;
+            pub static F_TLOCK : c_int = 2;
+            pub static F_ULOCK : c_int = 0;
+            pub static SIGHUP : c_int = 1;
+            pub static SIGINT : c_int = 2;
+            pub static SIGQUIT : c_int = 3;
+            pub static SIGILL : c_int = 4;
+            pub static SIGABRT : c_int = 6;
+            pub static SIGFPE : c_int = 8;
+            pub static SIGKILL : c_int = 9;
+            pub static SIGSEGV : c_int = 11;
+            pub static SIGPIPE : c_int = 13;
+            pub static SIGALRM : c_int = 14;
+            pub static SIGTERM : c_int = 15;
+
+            pub static PROT_NONE : c_int = 0;
+            pub static PROT_READ : c_int = 1;
+            pub static PROT_WRITE : c_int = 2;
+            pub static PROT_EXEC : c_int = 4;
+
+            pub static MAP_FILE : c_int = 0x0000;
+            pub static MAP_SHARED : c_int = 0x0001;
+            pub static MAP_PRIVATE : c_int = 0x0002;
+            pub static MAP_FIXED : c_int = 0x0010;
+            pub static MAP_ANON : c_int = 0x1000;
+
+            pub static MAP_FAILED : *c_void = -1 as *c_void;
+
+            pub static MCL_CURRENT : c_int = 0x0001;
+            pub static MCL_FUTURE : c_int = 0x0002;
+
+            pub static MS_ASYNC : c_int = 0x0001;
+            pub static MS_INVALIDATE : c_int = 0x0002;
+            pub static MS_SYNC : c_int = 0x0004;
         }
         #[cfg(target_arch = "mips")]
         pub mod posix88 {
-            pub static O_RDONLY : int = 0;
-            pub static O_WRONLY : int = 1;
-            pub static O_RDWR : int = 2;
-            pub static O_APPEND : int = 8;
-            pub static O_CREAT : int = 256;
-            pub static O_EXCL : int = 1024;
-            pub static O_TRUNC : int = 512;
-            pub static S_IFIFO : int = 4096;
-            pub static S_IFCHR : int = 8192;
-            pub static S_IFBLK : int = 24576;
-            pub static S_IFDIR : int = 16384;
-            pub static S_IFREG : int = 32768;
-            pub static S_IFMT : int = 61440;
-            pub static S_IEXEC : int = 64;
-            pub static S_IWRITE : int = 128;
-            pub static S_IREAD : int = 256;
-            pub static S_IRWXU : int = 448;
-            pub static S_IXUSR : int = 64;
-            pub static S_IWUSR : int = 128;
-            pub static S_IRUSR : int = 256;
-            pub static F_OK : int = 0;
-            pub static R_OK : int = 4;
-            pub static W_OK : int = 2;
-            pub static X_OK : int = 1;
-            pub static STDIN_FILENO : int = 0;
-            pub static STDOUT_FILENO : int = 1;
-            pub static STDERR_FILENO : int = 2;
-            pub static F_LOCK : int = 1;
-            pub static F_TEST : int = 3;
-            pub static F_TLOCK : int = 2;
-            pub static F_ULOCK : int = 0;
-            pub static SIGHUP : int = 1;
-            pub static SIGINT : int = 2;
-            pub static SIGQUIT : int = 3;
-            pub static SIGILL : int = 4;
-            pub static SIGABRT : int = 6;
-            pub static SIGFPE : int = 8;
-            pub static SIGKILL : int = 9;
-            pub static SIGSEGV : int = 11;
-            pub static SIGPIPE : int = 13;
-            pub static SIGALRM : int = 14;
-            pub static SIGTERM : int = 15;
+            use libc::types::os::arch::c95::c_int;
+            use libc::types::common::c95::c_void;
+
+            pub static O_RDONLY : c_int = 0;
+            pub static O_WRONLY : c_int = 1;
+            pub static O_RDWR : c_int = 2;
+            pub static O_APPEND : c_int = 8;
+            pub static O_CREAT : c_int = 256;
+            pub static O_EXCL : c_int = 1024;
+            pub static O_TRUNC : c_int = 512;
+            pub static S_IFIFO : c_int = 4096;
+            pub static S_IFCHR : c_int = 8192;
+            pub static S_IFBLK : c_int = 24576;
+            pub static S_IFDIR : c_int = 16384;
+            pub static S_IFREG : c_int = 32768;
+            pub static S_IFMT : c_int = 61440;
+            pub static S_IEXEC : c_int = 64;
+            pub static S_IWRITE : c_int = 128;
+            pub static S_IREAD : c_int = 256;
+            pub static S_IRWXU : c_int = 448;
+            pub static S_IXUSR : c_int = 64;
+            pub static S_IWUSR : c_int = 128;
+            pub static S_IRUSR : c_int = 256;
+            pub static F_OK : c_int = 0;
+            pub static R_OK : c_int = 4;
+            pub static W_OK : c_int = 2;
+            pub static X_OK : c_int = 1;
+            pub static STDIN_FILENO : c_int = 0;
+            pub static STDOUT_FILENO : c_int = 1;
+            pub static STDERR_FILENO : c_int = 2;
+            pub static F_LOCK : c_int = 1;
+            pub static F_TEST : c_int = 3;
+            pub static F_TLOCK : c_int = 2;
+            pub static F_ULOCK : c_int = 0;
+            pub static SIGHUP : c_int = 1;
+            pub static SIGINT : c_int = 2;
+            pub static SIGQUIT : c_int = 3;
+            pub static SIGILL : c_int = 4;
+            pub static SIGABRT : c_int = 6;
+            pub static SIGFPE : c_int = 8;
+            pub static SIGKILL : c_int = 9;
+            pub static SIGSEGV : c_int = 11;
+            pub static SIGPIPE : c_int = 13;
+            pub static SIGALRM : c_int = 14;
+            pub static SIGTERM : c_int = 15;
+
+            pub static PROT_NONE : c_int = 0;
+            pub static PROT_READ : c_int = 1;
+            pub static PROT_WRITE : c_int = 2;
+            pub static PROT_EXEC : c_int = 4;
+
+            pub static MAP_FILE : c_int = 0x0000;
+            pub static MAP_SHARED : c_int = 0x0001;
+            pub static MAP_PRIVATE : c_int = 0x0002;
+            pub static MAP_FIXED : c_int = 0x0010;
+            pub static MAP_ANON : c_int = 0x1000;
+
+            pub static MAP_FAILED : *c_void = -1 as *c_void;
+
+            pub static MCL_CURRENT : c_int = 0x0001;
+            pub static MCL_FUTURE : c_int = 0x0002;
+
+            pub static MS_ASYNC : c_int = 0x0001;
+            pub static MS_INVALIDATE : c_int = 0x0002;
+            pub static MS_SYNC : c_int = 0x0004;
+
+            pub static _SC_ARG_MAX : c_int = 0;
+            pub static _SC_CHILD_MAX : c_int = 1;
+            pub static _SC_CLK_TCK : c_int = 2;
+            pub static _SC_NGROUPS_MAX : c_int = 3;
+            pub static _SC_OPEN_MAX : c_int = 4;
+            pub static _SC_STREAM_MAX : c_int = 5;
+            pub static _SC_TZNAME_MAX : c_int = 6;
+            pub static _SC_JOB_CONTROL : c_int = 7;
+            pub static _SC_SAVED_IDS : c_int = 8;
+            pub static _SC_REALTIME_SIGNALS : c_int = 9;
+            pub static _SC_PRIORITY_SCHEDULING : c_int = 10;
+            pub static _SC_TIMERS : c_int = 11;
+            pub static _SC_ASYNCHRONOUS_IO : c_int = 12;
+            pub static _SC_PRIORITIZED_IO : c_int = 13;
+            pub static _SC_SYNCHRONIZED_IO : c_int = 14;
+            pub static _SC_FSYNC : c_int = 15;
+            pub static _SC_MAPPED_FILES : c_int = 16;
+            pub static _SC_MEMLOCK : c_int = 17;
+            pub static _SC_MEMLOCK_RANGE : c_int = 18;
+            pub static _SC_MEMORY_PROTECTION : c_int = 19;
+            pub static _SC_MESSAGE_PASSING : c_int = 20;
+            pub static _SC_SEMAPHORES : c_int = 21;
+            pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 22;
+            pub static _SC_AIO_LISTIO_MAX : c_int = 23;
+            pub static _SC_AIO_MAX : c_int = 24;
+            pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 25;
+            pub static _SC_DELAYTIMER_MAX : c_int = 26;
+            pub static _SC_MQ_OPEN_MAX : c_int = 27;
+            pub static _SC_VERSION : c_int = 29;
+            pub static _SC_PAGESIZE : c_int = 30;
+            pub static _SC_RTSIG_MAX : c_int = 31;
+            pub static _SC_SEM_NSEMS_MAX : c_int = 32;
+            pub static _SC_SEM_VALUE_MAX : c_int = 33;
+            pub static _SC_SIGQUEUE_MAX : c_int = 34;
+            pub static _SC_TIMER_MAX : c_int = 35;
+            pub static _SC_BC_BASE_MAX : c_int = 36;
+            pub static _SC_BC_DIM_MAX : c_int = 37;
+            pub static _SC_BC_SCALE_MAX : c_int = 38;
+            pub static _SC_BC_STRING_MAX : c_int = 39;
+            pub static _SC_COLL_WEIGHTS_MAX : c_int = 40;
+            pub static _SC_EXPR_NEST_MAX : c_int = 42;
+            pub static _SC_LINE_MAX : c_int = 43;
+            pub static _SC_RE_DUP_MAX : c_int = 44;
+            pub static _SC_2_VERSION : c_int = 46;
+            pub static _SC_2_C_BIND : c_int = 47;
+            pub static _SC_2_C_DEV : c_int = 48;
+            pub static _SC_2_FORT_DEV : c_int = 49;
+            pub static _SC_2_FORT_RUN : c_int = 50;
+            pub static _SC_2_SW_DEV : c_int = 51;
+            pub static _SC_2_LOCALEDEF : c_int = 52;
+            pub static _SC_2_CHAR_TERM : c_int = 95;
+            pub static _SC_2_C_VERSION : c_int = 96;
+            pub static _SC_2_UPE : c_int = 97;
+            pub static _SC_XBS5_ILP32_OFF32 : c_int = 125;
+            pub static _SC_XBS5_ILP32_OFFBIG : c_int = 126;
+            pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 128;
         }
         pub mod posix01 {
-            pub static SIGTRAP : int = 5;
-
-            pub static GLOB_ERR      : int = 1 << 0;
-            pub static GLOB_MARK     : int = 1 << 1;
-            pub static GLOB_NOSORT   : int = 1 << 2;
-            pub static GLOB_DOOFFS   : int = 1 << 3;
-            pub static GLOB_NOCHECK  : int = 1 << 4;
-            pub static GLOB_APPEND   : int = 1 << 5;
-            pub static GLOB_NOESCAPE : int = 1 << 6;
-
-            pub static GLOB_NOSPACE  : int = 1;
-            pub static GLOB_ABORTED  : int = 2;
-            pub static GLOB_NOMATCH  : int = 3;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static SIGTRAP : c_int = 5;
+
+            pub static GLOB_ERR      : c_int = 1 << 0;
+            pub static GLOB_MARK     : c_int = 1 << 1;
+            pub static GLOB_NOSORT   : c_int = 1 << 2;
+            pub static GLOB_DOOFFS   : c_int = 1 << 3;
+            pub static GLOB_NOCHECK  : c_int = 1 << 4;
+            pub static GLOB_APPEND   : c_int = 1 << 5;
+            pub static GLOB_NOESCAPE : c_int = 1 << 6;
+
+            pub static GLOB_NOSPACE  : c_int = 1;
+            pub static GLOB_ABORTED  : c_int = 2;
+            pub static GLOB_NOMATCH  : c_int = 3;
+
+            pub static POSIX_MADV_NORMAL : c_int = 0;
+            pub static POSIX_MADV_RANDOM : c_int = 1;
+            pub static POSIX_MADV_SEQUENTIAL : c_int = 2;
+            pub static POSIX_MADV_WILLNEED : c_int = 3;
+            pub static POSIX_MADV_DONTNEED : c_int = 4;
+
+            pub static _SC_MQ_PRIO_MAX : c_int = 28;
+            pub static _SC_IOV_MAX : c_int = 60;
+            pub static _SC_GETGR_R_SIZE_MAX : c_int = 69;
+            pub static _SC_GETPW_R_SIZE_MAX : c_int = 70;
+            pub static _SC_LOGIN_NAME_MAX : c_int = 71;
+            pub static _SC_TTY_NAME_MAX : c_int = 72;
+            pub static _SC_THREADS : c_int = 67;
+            pub static _SC_THREAD_SAFE_FUNCTIONS : c_int = 68;
+            pub static _SC_THREAD_DESTRUCTOR_ITERATIONS : c_int = 73;
+            pub static _SC_THREAD_KEYS_MAX : c_int = 74;
+            pub static _SC_THREAD_STACK_MIN : c_int = 75;
+            pub static _SC_THREAD_THREADS_MAX : c_int = 76;
+            pub static _SC_THREAD_ATTR_STACKADDR : c_int = 77;
+            pub static _SC_THREAD_ATTR_STACKSIZE : c_int = 78;
+            pub static _SC_THREAD_PRIORITY_SCHEDULING : c_int = 79;
+            pub static _SC_THREAD_PRIO_INHERIT : c_int = 80;
+            pub static _SC_THREAD_PRIO_PROTECT : c_int = 81;
+            pub static _SC_THREAD_PROCESS_SHARED : c_int = 82;
+            pub static _SC_ATEXIT_MAX : c_int = 87;
+            pub static _SC_XOPEN_VERSION : c_int = 89;
+            pub static _SC_XOPEN_XCU_VERSION : c_int = 90;
+            pub static _SC_XOPEN_UNIX : c_int = 91;
+            pub static _SC_XOPEN_CRYPT : c_int = 92;
+            pub static _SC_XOPEN_ENH_I18N : c_int = 93;
+            pub static _SC_XOPEN_SHM : c_int = 94;
+            pub static _SC_XOPEN_LEGACY : c_int = 129;
+            pub static _SC_XOPEN_REALTIME : c_int = 130;
+            pub static _SC_XOPEN_REALTIME_THREADS : c_int = 131;
         }
         pub mod posix08 {
         }
         pub mod bsd44 {
+            use libc::types::os::arch::c95::c_int;
+
+            pub static MADV_NORMAL : c_int = 0;
+            pub static MADV_RANDOM : c_int = 1;
+            pub static MADV_SEQUENTIAL : c_int = 2;
+            pub static MADV_WILLNEED : c_int = 3;
+            pub static MADV_DONTNEED : c_int = 4;
+            pub static MADV_REMOVE : c_int = 9;
+            pub static MADV_DONTFORK : c_int = 10;
+            pub static MADV_DOFORK : c_int = 11;
+            pub static MADV_MERGEABLE : c_int = 12;
+            pub static MADV_UNMERGEABLE : c_int = 13;
+            pub static MADV_HWPOISON : c_int = 100;
         }
         #[cfg(target_arch = "x86")]
         #[cfg(target_arch = "x86_64")]
         #[cfg(target_arch = "arm")]
         pub mod extra {
-            pub static O_RSYNC : int = 1052672;
-            pub static O_DSYNC : int = 4096;
-            pub static O_SYNC : int = 1052672;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_RSYNC : c_int = 1052672;
+            pub static O_DSYNC : c_int = 4096;
+            pub static O_SYNC : c_int = 1052672;
+
+            pub static PROT_GROWSDOWN : c_int = 0x010000000;
+            pub static PROT_GROWSUP : c_int = 0x020000000;
+
+            pub static MAP_TYPE : c_int = 0x000f;
+            pub static MAP_ANONONYMOUS : c_int = 0x1000;
+            pub static MAP_32BIT : c_int = 0x0040;
+            pub static MAP_GROWSDOWN : c_int = 0x0100;
+            pub static MAP_DENYWRITE : c_int = 0x0800;
+            pub static MAP_EXECUTABLE : c_int = 0x01000;
+            pub static MAP_LOCKED : c_int = 0x02000;
+            pub static MAP_NONRESERVE : c_int = 0x04000;
+            pub static MAP_POPULATE : c_int = 0x08000;
+            pub static MAP_NONBLOCK : c_int = 0x010000;
+            pub static MAP_STACK : c_int = 0x020000;
         }
         #[cfg(target_arch = "mips")]
         pub mod extra {
-            pub static O_RSYNC : int = 16400;
-            pub static O_DSYNC : int = 16;
-            pub static O_SYNC : int = 16400;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_RSYNC : c_int = 16400;
+            pub static O_DSYNC : c_int = 16;
+            pub static O_SYNC : c_int = 16400;
+
+            pub static PROT_GROWSDOWN : c_int = 0x010000000;
+            pub static PROT_GROWSUP : c_int = 0x020000000;
+
+            pub static MAP_TYPE : c_int = 0x000f;
+            pub static MAP_ANONONYMOUS : c_int = 0x1000;
+            pub static MAP_32BIT : c_int = 0x0040;
+            pub static MAP_GROWSDOWN : c_int = 0x0100;
+            pub static MAP_DENYWRITE : c_int = 0x0800;
+            pub static MAP_EXECUTABLE : c_int = 0x01000;
+            pub static MAP_LOCKED : c_int = 0x02000;
+            pub static MAP_NONRESERVE : c_int = 0x04000;
+            pub static MAP_POPULATE : c_int = 0x08000;
+            pub static MAP_NONBLOCK : c_int = 0x010000;
+            pub static MAP_STACK : c_int = 0x020000;
         }
     }
 
     #[cfg(target_os = "freebsd")]
     pub mod os {
         pub mod c95 {
-            pub static EXIT_FAILURE : int = 1;
-            pub static EXIT_SUCCESS : int = 0;
-            pub static RAND_MAX : int = 2147483647;
-            pub static EOF : int = -1;
-            pub static SEEK_SET : int = 0;
-            pub static SEEK_CUR : int = 1;
-            pub static SEEK_END : int = 2;
-            pub static _IOFBF : int = 0;
-            pub static _IONBF : int = 2;
-            pub static _IOLBF : int = 1;
-            pub static BUFSIZ : uint = 1024_u;
-            pub static FOPEN_MAX : uint = 20_u;
-            pub static FILENAME_MAX : uint = 1024_u;
-            pub static L_tmpnam : uint = 1024_u;
-            pub static TMP_MAX : uint = 308915776_u;
+            use libc::types::os::arch::c95::{c_int, c_uint};
+
+            pub static EXIT_FAILURE : c_int = 1;
+            pub static EXIT_SUCCESS : c_int = 0;
+            pub static RAND_MAX : c_int = 2147483647;
+            pub static EOF : c_int = -1;
+            pub static SEEK_SET : c_int = 0;
+            pub static SEEK_CUR : c_int = 1;
+            pub static SEEK_END : c_int = 2;
+            pub static _IOFBF : c_int = 0;
+            pub static _IONBF : c_int = 2;
+            pub static _IOLBF : c_int = 1;
+            pub static BUFSIZ : c_uint = 1024_u32;
+            pub static FOPEN_MAX : c_uint = 20_u32;
+            pub static FILENAME_MAX : c_uint = 1024_u32;
+            pub static L_tmpnam : c_uint = 1024_u32;
+            pub static TMP_MAX : c_uint = 308915776_u32;
         }
         pub mod c99 {
         }
         pub mod posix88 {
-            pub static O_RDONLY : int = 0;
-            pub static O_WRONLY : int = 1;
-            pub static O_RDWR : int = 2;
-            pub static O_APPEND : int = 8;
-            pub static O_CREAT : int = 512;
-            pub static O_EXCL : int = 2048;
-            pub static O_TRUNC : int = 1024;
-            pub static S_IFIFO : int = 4096;
-            pub static S_IFCHR : int = 8192;
-            pub static S_IFBLK : int = 24576;
-            pub static S_IFDIR : int = 16384;
-            pub static S_IFREG : int = 32768;
-            pub static S_IFMT : int = 61440;
-            pub static S_IEXEC : int = 64;
-            pub static S_IWRITE : int = 128;
-            pub static S_IREAD : int = 256;
-            pub static S_IRWXU : int = 448;
-            pub static S_IXUSR : int = 64;
-            pub static S_IWUSR : int = 128;
-            pub static S_IRUSR : int = 256;
-            pub static F_OK : int = 0;
-            pub static R_OK : int = 4;
-            pub static W_OK : int = 2;
-            pub static X_OK : int = 1;
-            pub static STDIN_FILENO : int = 0;
-            pub static STDOUT_FILENO : int = 1;
-            pub static STDERR_FILENO : int = 2;
-            pub static F_LOCK : int = 1;
-            pub static F_TEST : int = 3;
-            pub static F_TLOCK : int = 2;
-            pub static F_ULOCK : int = 0;
-            pub static SIGHUP : int = 1;
-            pub static SIGINT : int = 2;
-            pub static SIGQUIT : int = 3;
-            pub static SIGILL : int = 4;
-            pub static SIGABRT : int = 6;
-            pub static SIGFPE : int = 8;
-            pub static SIGKILL : int = 9;
-            pub static SIGSEGV : int = 11;
-            pub static SIGPIPE : int = 13;
-            pub static SIGALRM : int = 14;
-            pub static SIGTERM : int = 15;
+            use libc::types::common::c95::c_void;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_RDONLY : c_int = 0;
+            pub static O_WRONLY : c_int = 1;
+            pub static O_RDWR : c_int = 2;
+            pub static O_APPEND : c_int = 8;
+            pub static O_CREAT : c_int = 512;
+            pub static O_EXCL : c_int = 2048;
+            pub static O_TRUNC : c_int = 1024;
+            pub static S_IFIFO : c_int = 4096;
+            pub static S_IFCHR : c_int = 8192;
+            pub static S_IFBLK : c_int = 24576;
+            pub static S_IFDIR : c_int = 16384;
+            pub static S_IFREG : c_int = 32768;
+            pub static S_IFMT : c_int = 61440;
+            pub static S_IEXEC : c_int = 64;
+            pub static S_IWRITE : c_int = 128;
+            pub static S_IREAD : c_int = 256;
+            pub static S_IRWXU : c_int = 448;
+            pub static S_IXUSR : c_int = 64;
+            pub static S_IWUSR : c_int = 128;
+            pub static S_IRUSR : c_int = 256;
+            pub static F_OK : c_int = 0;
+            pub static R_OK : c_int = 4;
+            pub static W_OK : c_int = 2;
+            pub static X_OK : c_int = 1;
+            pub static STDIN_FILENO : c_int = 0;
+            pub static STDOUT_FILENO : c_int = 1;
+            pub static STDERR_FILENO : c_int = 2;
+            pub static F_LOCK : c_int = 1;
+            pub static F_TEST : c_int = 3;
+            pub static F_TLOCK : c_int = 2;
+            pub static F_ULOCK : c_int = 0;
+            pub static SIGHUP : c_int = 1;
+            pub static SIGINT : c_int = 2;
+            pub static SIGQUIT : c_int = 3;
+            pub static SIGILL : c_int = 4;
+            pub static SIGABRT : c_int = 6;
+            pub static SIGFPE : c_int = 8;
+            pub static SIGKILL : c_int = 9;
+            pub static SIGSEGV : c_int = 11;
+            pub static SIGPIPE : c_int = 13;
+            pub static SIGALRM : c_int = 14;
+            pub static SIGTERM : c_int = 15;
+
+            pub static PROT_NONE : c_int = 0;
+            pub static PROT_READ : c_int = 1;
+            pub static PROT_WRITE : c_int = 2;
+            pub static PROT_EXEC : c_int = 4;
+
+            pub static MAP_FILE : c_int = 0x0000;
+            pub static MAP_SHARED : c_int = 0x0001;
+            pub static MAP_PRIVATE : c_int = 0x0002;
+            pub static MAP_FIXED : c_int = 0x0010;
+            pub static MAP_ANON : c_int = 0x1000;
+
+            pub static MAP_FAILED : *c_void = -1 as *c_void;
+
+            pub static MCL_CURRENT : c_int = 0x0001;
+            pub static MCL_FUTURE : c_int = 0x0002;
+
+            pub static MS_SYNC : c_int = 0x0000;
+            pub static MS_ASYNC : c_int = 0x0001;
+            pub static MS_INVALIDATE : c_int = 0x0002;
+
+            pub static _SC_ARG_MAX : c_int = 1;
+            pub static _SC_CHILD_MAX : c_int = 2;
+            pub static _SC_CLK_TCK : c_int = 3;
+            pub static _SC_NGROUPS_MAX : c_int = 4;
+            pub static _SC_OPEN_MAX : c_int = 5;
+            pub static _SC_JOB_CONTROL : c_int = 6;
+            pub static _SC_SAVED_IDS : c_int = 7;
+            pub static _SC_VERSION : c_int = 8;
+            pub static _SC_BC_BASE_MAX : c_int = 9;
+            pub static _SC_BC_DIM_MAX : c_int = 10;
+            pub static _SC_BC_SCALE_MAX : c_int = 11;
+            pub static _SC_BC_STRING_MAX : c_int = 12;
+            pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
+            pub static _SC_EXPR_NEST_MAX : c_int = 14;
+            pub static _SC_LINE_MAX : c_int = 15;
+            pub static _SC_RE_DUP_MAX : c_int = 16;
+            pub static _SC_2_VERSION : c_int = 17;
+            pub static _SC_2_C_BIND : c_int = 18;
+            pub static _SC_2_C_DEV : c_int = 19;
+            pub static _SC_2_CHAR_TERM : c_int = 20;
+            pub static _SC_2_FORT_DEV : c_int = 21;
+            pub static _SC_2_FORT_RUN : c_int = 22;
+            pub static _SC_2_LOCALEDEF : c_int = 23;
+            pub static _SC_2_SW_DEV : c_int = 24;
+            pub static _SC_2_UPE : c_int = 25;
+            pub static _SC_STREAM_MAX : c_int = 26;
+            pub static _SC_TZNAME_MAX : c_int = 27;
+            pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
+            pub static _SC_MAPPED_FILES : c_int = 29;
+            pub static _SC_MEMLOCK : c_int = 30;
+            pub static _SC_MEMLOCK_RANGE : c_int = 31;
+            pub static _SC_MEMORY_PROTECTION : c_int = 32;
+            pub static _SC_MESSAGE_PASSING : c_int = 33;
+            pub static _SC_PRIORITIZED_IO : c_int = 34;
+            pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
+            pub static _SC_REALTIME_SIGNALS : c_int = 36;
+            pub static _SC_SEMAPHORES : c_int = 37;
+            pub static _SC_FSYNC : c_int = 38;
+            pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
+            pub static _SC_SYNCHRONIZED_IO : c_int = 40;
+            pub static _SC_TIMERS : c_int = 41;
+            pub static _SC_AIO_LISTIO_MAX : c_int = 42;
+            pub static _SC_AIO_MAX : c_int = 43;
+            pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
+            pub static _SC_DELAYTIMER_MAX : c_int = 45;
+            pub static _SC_MQ_OPEN_MAX : c_int = 46;
+            pub static _SC_PAGESIZE : c_int = 47;
+            pub static _SC_RTSIG_MAX : c_int = 48;
+            pub static _SC_SEM_NSEMS_MAX : c_int = 49;
+            pub static _SC_SEM_VALUE_MAX : c_int = 50;
+            pub static _SC_SIGQUEUE_MAX : c_int = 51;
+            pub static _SC_TIMER_MAX : c_int = 52;
         }
         pub mod posix01 {
-            pub static SIGTRAP : int = 5;
-
-            pub static GLOB_APPEND   : int = 0x0001;
-            pub static GLOB_DOOFFS   : int = 0x0002;
-            pub static GLOB_ERR      : int = 0x0004;
-            pub static GLOB_MARK     : int = 0x0008;
-            pub static GLOB_NOCHECK  : int = 0x0010;
-            pub static GLOB_NOSORT   : int = 0x0020;
-            pub static GLOB_NOESCAPE : int = 0x2000;
-
-            pub static GLOB_NOSPACE  : int = -1;
-            pub static GLOB_ABORTED  : int = -2;
-            pub static GLOB_NOMATCH  : int = -3;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static SIGTRAP : c_int = 5;
+
+            pub static GLOB_APPEND   : c_int = 0x0001;
+            pub static GLOB_DOOFFS   : c_int = 0x0002;
+            pub static GLOB_ERR      : c_int = 0x0004;
+            pub static GLOB_MARK     : c_int = 0x0008;
+            pub static GLOB_NOCHECK  : c_int = 0x0010;
+            pub static GLOB_NOSORT   : c_int = 0x0020;
+            pub static GLOB_NOESCAPE : c_int = 0x2000;
+
+            pub static GLOB_NOSPACE  : c_int = -1;
+            pub static GLOB_ABORTED  : c_int = -2;
+            pub static GLOB_NOMATCH  : c_int = -3;
+
+            pub static POSIX_MADV_NORMAL : c_int = 0;
+            pub static POSIX_MADV_RANDOM : c_int = 1;
+            pub static POSIX_MADV_SEQUENTIAL : c_int = 2;
+            pub static POSIX_MADV_WILLNEED : c_int = 3;
+            pub static POSIX_MADV_DONTNEED : c_int = 4;
+
+            pub static _SC_IOV_MAX : c_int = 56;
+            pub static _SC_GETGR_R_SIZE_MAX : c_int = 70;
+            pub static _SC_GETPW_R_SIZE_MAX : c_int = 71;
+            pub static _SC_LOGIN_NAME_MAX : c_int = 73;
+            pub static _SC_MQ_PRIO_MAX : c_int = 75;
+            pub static _SC_THREAD_ATTR_STACKADDR : c_int = 82;
+            pub static _SC_THREAD_ATTR_STACKSIZE : c_int = 83;
+            pub static _SC_THREAD_DESTRUCTOR_ITERATIONS : c_int = 85;
+            pub static _SC_THREAD_KEYS_MAX : c_int = 86;
+            pub static _SC_THREAD_PRIO_INHERIT : c_int = 87;
+            pub static _SC_THREAD_PRIO_PROTECT : c_int = 88;
+            pub static _SC_THREAD_PRIORITY_SCHEDULING : c_int = 89;
+            pub static _SC_THREAD_PROCESS_SHARED : c_int = 90;
+            pub static _SC_THREAD_SAFE_FUNCTIONS : c_int = 91;
+            pub static _SC_THREAD_STACK_MIN : c_int = 93;
+            pub static _SC_THREAD_THREADS_MAX : c_int = 94;
+            pub static _SC_THREADS : c_int = 96;
+            pub static _SC_TTY_NAME_MAX : c_int = 101;
+            pub static _SC_ATEXIT_MAX : c_int = 107;
+            pub static _SC_XOPEN_CRYPT : c_int = 108;
+            pub static _SC_XOPEN_ENH_I18N : c_int = 109;
+            pub static _SC_XOPEN_LEGACY : c_int = 110;
+            pub static _SC_XOPEN_REALTIME : c_int = 111;
+            pub static _SC_XOPEN_REALTIME_THREADS : c_int = 112;
+            pub static _SC_XOPEN_SHM : c_int = 113;
+            pub static _SC_XOPEN_UNIX : c_int = 115;
+            pub static _SC_XOPEN_VERSION : c_int = 116;
+            pub static _SC_XOPEN_XCU_VERSION : c_int = 117;
         }
         pub mod posix08 {
         }
         pub mod bsd44 {
+            use libc::types::os::arch::c95::c_int;
+
+            pub static MADV_NORMAL : c_int = 0;
+            pub static MADV_RANDOM : c_int = 1;
+            pub static MADV_SEQUENTIAL : c_int = 2;
+            pub static MADV_WILLNEED : c_int = 3;
+            pub static MADV_DONTNEED : c_int = 4;
+            pub static MADV_FREE : c_int = 5;
+            pub static MADV_NOSYNC : c_int = 6;
+            pub static MADV_AUTOSYNC : c_int = 7;
+            pub static MADV_NOCORE : c_int = 8;
+            pub static MADV_CORE : c_int = 9;
+            pub static MADV_PROTECT : c_int = 10;
+
+            pub static MINCORE_INCORE : c_int =  0x1;
+            pub static MINCORE_REFERENCED : c_int = 0x2;
+            pub static MINCORE_MODIFIED : c_int = 0x4;
+            pub static MINCORE_REFERENCED_OTHER : c_int = 0x8;
+            pub static MINCORE_MODIFIED_OTHER : c_int = 0x10;
+            pub static MINCORE_SUPER : c_int = 0x20;
         }
         pub mod extra {
-            pub static O_SYNC : int = 128;
-            pub static CTL_KERN: int = 1;
-            pub static KERN_PROC: int = 14;
-            pub static KERN_PROC_PATHNAME: int = 12;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_SYNC : c_int = 128;
+            pub static CTL_KERN: c_int = 1;
+            pub static KERN_PROC: c_int = 14;
+            pub static KERN_PROC_PATHNAME: c_int = 12;
+
+            pub static MAP_COPY : c_int = 0x0002;
+            pub static MAP_RENAME : c_int = 0x0020;
+            pub static MAP_NORESERVE : c_int = 0x0040;
+            pub static MAP_HASSEMAPHORE : c_int = 0x0200;
+            pub static MAP_STACK : c_int = 0x0400;
+            pub static MAP_NOSYNC : c_int = 0x0800;
+            pub static MAP_NOCORE : c_int = 0x020000;
         }
     }
 
     #[cfg(target_os = "macos")]
     pub mod os {
         pub mod c95 {
-            pub static EXIT_FAILURE : int = 1;
-            pub static EXIT_SUCCESS : int = 0;
-            pub static RAND_MAX : int = 2147483647;
-            pub static EOF : int = -1;
-            pub static SEEK_SET : int = 0;
-            pub static SEEK_CUR : int = 1;
-            pub static SEEK_END : int = 2;
-            pub static _IOFBF : int = 0;
-            pub static _IONBF : int = 2;
-            pub static _IOLBF : int = 1;
-            pub static BUFSIZ : uint = 1024_u;
-            pub static FOPEN_MAX : uint = 20_u;
-            pub static FILENAME_MAX : uint = 1024_u;
-            pub static L_tmpnam : uint = 1024_u;
-            pub static TMP_MAX : uint = 308915776_u;
+            use libc::types::os::arch::c95::{c_int, c_uint};
+
+            pub static EXIT_FAILURE : c_int = 1;
+            pub static EXIT_SUCCESS : c_int = 0;
+            pub static RAND_MAX : c_int = 2147483647;
+            pub static EOF : c_int = -1;
+            pub static SEEK_SET : c_int = 0;
+            pub static SEEK_CUR : c_int = 1;
+            pub static SEEK_END : c_int = 2;
+            pub static _IOFBF : c_int = 0;
+            pub static _IONBF : c_int = 2;
+            pub static _IOLBF : c_int = 1;
+            pub static BUFSIZ : c_uint = 1024_u32;
+            pub static FOPEN_MAX : c_uint = 20_u32;
+            pub static FILENAME_MAX : c_uint = 1024_u32;
+            pub static L_tmpnam : c_uint = 1024_u32;
+            pub static TMP_MAX : c_uint = 308915776_u32;
         }
         pub mod c99 {
         }
         pub mod posix88 {
-            pub static O_RDONLY : int = 0;
-            pub static O_WRONLY : int = 1;
-            pub static O_RDWR : int = 2;
-            pub static O_APPEND : int = 8;
-            pub static O_CREAT : int = 512;
-            pub static O_EXCL : int = 2048;
-            pub static O_TRUNC : int = 1024;
-            pub static S_IFIFO : int = 4096;
-            pub static S_IFCHR : int = 8192;
-            pub static S_IFBLK : int = 24576;
-            pub static S_IFDIR : int = 16384;
-            pub static S_IFREG : int = 32768;
-            pub static S_IFMT : int = 61440;
-            pub static S_IEXEC : int = 64;
-            pub static S_IWRITE : int = 128;
-            pub static S_IREAD : int = 256;
-            pub static S_IRWXU : int = 448;
-            pub static S_IXUSR : int = 64;
-            pub static S_IWUSR : int = 128;
-            pub static S_IRUSR : int = 256;
-            pub static F_OK : int = 0;
-            pub static R_OK : int = 4;
-            pub static W_OK : int = 2;
-            pub static X_OK : int = 1;
-            pub static STDIN_FILENO : int = 0;
-            pub static STDOUT_FILENO : int = 1;
-            pub static STDERR_FILENO : int = 2;
-            pub static F_LOCK : int = 1;
-            pub static F_TEST : int = 3;
-            pub static F_TLOCK : int = 2;
-            pub static F_ULOCK : int = 0;
-            pub static SIGHUP : int = 1;
-            pub static SIGINT : int = 2;
-            pub static SIGQUIT : int = 3;
-            pub static SIGILL : int = 4;
-            pub static SIGABRT : int = 6;
-            pub static SIGFPE : int = 8;
-            pub static SIGKILL : int = 9;
-            pub static SIGSEGV : int = 11;
-            pub static SIGPIPE : int = 13;
-            pub static SIGALRM : int = 14;
-            pub static SIGTERM : int = 15;
+            use libc::types::common::c95::c_void;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_RDONLY : c_int = 0;
+            pub static O_WRONLY : c_int = 1;
+            pub static O_RDWR : c_int = 2;
+            pub static O_APPEND : c_int = 8;
+            pub static O_CREAT : c_int = 512;
+            pub static O_EXCL : c_int = 2048;
+            pub static O_TRUNC : c_int = 1024;
+            pub static S_IFIFO : c_int = 4096;
+            pub static S_IFCHR : c_int = 8192;
+            pub static S_IFBLK : c_int = 24576;
+            pub static S_IFDIR : c_int = 16384;
+            pub static S_IFREG : c_int = 32768;
+            pub static S_IFMT : c_int = 61440;
+            pub static S_IEXEC : c_int = 64;
+            pub static S_IWRITE : c_int = 128;
+            pub static S_IREAD : c_int = 256;
+            pub static S_IRWXU : c_int = 448;
+            pub static S_IXUSR : c_int = 64;
+            pub static S_IWUSR : c_int = 128;
+            pub static S_IRUSR : c_int = 256;
+            pub static F_OK : c_int = 0;
+            pub static R_OK : c_int = 4;
+            pub static W_OK : c_int = 2;
+            pub static X_OK : c_int = 1;
+            pub static STDIN_FILENO : c_int = 0;
+            pub static STDOUT_FILENO : c_int = 1;
+            pub static STDERR_FILENO : c_int = 2;
+            pub static F_LOCK : c_int = 1;
+            pub static F_TEST : c_int = 3;
+            pub static F_TLOCK : c_int = 2;
+            pub static F_ULOCK : c_int = 0;
+            pub static SIGHUP : c_int = 1;
+            pub static SIGINT : c_int = 2;
+            pub static SIGQUIT : c_int = 3;
+            pub static SIGILL : c_int = 4;
+            pub static SIGABRT : c_int = 6;
+            pub static SIGFPE : c_int = 8;
+            pub static SIGKILL : c_int = 9;
+            pub static SIGSEGV : c_int = 11;
+            pub static SIGPIPE : c_int = 13;
+            pub static SIGALRM : c_int = 14;
+            pub static SIGTERM : c_int = 15;
+
+            pub static PROT_NONE : c_int = 0;
+            pub static PROT_READ : c_int = 1;
+            pub static PROT_WRITE : c_int = 2;
+            pub static PROT_EXEC : c_int = 4;
+
+            pub static MAP_FILE : c_int = 0x0000;
+            pub static MAP_SHARED : c_int = 0x0001;
+            pub static MAP_PRIVATE : c_int = 0x0002;
+            pub static MAP_FIXED : c_int = 0x0010;
+            pub static MAP_ANON : c_int = 0x1000;
+
+            pub static MAP_FAILED : *c_void = -1 as *c_void;
+
+            pub static MCL_CURRENT : c_int = 0x0001;
+            pub static MCL_FUTURE : c_int = 0x0002;
+
+            pub static MS_ASYNC : c_int = 0x0001;
+            pub static MS_INVALIDATE : c_int = 0x0002;
+            pub static MS_SYNC : c_int = 0x0010;
+
+            pub static MS_KILLPAGES : c_int = 0x0004;
+            pub static MS_DEACTIVATE : c_int = 0x0008;
+
+            pub static _SC_ARG_MAX : c_int = 1;
+            pub static _SC_CHILD_MAX : c_int = 2;
+            pub static _SC_CLK_TCK : c_int = 3;
+            pub static _SC_NGROUPS_MAX : c_int = 4;
+            pub static _SC_OPEN_MAX : c_int = 5;
+            pub static _SC_JOB_CONTROL : c_int = 6;
+            pub static _SC_SAVED_IDS : c_int = 7;
+            pub static _SC_VERSION : c_int = 8;
+            pub static _SC_BC_BASE_MAX : c_int = 9;
+            pub static _SC_BC_DIM_MAX : c_int = 10;
+            pub static _SC_BC_SCALE_MAX : c_int = 11;
+            pub static _SC_BC_STRING_MAX : c_int = 12;
+            pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
+            pub static _SC_EXPR_NEST_MAX : c_int = 14;
+            pub static _SC_LINE_MAX : c_int = 15;
+            pub static _SC_RE_DUP_MAX : c_int = 16;
+            pub static _SC_2_VERSION : c_int = 17;
+            pub static _SC_2_C_BIND : c_int = 18;
+            pub static _SC_2_C_DEV : c_int = 19;
+            pub static _SC_2_CHAR_TERM : c_int = 20;
+            pub static _SC_2_FORT_DEV : c_int = 21;
+            pub static _SC_2_FORT_RUN : c_int = 22;
+            pub static _SC_2_LOCALEDEF : c_int = 23;
+            pub static _SC_2_SW_DEV : c_int = 24;
+            pub static _SC_2_UPE : c_int = 25;
+            pub static _SC_STREAM_MAX : c_int = 26;
+            pub static _SC_TZNAME_MAX : c_int = 27;
+            pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
+            pub static _SC_PAGESIZE : c_int = 29;
+            pub static _SC_MEMLOCK : c_int = 30;
+            pub static _SC_MEMLOCK_RANGE : c_int = 31;
+            pub static _SC_MEMORY_PROTECTION : c_int = 32;
+            pub static _SC_MESSAGE_PASSING : c_int = 33;
+            pub static _SC_PRIORITIZED_IO : c_int = 34;
+            pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
+            pub static _SC_REALTIME_SIGNALS : c_int = 36;
+            pub static _SC_SEMAPHORES : c_int = 37;
+            pub static _SC_FSYNC : c_int = 38;
+            pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
+            pub static _SC_SYNCHRONIZED_IO : c_int = 40;
+            pub static _SC_TIMERS : c_int = 41;
+            pub static _SC_AIO_LISTIO_MAX : c_int = 42;
+            pub static _SC_AIO_MAX : c_int = 43;
+            pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
+            pub static _SC_DELAYTIMER_MAX : c_int = 45;
+            pub static _SC_MQ_OPEN_MAX : c_int = 46;
+            pub static _SC_MAPPED_FILES : c_int = 47;
+            pub static _SC_RTSIG_MAX : c_int = 48;
+            pub static _SC_SEM_NSEMS_MAX : c_int = 49;
+            pub static _SC_SEM_VALUE_MAX : c_int = 50;
+            pub static _SC_SIGQUEUE_MAX : c_int = 51;
+            pub static _SC_TIMER_MAX : c_int = 52;
+            pub static _SC_XBS5_ILP32_OFF32 : c_int = 122;
+            pub static _SC_XBS5_ILP32_OFFBIG : c_int = 123;
+            pub static _SC_XBS5_LP64_OFF64 : c_int = 124;
+            pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 125;
         }
         pub mod posix01 {
-            pub static SIGTRAP : int = 5;
-
-            pub static GLOB_APPEND   : int = 0x0001;
-            pub static GLOB_DOOFFS   : int = 0x0002;
-            pub static GLOB_ERR      : int = 0x0004;
-            pub static GLOB_MARK     : int = 0x0008;
-            pub static GLOB_NOCHECK  : int = 0x0010;
-            pub static GLOB_NOSORT   : int = 0x0020;
-            pub static GLOB_NOESCAPE : int = 0x2000;
-
-            pub static GLOB_NOSPACE  : int = -1;
-            pub static GLOB_ABORTED  : int = -2;
-            pub static GLOB_NOMATCH  : int = -3;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static SIGTRAP : c_int = 5;
+
+            pub static GLOB_APPEND   : c_int = 0x0001;
+            pub static GLOB_DOOFFS   : c_int = 0x0002;
+            pub static GLOB_ERR      : c_int = 0x0004;
+            pub static GLOB_MARK     : c_int = 0x0008;
+            pub static GLOB_NOCHECK  : c_int = 0x0010;
+            pub static GLOB_NOSORT   : c_int = 0x0020;
+            pub static GLOB_NOESCAPE : c_int = 0x2000;
+
+            pub static GLOB_NOSPACE  : c_int = -1;
+            pub static GLOB_ABORTED  : c_int = -2;
+            pub static GLOB_NOMATCH  : c_int = -3;
+
+            pub static POSIX_MADV_NORMAL : c_int = 0;
+            pub static POSIX_MADV_RANDOM : c_int = 1;
+            pub static POSIX_MADV_SEQUENTIAL : c_int = 2;
+            pub static POSIX_MADV_WILLNEED : c_int = 3;
+            pub static POSIX_MADV_DONTNEED : c_int = 4;
+
+            pub static _SC_IOV_MAX : c_int = 56;
+            pub static _SC_GETGR_R_SIZE_MAX : c_int = 70;
+            pub static _SC_GETPW_R_SIZE_MAX : c_int = 71;
+            pub static _SC_LOGIN_NAME_MAX : c_int = 73;
+            pub static _SC_MQ_PRIO_MAX : c_int = 75;
+            pub static _SC_THREAD_ATTR_STACKADDR : c_int = 82;
+            pub static _SC_THREAD_ATTR_STACKSIZE : c_int = 83;
+            pub static _SC_THREAD_DESTRUCTOR_ITERATIONS : c_int = 85;
+            pub static _SC_THREAD_KEYS_MAX : c_int = 86;
+            pub static _SC_THREAD_PRIO_INHERIT : c_int = 87;
+            pub static _SC_THREAD_PRIO_PROTECT : c_int = 88;
+            pub static _SC_THREAD_PRIORITY_SCHEDULING : c_int = 89;
+            pub static _SC_THREAD_PROCESS_SHARED : c_int = 90;
+            pub static _SC_THREAD_SAFE_FUNCTIONS : c_int = 91;
+            pub static _SC_THREAD_STACK_MIN : c_int = 93;
+            pub static _SC_THREAD_THREADS_MAX : c_int = 94;
+            pub static _SC_THREADS : c_int = 96;
+            pub static _SC_TTY_NAME_MAX : c_int = 101;
+            pub static _SC_ATEXIT_MAX : c_int = 107;
+            pub static _SC_XOPEN_CRYPT : c_int = 108;
+            pub static _SC_XOPEN_ENH_I18N : c_int = 109;
+            pub static _SC_XOPEN_LEGACY : c_int = 110;
+            pub static _SC_XOPEN_REALTIME : c_int = 111;
+            pub static _SC_XOPEN_REALTIME_THREADS : c_int = 112;
+            pub static _SC_XOPEN_SHM : c_int = 113;
+            pub static _SC_XOPEN_UNIX : c_int = 115;
+            pub static _SC_XOPEN_VERSION : c_int = 116;
+            pub static _SC_XOPEN_XCU_VERSION : c_int = 121;
         }
         pub mod posix08 {
         }
         pub mod bsd44 {
+            use libc::types::os::arch::c95::c_int;
+
+            pub static MADV_NORMAL : c_int = 0;
+            pub static MADV_RANDOM : c_int = 1;
+            pub static MADV_SEQUENTIAL : c_int = 2;
+            pub static MADV_WILLNEED : c_int = 3;
+            pub static MADV_DONTNEED : c_int = 4;
+            pub static MADV_FREE : c_int = 5;
+            pub static MADV_ZERO_WIRED_PAGES : c_int = 6;
+            pub static MADV_FREE_REUSABLE : c_int = 7;
+            pub static MADV_FREE_REUSE : c_int = 8;
+            pub static MADV_CAN_REUSE : c_int = 9;
+
+            pub static MINCORE_INCORE : c_int =  0x1;
+            pub static MINCORE_REFERENCED : c_int = 0x2;
+            pub static MINCORE_MODIFIED : c_int = 0x4;
+            pub static MINCORE_REFERENCED_OTHER : c_int = 0x8;
+            pub static MINCORE_MODIFIED_OTHER : c_int = 0x10;
         }
         pub mod extra {
-            pub static O_DSYNC : int = 4194304;
-            pub static O_SYNC : int = 128;
-            pub static F_FULLFSYNC : int = 51;
+            use libc::types::os::arch::c95::c_int;
+
+            pub static O_DSYNC : c_int = 4194304;
+            pub static O_SYNC : c_int = 128;
+            pub static F_FULLFSYNC : c_int = 51;
+
+            pub static MAP_COPY : c_int = 0x0002;
+            pub static MAP_RENAME : c_int = 0x0020;
+            pub static MAP_NORESERVE : c_int = 0x0040;
+            pub static MAP_NOEXTEND : c_int = 0x0100;
+            pub static MAP_HASSEMAPHORE : c_int = 0x0200;
+            pub static MAP_NOCACHE : c_int = 0x0400;
+            pub static MAP_JIT : c_int = 0x0800;
         }
     }
 }
@@ -1658,6 +2149,9 @@ pub mod funcs {
                              -> c_int;
             }
         }
+
+        pub mod mman {
+        }
     }
 
 
@@ -1835,6 +2329,38 @@ pub mod funcs {
                 unsafe fn kill(pid: pid_t, sig: c_int) -> c_int;
             }
         }
+
+        #[nolink]
+        #[abi = "cdecl"]
+        pub mod mman {
+            use libc::types::common::c95::{c_void};
+            use libc::types::os::arch::c95::{size_t, c_int, c_char};
+            use libc::types::os::arch::posix88::{mode_t, off_t};
+
+            pub extern {
+                unsafe fn mlock(addr: *c_void, len: size_t) -> c_int;
+                unsafe fn munlock(addr: *c_void, len: size_t) -> c_int;
+                unsafe fn mlockall(flags: c_int) -> c_int;
+                unsafe fn munlockall() -> c_int;
+
+                unsafe fn mmap(addr: *c_void,
+                               len: size_t,
+                               prot: c_int,
+                               flags: c_int,
+                               fd: c_int,
+                               offset: off_t) -> *mut c_void;
+                unsafe fn munmap(addr: *c_void, len: size_t) -> c_int;
+
+                unsafe fn mprotect(addr: *c_void, len: size_t, prot: c_int)
+                    -> c_int;
+
+                unsafe fn msync(addr: *c_void, len: size_t, flags: c_int)
+                    -> c_int;
+                unsafe fn shm_open(name: *c_char, oflag: c_int, mode: mode_t)
+                    -> c_int;
+                unsafe fn shm_unlink(name: *c_char) -> c_int;
+            }
+        }
     }
 
     #[cfg(target_os = "linux")]
@@ -1913,6 +2439,19 @@ pub mod funcs {
                 unsafe fn globfree(pglob: *mut glob_t);
             }
         }
+
+        #[nolink]
+        #[abi = "cdecl"]
+        pub mod mman {
+            use libc::types::common::c95::{c_void};
+            use libc::types::os::arch::c95::{c_int, size_t};
+
+            pub extern {
+                unsafe fn posix_madvise(addr: *c_void,
+                                        len: size_t,
+                                        advice: c_int) -> c_int;
+            }
+        }
     }
 
     #[cfg(target_os = "win32")]
@@ -1925,6 +2464,9 @@ pub mod funcs {
 
         pub mod glob {
         }
+
+        pub mod mman {
+        }
     }
 
 
@@ -1943,7 +2485,8 @@ pub mod funcs {
     #[cfg(target_os = "freebsd")]
     pub mod bsd44 {
         use libc::types::common::c95::{c_void};
-        use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
+        use libc::types::os::arch::c95::{c_char, c_uchar, c_int, c_uint,
+                                         size_t};
 
         #[abi = "cdecl"]
         pub extern {
@@ -1959,6 +2502,12 @@ pub mod funcs {
                                sizep: *mut size_t) -> c_int;
 
             unsafe fn getdtablesize() -> c_int;
+
+            unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                -> c_int;
+
+            unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                -> c_int;
         }
     }
 
@@ -1966,11 +2515,18 @@ pub mod funcs {
     #[cfg(target_os = "linux")]
     #[cfg(target_os = "android")]
     pub mod bsd44 {
-        use libc::types::os::arch::c95::{c_int};
+        use libc::types::common::c95::{c_void};
+        use libc::types::os::arch::c95::{c_uchar, c_int, size_t};
 
         #[abi = "cdecl"]
         pub extern {
             unsafe fn getdtablesize() -> c_int;
+
+            unsafe fn madvise(addr: *c_void, len: size_t, advice: c_int)
+                -> c_int;
+
+            unsafe fn mincore(addr: *c_void, len: size_t, vec: *c_uchar)
+                -> c_int;
         }
     }
 
diff --git a/src/libstd/managed.rs b/src/libstd/managed.rs
index d514612b5af..b71b3b503c2 100644
--- a/src/libstd/managed.rs
+++ b/src/libstd/managed.rs
@@ -15,7 +15,7 @@ use ptr::to_unsafe_ptr;
 #[cfg(not(test))] use cmp::{Eq, Ord};
 
 pub mod raw {
-    use intrinsic::TyDesc;
+    use std::unstable::intrinsics::TyDesc;
 
     pub static RC_EXCHANGE_UNIQUE : uint = (-1) as uint;
     pub static RC_MANAGED_UNIQUE : uint = (-2) as uint;
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index de87f967d28..84fdc1c46d1 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -758,7 +758,7 @@ pub fn list_dir(p: &Path) -> ~[~str] {
                     FindFirstFileW(
                         path_ptr,
                         ::cast::transmute(wfd_ptr));
-                if find_handle as int != INVALID_HANDLE_VALUE {
+                if find_handle as libc::c_int != INVALID_HANDLE_VALUE {
                     let mut more_files = 1 as libc::c_int;
                     while more_files != 0 {
                         let fp_buf = rust_list_dir_wfd_fp_buf(wfd_ptr);
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
index d276abf0c8b..16ab4771d0d 100644
--- a/src/libstd/reflect.rs
+++ b/src/libstd/reflect.rs
@@ -16,8 +16,10 @@ Runtime type reflection
 
 #[allow(missing_doc)];
 
-use intrinsic::{TyDesc, TyVisitor};
-use intrinsic::Opaque;
+#[cfg(stage0)]
+use intrinsic::{Opaque, TyDesc, TyVisitor};
+#[cfg(not(stage0))]
+use unstable::intrinsics::{Opaque, TyDesc, TyVisitor};
 use libc::c_void;
 use sys;
 use vec;
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index ab3f83d34d5..f39b5a00ed0 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -19,9 +19,6 @@ More runtime type reflection
 use cast::transmute;
 use char;
 use container::Container;
-use intrinsic;
-use intrinsic::{TyDesc, TyVisitor, visit_tydesc};
-use intrinsic::Opaque;
 use io::{Writer, WriterUtil};
 use iterator::IteratorUtil;
 use libc::c_void;
@@ -34,6 +31,10 @@ use to_str::ToStr;
 use vec::raw::{VecRepr, SliceRepr};
 use vec;
 use vec::{OwnedVector, UnboxedVecRepr};
+#[cfg(stage0)]
+use intrinsic::{Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
+#[cfg(not(stage0))]
+use unstable::intrinsics::{Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
 
 #[cfg(test)] use io;
 
@@ -564,6 +565,7 @@ impl TyVisitor for ReprVisitor {
     fn visit_self(&self) -> bool { true }
     fn visit_type(&self) -> bool { true }
 
+    #[cfg(not(stage0))]
     fn visit_opaque_box(&self) -> bool {
         self.writer.write_char('@');
         do self.get::<&managed::raw::BoxRepr> |b| {
@@ -571,6 +573,16 @@ impl TyVisitor for ReprVisitor {
             self.visit_ptr_inner(p, b.header.type_desc);
         }
     }
+    #[cfg(stage0)]
+    fn visit_opaque_box(&self) -> bool {
+        self.writer.write_char('@');
+        do self.get::<&managed::raw::BoxRepr> |b| {
+            let p = ptr::to_unsafe_ptr(&b.data) as *c_void;
+            unsafe {
+                self.visit_ptr_inner(p, transmute(b.header.type_desc));
+            }
+        }
+    }
 
     // Type no longer exists, vestigial function.
     fn visit_constr(&self, _inner: *TyDesc) -> bool { fail!(); }
@@ -581,7 +593,7 @@ impl TyVisitor for ReprVisitor {
 pub fn write_repr<T>(writer: @Writer, object: &T) {
     unsafe {
         let ptr = ptr::to_unsafe_ptr(object) as *c_void;
-        let tydesc = intrinsic::get_tydesc::<T>();
+        let tydesc = get_tydesc::<T>();
         let u = ReprVisitor(ptr, writer);
         let v = reflect::MovePtrAdaptor(u);
         visit_tydesc(tydesc, @v as @TyVisitor)
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index ce7ff87b445..1e9f9aab834 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -8,26 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use sys::{TypeDesc, size_of};
+use sys::{size_of};
 use libc::{c_void, size_t, uintptr_t};
 use c_malloc = libc::malloc;
 use c_free = libc::free;
 use managed::raw::{BoxHeaderRepr, BoxRepr};
 use cast::transmute;
-use unstable::intrinsics::{atomic_xadd,atomic_xsub};
+use unstable::intrinsics::{atomic_xadd,atomic_xsub,TyDesc};
 use ptr::null;
-use intrinsic::TyDesc;
 
-pub unsafe fn malloc(td: *TypeDesc, size: uint) -> *c_void {
+pub unsafe fn malloc(td: *TyDesc, size: uint) -> *c_void {
     assert!(td.is_not_null());
 
     let total_size = get_box_size(size, (*td).align);
     let p = c_malloc(total_size as size_t);
     assert!(p.is_not_null());
 
-    // FIXME #3475: Converting between our two different tydesc types
-    let td: *TyDesc = transmute(td);
-
     let box: &mut BoxRepr = transmute(p);
     box.header.ref_count = -1; // Exchange values not ref counted
     box.header.type_desc = td;
diff --git a/src/libstd/core.rc b/src/libstd/std.rs
index 13c54799fac..13c54799fac 100644
--- a/src/libstd/core.rc
+++ b/src/libstd/std.rs
diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs
index 79ea60cc224..a1d6342323c 100644
--- a/src/libstd/sys.rs
+++ b/src/libstd/sys.rs
@@ -17,23 +17,11 @@ use cast;
 use gc;
 use io;
 use libc;
-use libc::{c_void, c_char, size_t};
+use libc::{c_char, size_t};
 use repr;
 use str;
 use unstable::intrinsics;
 
-pub type FreeGlue<'self> = &'self fn(*TypeDesc, *c_void);
-
-// Corresponds to runtime type_desc type
-pub struct TypeDesc {
-    size: uint,
-    align: uint,
-    take_glue: uint,
-    drop_glue: uint,
-    free_glue: uint
-    // Remaining fields not listed
-}
-
 /// The representation of a Rust closure
 pub struct Closure {
     code: *(),
@@ -51,23 +39,6 @@ pub mod rustrt {
     }
 }
 
-/**
- * Returns a pointer to a type descriptor.
- *
- * Useful for calling certain function in the Rust runtime or otherwise
- * performing dark magick.
- */
-#[inline]
-pub fn get_type_desc<T>() -> *TypeDesc {
-    unsafe { intrinsics::get_tydesc::<T>() as *TypeDesc }
-}
-
-/// Returns a pointer to a type descriptor.
-#[inline]
-pub fn get_type_desc_val<T>(_val: &T) -> *TypeDesc {
-    get_type_desc::<T>()
-}
-
 /// Returns the size of a type
 #[inline]
 pub fn size_of<T>() -> uint {
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 77053f39677..04c0dd79ded 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -111,7 +111,7 @@ fn taskset_remove(tasks: &mut TaskSet, task: *rust_task) {
     assert!(was_present);
 }
 pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) -> bool {
-    tasks.each(|k| blk(*k))
+    tasks.iter().advance(|k| blk(*k))
 }
 
 // One of these per group of linked-failure tasks.
diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs
index 9f812288621..4d5bc0f8842 100644
--- a/src/libstd/to_str.rs
+++ b/src/libstd/to_str.rs
@@ -18,11 +18,9 @@ use str::OwnedStr;
 use hashmap::HashMap;
 use hashmap::HashSet;
 use iterator::IteratorUtil;
-use container::Map;
 use hash::Hash;
 use cmp::Eq;
 use vec::ImmutableVector;
-use iterator::IteratorUtil;
 
 /// A generic trait for converting a value to a string
 pub trait ToStr {
@@ -179,7 +177,7 @@ impl<A:ToStr> ToStr for @[A] {
 mod tests {
     use hashmap::HashMap;
     use hashmap::HashSet;
-    use container::Set;
+    use container::{Set,Map};
     #[test]
     fn test_simple_types() {
         assert_eq!(1i.to_str(), ~"1");
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index e6449ef4922..8f70c75439a 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -58,30 +58,6 @@ impl<T> Map<uint, T> for TrieMap<T> {
         self.find(key).is_some()
     }
 
-    /// Visit all key-value pairs in order
-    #[inline]
-    fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
-        self.root.each(f)
-    }
-
-    /// Visit all keys in order
-    #[inline]
-    fn each_key(&self, f: &fn(&uint) -> bool) -> bool {
-        self.each(|k, _| f(k))
-    }
-
-    /// Visit all values in order
-    #[inline]
-    fn each_value<'a>(&'a self, f: &fn(&'a T) -> bool) -> bool {
-        self.each(|_, v| f(v))
-    }
-
-    /// Iterate over the map and mutate the contained values
-    #[inline]
-    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
-        self.root.mutate_values(f)
-    }
-
     /// Return a reference to the value corresponding to the key
     #[inline]
     fn find<'a>(&'a self, key: &uint) -> Option<&'a T> {
@@ -158,6 +134,30 @@ impl<T> TrieMap<T> {
         self.root.each_reverse(f)
     }
 
+    /// Visit all key-value pairs in order
+    #[inline]
+    pub fn each<'a>(&'a self, f: &fn(&uint, &'a T) -> bool) -> bool {
+        self.root.each(f)
+    }
+
+    /// Visit all keys in order
+    #[inline]
+    pub fn each_key(&self, f: &fn(&uint) -> bool) -> bool {
+        self.each(|k, _| f(k))
+    }
+
+    /// Visit all values in order
+    #[inline]
+    pub fn each_value<'a>(&'a self, f: &fn(&'a T) -> bool) -> bool {
+        self.each(|_, v| f(v))
+    }
+
+    /// Iterate over the map and mutate the contained values
+    #[inline]
+    pub fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
+        self.root.mutate_values(f)
+    }
+
     /// Visit all keys in reverse order
     #[inline]
     pub fn each_key_reverse(&self, f: &fn(&uint) -> bool) -> bool {
diff --git a/src/libstd/unstable/atomics.rs b/src/libstd/unstable/atomics.rs
index 6e7a7e2b129..7a3a5f51d35 100644
--- a/src/libstd/unstable/atomics.rs
+++ b/src/libstd/unstable/atomics.rs
@@ -62,6 +62,7 @@ pub struct AtomicPtr<T> {
 /**
  * An owned atomic pointer. Ensures that only a single reference to the data is held at any time.
  */
+#[no_drop_flag]
 pub struct AtomicOption<T> {
     priv p: *mut c_void
 }
diff --git a/src/libstd/unstable/exchange_alloc.rs b/src/libstd/unstable/exchange_alloc.rs
index 3b35c2fb804..5c47901df48 100644
--- a/src/libstd/unstable/exchange_alloc.rs
+++ b/src/libstd/unstable/exchange_alloc.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use sys::{TypeDesc, size_of};
+use sys::size_of;
 use libc::{c_void, size_t};
 use c_malloc = libc::malloc;
 use c_free = libc::free;
@@ -16,18 +16,18 @@ use managed::raw::{BoxHeaderRepr, BoxRepr};
 use cast::transmute;
 use unstable::intrinsics::{atomic_xadd,atomic_xsub};
 use ptr::null;
+#[cfg(stage0)]
 use intrinsic::TyDesc;
+#[cfg(not(stage0))]
+use unstable::intrinsics::TyDesc;
 
-pub unsafe fn malloc(td: *TypeDesc, size: uint) -> *c_void {
+pub unsafe fn malloc(td: *TyDesc, size: uint) -> *c_void {
     assert!(td.is_not_null());
 
     let total_size = get_box_size(size, (*td).align);
     let p = c_malloc(total_size as size_t);
     assert!(p.is_not_null());
 
-    // FIXME #3475: Converting between our two different tydesc types
-    let td: *TyDesc = transmute(td);
-
     let box: &mut BoxRepr = transmute(p);
     box.header.ref_count = -1; // Exchange values not ref counted
     box.header.type_desc = td;
diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs
index c38b013a75a..1254a591293 100644
--- a/src/libstd/unstable/intrinsics.rs
+++ b/src/libstd/unstable/intrinsics.rs
@@ -32,6 +32,130 @@ A quick refresher on memory ordering:
 
 */
 
+// This is needed to prevent duplicate lang item definitions.
+#[cfg(test)]
+pub use realstd::unstable::intrinsics::{TyDesc, Opaque, TyVisitor};
+
+#[cfg(not(stage0))]
+pub type GlueFn = extern "Rust" fn(*i8);
+
+#[cfg(stage0)]
+pub type GlueFn = extern "Rust" fn(**TyDesc, *i8);
+
+// NB: this has to be kept in sync with the Rust ABI.
+#[lang="ty_desc"]
+#[cfg(not(test))]
+pub struct TyDesc {
+    size: uint,
+    align: uint,
+    take_glue: GlueFn,
+    drop_glue: GlueFn,
+    free_glue: GlueFn,
+    visit_glue: GlueFn,
+}
+
+#[lang="opaque"]
+#[cfg(not(test))]
+pub enum Opaque { }
+
+#[lang="ty_visitor"]
+#[cfg(not(test))]
+pub trait TyVisitor {
+    fn visit_bot(&self) -> bool;
+    fn visit_nil(&self) -> bool;
+    fn visit_bool(&self) -> bool;
+
+    fn visit_int(&self) -> bool;
+    fn visit_i8(&self) -> bool;
+    fn visit_i16(&self) -> bool;
+    fn visit_i32(&self) -> bool;
+    fn visit_i64(&self) -> bool;
+
+    fn visit_uint(&self) -> bool;
+    fn visit_u8(&self) -> bool;
+    fn visit_u16(&self) -> bool;
+    fn visit_u32(&self) -> bool;
+    fn visit_u64(&self) -> bool;
+
+    fn visit_float(&self) -> bool;
+    fn visit_f32(&self) -> bool;
+    fn visit_f64(&self) -> bool;
+
+    fn visit_char(&self) -> bool;
+    fn visit_str(&self) -> bool;
+
+    fn visit_estr_box(&self) -> bool;
+    fn visit_estr_uniq(&self) -> bool;
+    fn visit_estr_slice(&self) -> bool;
+    fn visit_estr_fixed(&self, n: uint, sz: uint, align: uint) -> bool;
+
+    fn visit_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_ptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_rptr(&self, mtbl: uint, inner: *TyDesc) -> bool;
+
+    fn visit_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_unboxed_vec(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_evec_box(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_evec_uniq(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_evec_slice(&self, mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_evec_fixed(&self, n: uint, sz: uint, align: uint,
+                        mtbl: uint, inner: *TyDesc) -> bool;
+
+    fn visit_enter_rec(&self, n_fields: uint,
+                       sz: uint, align: uint) -> bool;
+    fn visit_rec_field(&self, i: uint, name: &str,
+                       mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_leave_rec(&self, n_fields: uint,
+                       sz: uint, align: uint) -> bool;
+
+    fn visit_enter_class(&self, n_fields: uint,
+                         sz: uint, align: uint) -> bool;
+    fn visit_class_field(&self, i: uint, name: &str,
+                         mtbl: uint, inner: *TyDesc) -> bool;
+    fn visit_leave_class(&self, n_fields: uint,
+                         sz: uint, align: uint) -> bool;
+
+    fn visit_enter_tup(&self, n_fields: uint,
+                       sz: uint, align: uint) -> bool;
+    fn visit_tup_field(&self, i: uint, inner: *TyDesc) -> bool;
+    fn visit_leave_tup(&self, n_fields: uint,
+                       sz: uint, align: uint) -> bool;
+
+    fn visit_enter_enum(&self, n_variants: uint,
+                        get_disr: extern unsafe fn(ptr: *Opaque) -> int,
+                        sz: uint, align: uint) -> bool;
+    fn visit_enter_enum_variant(&self, variant: uint,
+                                disr_val: int,
+                                n_fields: uint,
+                                name: &str) -> bool;
+    fn visit_enum_variant_field(&self, i: uint, offset: uint, inner: *TyDesc) -> bool;
+    fn visit_leave_enum_variant(&self, variant: uint,
+                                disr_val: int,
+                                n_fields: uint,
+                                name: &str) -> bool;
+    fn visit_leave_enum(&self, n_variants: uint,
+                        get_disr: extern unsafe fn(ptr: *Opaque) -> int,
+                        sz: uint, align: uint) -> bool;
+
+    fn visit_enter_fn(&self, purity: uint, proto: uint,
+                      n_inputs: uint, retstyle: uint) -> bool;
+    fn visit_fn_input(&self, i: uint, mode: uint, inner: *TyDesc) -> bool;
+    fn visit_fn_output(&self, retstyle: uint, inner: *TyDesc) -> bool;
+    fn visit_leave_fn(&self, purity: uint, proto: uint,
+                      n_inputs: uint, retstyle: uint) -> bool;
+
+    fn visit_trait(&self) -> bool;
+    fn visit_var(&self) -> bool;
+    fn visit_var_integral(&self) -> bool;
+    fn visit_param(&self, i: uint) -> bool;
+    fn visit_self(&self) -> bool;
+    fn visit_type(&self) -> bool;
+    fn visit_opaque_box(&self) -> bool;
+    fn visit_constr(&self, inner: *TyDesc) -> bool;
+    fn visit_closure_ptr(&self, ck: uint) -> bool;
+}
+
 #[abi = "rust-intrinsic"]
 pub extern "rust-intrinsic" {
 
@@ -42,9 +166,7 @@ pub extern "rust-intrinsic" {
     /// Atomic compare and exchange, release ordering.
     pub fn atomic_cxchg_rel(dst: &mut int, old: int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_cxchg_acqrel(dst: &mut int, old: int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_cxchg_relaxed(dst: &mut int, old: int, src: int) -> int;
 
 
@@ -53,7 +175,6 @@ pub extern "rust-intrinsic" {
     /// Atomic load, acquire ordering.
     pub fn atomic_load_acq(src: &int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_load_relaxed(src: &int) -> int;
 
     /// Atomic store, sequentially consistent.
@@ -61,7 +182,6 @@ pub extern "rust-intrinsic" {
     /// Atomic store, release ordering.
     pub fn atomic_store_rel(dst: &mut int, val: int);
 
-    #[cfg(not(stage0))]
     pub fn atomic_store_relaxed(dst: &mut int, val: int);
 
     /// Atomic exchange, sequentially consistent.
@@ -70,9 +190,7 @@ pub extern "rust-intrinsic" {
     pub fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
     /// Atomic exchange, release ordering.
     pub fn atomic_xchg_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xchg_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xchg_relaxed(dst: &mut int, src: int) -> int;
 
     /// Atomic addition, sequentially consistent.
@@ -81,9 +199,7 @@ pub extern "rust-intrinsic" {
     pub fn atomic_xadd_acq(dst: &mut int, src: int) -> int;
     /// Atomic addition, release ordering.
     pub fn atomic_xadd_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xadd_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xadd_relaxed(dst: &mut int, src: int) -> int;
 
     /// Atomic subtraction, sequentially consistent.
@@ -92,97 +208,55 @@ pub extern "rust-intrinsic" {
     pub fn atomic_xsub_acq(dst: &mut int, src: int) -> int;
     /// Atomic subtraction, release ordering.
     pub fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xsub_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xsub_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_and(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_and_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_and_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_and_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_and_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_nand(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_nand_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_nand_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_nand_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_nand_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_or(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_or_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_or_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_or_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_or_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_xor(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xor_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xor_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xor_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_xor_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_max(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_max_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_max_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_max_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_max_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_min(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_min_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_min_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_min_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_min_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_umin(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umin_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umin_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umin_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umin_relaxed(dst: &mut int, src: int) -> int;
 
-    #[cfg(not(stage0))]
     pub fn atomic_umax(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umax_acq(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umax_rel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umax_acqrel(dst: &mut int, src: int) -> int;
-    #[cfg(not(stage0))]
     pub fn atomic_umax_relaxed(dst: &mut int, src: int) -> int;
 
     /// The size of a type in bytes.
@@ -209,6 +283,9 @@ pub extern "rust-intrinsic" {
     pub fn pref_align_of<T>() -> uint;
 
     /// Get a static pointer to a type descriptor.
+    #[cfg(not(stage0))]
+    pub fn get_tydesc<T>() -> *TyDesc;
+    #[cfg(stage0)]
     pub fn get_tydesc<T>() -> *();
 
     /// Create a value initialized to zero.
@@ -231,9 +308,8 @@ pub extern "rust-intrinsic" {
     /// Returns `true` if a type requires drop glue.
     pub fn needs_drop<T>() -> bool;
 
-    // XXX: intrinsic uses legacy modes and has reference to TyDesc
-    // and TyVisitor which are in librustc
-    //fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor) -> ();
+    #[cfg(not(stage0))]
+    pub fn visit_tydesc(td: *TyDesc, tv: @TyVisitor);
 
     pub fn frame_address(f: &once fn(*u8));
 
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 7b7a3020b93..2e18a588fae 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -30,6 +30,10 @@ use sys;
 use sys::size_of;
 use uint;
 use unstable::intrinsics;
+#[cfg(stage0)]
+use intrinsic::{get_tydesc};
+#[cfg(not(stage0))]
+use unstable::intrinsics::{get_tydesc};
 use vec;
 use util;
 
@@ -37,19 +41,22 @@ use util;
 
 pub mod rustrt {
     use libc;
-    use sys;
     use vec::raw;
+    #[cfg(stage0)]
+    use intrinsic::{TyDesc};
+    #[cfg(not(stage0))]
+    use unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]
     pub extern {
         // These names are terrible. reserve_shared applies
         // to ~[] and reserve_shared_actual applies to @[].
         #[fast_ffi]
-        unsafe fn vec_reserve_shared(t: *sys::TypeDesc,
+        unsafe fn vec_reserve_shared(t: *TyDesc,
                                      v: **raw::VecRepr,
                                      n: libc::size_t);
         #[fast_ffi]
-        unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
+        unsafe fn vec_reserve_shared_actual(t: *TyDesc,
                                             v: **raw::VecRepr,
                                             n: libc::size_t);
     }
@@ -78,7 +85,7 @@ pub fn reserve<T>(v: &mut ~[T], n: uint) {
     if capacity(v) < n {
         unsafe {
             let ptr: **raw::VecRepr = cast::transmute(v);
-            let td = sys::get_type_desc::<T>();
+            let td = get_tydesc::<T>();
             if ((**ptr).box_header.ref_count ==
                 managed::raw::RC_MANAGED_UNIQUE) {
                 rustrt::vec_reserve_shared_actual(td, ptr, n as libc::size_t);
@@ -437,7 +444,7 @@ pub fn partitioned<T:Copy>(v: &[T], f: &fn(&T) -> bool) -> (~[T], ~[T]) {
     let mut lefts  = ~[];
     let mut rights = ~[];
 
-    for each(v) |elt| {
+    for v.iter().advance |elt| {
         if f(elt) {
             lefts.push(copy *elt);
         } else {
@@ -843,7 +850,7 @@ pub fn grow_set<T:Copy>(v: &mut ~[T], index: uint, initval: &T, val: T) {
 /// Apply a function to each element of a vector and return the results
 pub fn map<T, U>(v: &[T], f: &fn(t: &T) -> U) -> ~[U] {
     let mut result = with_capacity(v.len());
-    for each(v) |elem| {
+    for v.iter().advance |elem| {
         result.push(f(elem));
     }
     result
@@ -879,7 +886,7 @@ pub fn mapi<T, U>(v: &[T], f: &fn(uint, t: &T) -> U) -> ~[U] {
  */
 pub fn flat_map<T, U>(v: &[T], f: &fn(t: &T) -> ~[U]) -> ~[U] {
     let mut result = ~[];
-    for each(v) |elem| { result.push_all_move(f(elem)); }
+    for v.iter().advance |elem| { result.push_all_move(f(elem)); }
     result
 }
 
@@ -932,7 +939,7 @@ pub fn filter_mapped<T, U: Copy>(
      */
 
     let mut result = ~[];
-    for each(v) |elem| {
+    for v.iter().advance |elem| {
         match f(elem) {
           None => {/* no-op */ }
           Some(result_elem) => { result.push(result_elem); }
@@ -967,7 +974,7 @@ pub fn filter<T>(v: ~[T], f: &fn(t: &T) -> bool) -> ~[T] {
  */
 pub fn filtered<T:Copy>(v: &[T], f: &fn(t: &T) -> bool) -> ~[T] {
     let mut result = ~[];
-    for each(v) |elem| {
+    for v.iter().advance |elem| {
         if f(elem) { result.push(copy *elem); }
     }
     result
@@ -1051,7 +1058,7 @@ impl<'self, T:Copy> VectorVector<T> for &'self [&'self [T]] {
 
 /// Return true if a vector contains an element with the given value
 pub fn contains<T:Eq>(v: &[T], x: &T) -> bool {
-    for each(v) |elt| { if *x == *elt { return true; } }
+    for v.iter().advance |elt| { if *x == *elt { return true; } }
     false
 }
 
@@ -1202,7 +1209,7 @@ pub fn bsearch_elem<T:TotalOrd>(v: &[T], x: &T) -> Option<uint> {
  */
 pub fn unzip_slice<T:Copy,U:Copy>(v: &[(T, U)]) -> (~[T], ~[U]) {
     let mut (ts, us) = (~[], ~[]);
-    for each(v) |p| {
+    for v.iter().advance |p| {
         let (t, u) = copy *p;
         ts.push(t);
         us.push(u);
@@ -1341,69 +1348,6 @@ pub fn reversed<T:Copy>(v: &const [T]) -> ~[T] {
 }
 
 /**
- * Iterates over a vector, yielding each element to a closure.
- *
- * # Arguments
- *
- * * `v` - A vector, to be iterated over
- * * `f` - A closure to do the iterating. Within this closure, return true to
- * * continue iterating, false to break.
- *
- * # Examples
- *
- * ~~~ {.rust}
- * [1,2,3].each(|&i| {
- *     io::println(int::str(i));
- *     true
- * });
- * ~~~
- *
- * ~~~ {.rust}
- * [1,2,3,4,5].each(|&i| {
- *     if i < 4 {
- *         io::println(int::str(i));
- *         true
- *     }
- *     else {
- *         false
- *     }
- * });
- * ~~~
- *
- * You probably will want to use each with a `for`/`do` expression, depending
- * on your iteration needs:
- *
- * ~~~ {.rust}
- * for [1,2,3].each |&i| {
- *     io::println(int::str(i));
- * }
- * ~~~
- */
-#[inline]
-pub fn each<'r,T>(v: &'r [T], f: &fn(&'r T) -> bool) -> bool {
-    //            ^^^^
-    // NB---this CANNOT be &const [T]!  The reason
-    // is that you are passing it to `f()` using
-    // an immutable.
-
-    let mut broke = false;
-    do as_imm_buf(v) |p, n| {
-        let mut n = n;
-        let mut p = p;
-        while n > 0u {
-            unsafe {
-                let q = cast::copy_lifetime_vec(v, &*p);
-                if !f(q) { break; }
-                p = ptr::offset(p, 1u);
-            }
-            n -= 1u;
-        }
-        broke = n > 0;
-    }
-    return !broke;
-}
-
-/**
  * Iterate over all permutations of vector `v`.
  *
  * Permutations are produced in lexicographic order with respect to the order
@@ -2446,7 +2390,6 @@ macro_rules! iterator {
             }
 
             #[inline]
-            #[cfg(not(stage0))]
             fn size_hint(&self) -> (Option<uint>, Option<uint>) {
                 let exact = Some(((self.end as uint) - (self.ptr as uint)) / size_of::<$elem>());
                 (exact, exact)
@@ -3064,36 +3007,6 @@ mod tests {
     }
 
     #[test]
-    fn test_each_empty() {
-        for each::<int>([]) |_v| {
-            fail!(); // should never be executed
-        }
-    }
-
-    #[test]
-    fn test_each_nonempty() {
-        let mut i = 0;
-        for each([1, 2, 3]) |v| {
-            i += *v;
-        }
-        assert_eq!(i, 6);
-    }
-
-    #[test]
-    fn test_each_ret_len0() {
-        let a0 : [int, .. 0] = [];
-        assert_eq!(each(a0, |_p| fail!()), true);
-    }
-
-    #[test]
-    fn test_each_ret_len1() {
-        let a1 = [17];
-        assert_eq!(each(a1, |_p| true), true);
-        assert_eq!(each(a1, |_p| false), false);
-    }
-
-
-    #[test]
     fn test_each_permutation() {
         let mut results: ~[~[int]];
 
@@ -3851,21 +3764,6 @@ mod tests {
     #[test]
     #[ignore(windows)]
     #[should_fail]
-    fn test_each_fail() {
-        let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
-        let mut i = 0;
-        do each(v) |_elt| {
-            if i == 2 {
-                fail!()
-            }
-            i += 0;
-            false
-        };
-    }
-
-    #[test]
-    #[ignore(windows)]
-    #[should_fail]
     #[allow(non_implicitly_copyable_typarams)]
     fn test_permute_fail() {
         let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
@@ -3929,7 +3827,6 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(stage0))]
     fn test_iterator() {
         use iterator::*;
         let xs = [1, 2, 5, 10, 11];
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index b1fbfa0d91a..54ffa270f33 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -190,7 +190,7 @@ pub enum def {
     def_self_ty(/* trait id */ node_id),
     def_mod(def_id),
     def_foreign_mod(def_id),
-    def_const(def_id),
+    def_static(def_id, bool /* is_mutbl */),
     def_arg(node_id, bool /* is_mutbl */),
     def_local(node_id, bool /* is_mutbl */),
     def_variant(def_id /* enum */, def_id /* variant */),
@@ -1093,7 +1093,7 @@ pub struct item {
 
 #[deriving(Eq, Encodable, Decodable)]
 pub enum item_ {
-    item_const(@Ty, @expr),
+    item_static(@Ty, mutability, @expr),
     item_fn(fn_decl, purity, AbiSet, Generics, blk),
     item_mod(_mod),
     item_foreign_mod(foreign_mod),
@@ -1122,7 +1122,7 @@ pub struct foreign_item {
 #[deriving(Eq, Encodable, Decodable)]
 pub enum foreign_item_ {
     foreign_item_fn(fn_decl, purity, Generics),
-    foreign_item_const(@Ty)
+    foreign_item_static(@Ty, /* is_mutbl */ bool),
 }
 
 // The data we save and restore about an inlined item or method.  This is not
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index a0e1ec69350..421c4c566b5 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -339,7 +339,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str {
       Some(&node_item(item, path)) => {
         let path_str = path_ident_to_str(path, item.ident, itr);
         let item_str = match item.node {
-          item_const(*) => ~"const",
+          item_static(*) => ~"static",
           item_fn(*) => ~"fn",
           item_mod(*) => ~"mod",
           item_foreign_mod(*) => ~"foreign mod",
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 24cf5662a36..a233c330b64 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -59,7 +59,7 @@ pub fn variant_def_ids(d: def) -> Option<(def_id, def_id)> {
 pub fn def_id_of_def(d: def) -> def_id {
     match d {
       def_fn(id, _) | def_static_method(id, _, _) | def_mod(id) |
-      def_foreign_mod(id) | def_const(id) |
+      def_foreign_mod(id) | def_static(id, _) |
       def_variant(_, id) | def_ty(id) | def_ty_param(id, _) |
       def_use(id) | def_struct(id) | def_trait(id) => {
         id
@@ -394,10 +394,10 @@ impl id_range {
 
 pub fn id_visitor<T: Copy>(vfn: @fn(node_id, T)) -> visit::vt<T> {
     let visit_generics: @fn(&Generics, T) = |generics, t| {
-        for generics.ty_params.each |p| {
+        for generics.ty_params.iter().advance |p| {
             vfn(p.id, copy t);
         }
-        for generics.lifetimes.each |p| {
+        for generics.lifetimes.iter().advance |p| {
             vfn(p.id, copy t);
         }
     };
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 981b28afd02..83e446fa4c6 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -324,11 +324,11 @@ impl<'self> TraitDef<'self> {
 
         let mut trait_generics = self.generics.to_generics(cx, span, type_ident, generics);
         // Copy the lifetimes
-        for generics.lifetimes.each |l| {
+        for generics.lifetimes.iter().advance |l| {
             trait_generics.lifetimes.push(copy *l)
         };
         // Create the type parameters.
-        for generics.ty_params.each |ty_param| {
+        for generics.ty_params.iter().advance |ty_param| {
             // I don't think this can be moved out of the loop, since
             // a TyParamBound requires an ast id
             let mut bounds = opt_vec::from(
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 55ac9c5ec1c..da5455d4332 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -374,7 +374,7 @@ impl gen_init for protocol {
     fn buffer_ty_path(&self, cx: @ExtCtxt) -> @ast::Ty {
         let mut params: OptVec<ast::TyParam> = opt_vec::Empty;
         for (copy self.states).iter().advance |s| {
-            for s.generics.ty_params.each |tp| {
+            for s.generics.ty_params.iter().advance |tp| {
                 match params.iter().find_(|tpp| tp.ident == tpp.ident) {
                   None => params.push(*tp),
                   _ => ()
@@ -392,7 +392,7 @@ impl gen_init for protocol {
         let ext_cx = cx;
         let mut params: OptVec<ast::TyParam> = opt_vec::Empty;
         let fields = do (copy self.states).iter().transform |s| {
-            for s.generics.ty_params.each |tp| {
+            for s.generics.ty_params.iter().advance |tp| {
                 match params.iter().find_(|tpp| tp.ident == tpp.ident) {
                   None => params.push(*tp),
                   _ => ()
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 4bd2c0a3de1..25839fb4633 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -236,8 +236,8 @@ fn noop_fold_foreign_item(ni: @foreign_item, fld: @ast_fold)
                         purity,
                         fold_generics(generics, fld))
                 }
-                foreign_item_const(t) => {
-                    foreign_item_const(fld.fold_ty(t))
+                foreign_item_static(t, m) => {
+                    foreign_item_static(fld.fold_ty(t), m)
                 }
             },
         id: fld.new_id(ni.id),
@@ -270,7 +270,7 @@ fn noop_fold_struct_field(sf: @struct_field, fld: @ast_fold)
 
 pub fn noop_fold_item_underscore(i: &item_, fld: @ast_fold) -> item_ {
     match *i {
-        item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
+        item_static(t, m, e) => item_static(fld.fold_ty(t), m, fld.fold_expr(e)),
         item_fn(ref decl, purity, abi, ref generics, ref body) => {
             item_fn(
                 fold_fn_decl(decl, fld),
diff --git a/src/libsyntax/opt_vec.rs b/src/libsyntax/opt_vec.rs
index 8917b481dc7..22b1d040d42 100644
--- a/src/libsyntax/opt_vec.rs
+++ b/src/libsyntax/opt_vec.rs
@@ -38,13 +38,6 @@ pub fn from<T>(t: ~[T]) -> OptVec<T> {
 }
 
 impl<T> OptVec<T> {
-    fn each(&self, blk: &fn(v: &T) -> bool) -> bool {
-        match *self {
-            Empty => true,
-            Vec(ref v) => v.iter().advance(blk)
-        }
-    }
-
     fn push(&mut self, t: T) {
         match *self {
             Vec(ref mut v) => {
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index f2443f9e533..d8aab1f68ee 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -33,8 +33,8 @@ use ast::{expr_vec, expr_vstore, expr_vstore_mut_box};
 use ast::{expr_vstore_slice, expr_vstore_box};
 use ast::{expr_vstore_mut_slice, expr_while, extern_fn, field, fn_decl};
 use ast::{expr_vstore_uniq, Onceness, Once, Many};
-use ast::{foreign_item, foreign_item_const, foreign_item_fn, foreign_mod};
-use ast::{ident, impure_fn, inherited, item, item_, item_const};
+use ast::{foreign_item, foreign_item_static, foreign_item_fn, foreign_mod};
+use ast::{ident, impure_fn, inherited, item, item_, item_static};
 use ast::{item_enum, item_fn, item_foreign_mod, item_impl};
 use ast::{item_mac, item_mod, item_struct, item_trait, item_ty, lit, lit_};
 use ast::{lit_bool, lit_float, lit_float_unsuffixed, lit_int};
@@ -60,7 +60,7 @@ use ast::{view_item_, view_item_extern_mod, view_item_use};
 use ast::{view_path, view_path_glob, view_path_list, view_path_simple};
 use ast::visibility;
 use ast;
-use ast_util::{as_prec, ident_to_path, operator_prec};
+use ast_util::{as_prec, operator_prec};
 use ast_util;
 use codemap::{span, BytePos, spanned, mk_sp};
 use codemap;
@@ -3556,13 +3556,14 @@ impl Parser {
     }
 
     fn parse_item_const(&self) -> item_info {
+        let m = if self.eat_keyword(keywords::Mut) {m_mutbl} else {m_imm};
         let id = self.parse_ident();
         self.expect(&token::COLON);
         let ty = self.parse_ty(false);
         self.expect(&token::EQ);
         let e = self.parse_expr();
         self.expect(&token::SEMI);
-        (id, item_const(ty, e), None)
+        (id, item_static(ty, m, e), None)
     }
 
     // parse a mod { ...}  item
@@ -3683,6 +3684,7 @@ impl Parser {
         } else {
             self.expect_keyword(keywords::Static);
         }
+        let mutbl = self.eat_keyword(keywords::Mut);
 
         let ident = self.parse_ident();
         self.expect(&token::COLON);
@@ -3691,7 +3693,7 @@ impl Parser {
         self.expect(&token::SEMI);
         @ast::foreign_item { ident: ident,
                              attrs: attrs,
-                             node: foreign_item_const(ty),
+                             node: foreign_item_static(ty, mutbl),
                              id: self.get_id(),
                              span: mk_sp(lo, hi),
                              vis: vis }
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 273a59f0a3d..d40b96f077b 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -331,21 +331,18 @@ pub mod special_idents {
     pub static str : ident = ident { name: 19, ctxt: 0}; // for the type
 
     /* outside of libsyntax */
-    pub static ty_visitor : ident = ident { name: 20, ctxt: 0};
-    pub static arg : ident = ident { name: 21, ctxt: 0};
-    pub static descrim : ident = ident { name: 22, ctxt: 0};
-    pub static clownshoe_abi : ident = ident { name: 23, ctxt: 0};
-    pub static clownshoe_stack_shim : ident = ident { name: 24, ctxt: 0};
-    pub static tydesc : ident = ident { name: 25, ctxt: 0};
-    pub static main : ident = ident { name: 26, ctxt: 0};
-    pub static opaque : ident = ident { name: 27, ctxt: 0};
-    pub static blk : ident = ident { name: 28, ctxt: 0};
-    pub static statik : ident = ident { name: 29, ctxt: 0};
-    pub static intrinsic : ident = ident { name: 30, ctxt: 0};
-    pub static clownshoes_foreign_mod: ident = ident { name: 31, ctxt: 0};
-    pub static unnamed_field: ident = ident { name: 32, ctxt: 0};
-    pub static c_abi: ident = ident { name: 33, ctxt: 0};
-    pub static type_self: ident = ident { name: 34, ctxt: 0};    // `Self`
+    pub static arg : ident = ident { name: 20, ctxt: 0};
+    pub static descrim : ident = ident { name: 21, ctxt: 0};
+    pub static clownshoe_abi : ident = ident { name: 22, ctxt: 0};
+    pub static clownshoe_stack_shim : ident = ident { name: 23, ctxt: 0};
+    pub static main : ident = ident { name: 24, ctxt: 0};
+    pub static opaque : ident = ident { name: 25, ctxt: 0};
+    pub static blk : ident = ident { name: 26, ctxt: 0};
+    pub static statik : ident = ident { name: 27, ctxt: 0};
+    pub static clownshoes_foreign_mod: ident = ident { name: 28, ctxt: 0};
+    pub static unnamed_field: ident = ident { name: 29, ctxt: 0};
+    pub static c_abi: ident = ident { name: 30, ctxt: 0};
+    pub static type_self: ident = ident { name: 31, ctxt: 0};    // `Self`
 }
 
 /**
@@ -426,59 +423,56 @@ fn mk_fresh_ident_interner() -> @ident_interner {
         "tt",                 // 17
         "matchers",           // 18
         "str",                // 19
-        "TyVisitor",          // 20
-        "arg",                // 21
-        "descrim",            // 22
-        "__rust_abi",         // 23
-        "__rust_stack_shim",  // 24
-        "TyDesc",             // 25
-        "main",               // 26
-        "<opaque>",           // 27
-        "blk",                // 28
-        "static",             // 29
-        "intrinsic",          // 30
-        "__foreign_mod__",    // 31
-        "__field__",          // 32
-        "C",                  // 33
-        "Self",               // 34
-
-        "as",                 // 35
-        "break",              // 36
-        "const",              // 37
-        "copy",               // 38
-        "do",                 // 39
-        "else",               // 40
-        "enum",               // 41
-        "extern",             // 42
-        "false",              // 43
-        "fn",                 // 44
-        "for",                // 45
-        "if",                 // 46
-        "impl",               // 47
-        "let",                // 48
-        "__log",              // 49
-        "loop",               // 50
-        "match",              // 51
-        "mod",                // 52
-        "mut",                // 53
-        "once",               // 54
-        "priv",               // 55
-        "pub",                // 56
-        "pure",               // 57
-        "ref",                // 58
-        "return",             // 59
-        "static",             // 29 -- also a special ident
+        "arg",                // 20
+        "descrim",            // 21
+        "__rust_abi",         // 22
+        "__rust_stack_shim",  // 23
+        "main",               // 24
+        "<opaque>",           // 25
+        "blk",                // 26
+        "static",             // 27
+        "__foreign_mod__",    // 28
+        "__field__",          // 29
+        "C",                  // 30
+        "Self",               // 31
+
+        "as",                 // 32
+        "break",              // 33
+        "const",              // 34
+        "copy",               // 35
+        "do",                 // 36
+        "else",               // 37
+        "enum",               // 38
+        "extern",             // 39
+        "false",              // 40
+        "fn",                 // 41
+        "for",                // 42
+        "if",                 // 43
+        "impl",               // 44
+        "let",                // 45
+        "__log",              // 46
+        "loop",               // 47
+        "match",              // 48
+        "mod",                // 49
+        "mut",                // 50
+        "once",               // 51
+        "priv",               // 52
+        "pub",                // 53
+        "pure",               // 54
+        "ref",                // 55
+        "return",             // 56
+        "static",             // 27 -- also a special ident
         "self",               //  8 -- also a special ident
-        "struct",             // 60
-        "super",              // 61
-        "true",               // 62
-        "trait",              // 63
-        "type",               // 64
-        "unsafe",             // 65
-        "use",                // 66
-        "while",              // 67
-
-        "be",                 // 68
+        "struct",             // 57
+        "super",              // 58
+        "true",               // 59
+        "trait",              // 60
+        "type",               // 61
+        "unsafe",             // 62
+        "use",                // 63
+        "while",              // 64
+
+        "be",                 // 65
     ];
 
     @ident_interner {
@@ -612,42 +606,42 @@ pub mod keywords {
     impl Keyword {
         pub fn to_ident(&self) -> ident {
             match *self {
-                As => ident { name: 35, ctxt: 0 },
-                Break => ident { name: 36, ctxt: 0 },
-                Const => ident { name: 37, ctxt: 0 },
-                Copy => ident { name: 38, ctxt: 0 },
-                Do => ident { name: 39, ctxt: 0 },
-                Else => ident { name: 40, ctxt: 0 },
-                Enum => ident { name: 41, ctxt: 0 },
-                Extern => ident { name: 42, ctxt: 0 },
-                False => ident { name: 43, ctxt: 0 },
-                Fn => ident { name: 44, ctxt: 0 },
-                For => ident { name: 45, ctxt: 0 },
-                If => ident { name: 46, ctxt: 0 },
-                Impl => ident { name: 47, ctxt: 0 },
-                Let => ident { name: 48, ctxt: 0 },
-                __Log => ident { name: 49, ctxt: 0 },
-                Loop => ident { name: 50, ctxt: 0 },
-                Match => ident { name: 51, ctxt: 0 },
-                Mod => ident { name: 52, ctxt: 0 },
-                Mut => ident { name: 53, ctxt: 0 },
-                Once => ident { name: 54, ctxt: 0 },
-                Priv => ident { name: 55, ctxt: 0 },
-                Pub => ident { name: 56, ctxt: 0 },
-                Pure => ident { name: 57, ctxt: 0 },
-                Ref => ident { name: 58, ctxt: 0 },
-                Return => ident { name: 59, ctxt: 0 },
-                Static => ident { name: 29, ctxt: 0 },
+                As => ident { name: 32, ctxt: 0 },
+                Break => ident { name: 33, ctxt: 0 },
+                Const => ident { name: 34, ctxt: 0 },
+                Copy => ident { name: 35, ctxt: 0 },
+                Do => ident { name: 36, ctxt: 0 },
+                Else => ident { name: 37, ctxt: 0 },
+                Enum => ident { name: 38, ctxt: 0 },
+                Extern => ident { name: 39, ctxt: 0 },
+                False => ident { name: 40, ctxt: 0 },
+                Fn => ident { name: 41, ctxt: 0 },
+                For => ident { name: 42, ctxt: 0 },
+                If => ident { name: 43, ctxt: 0 },
+                Impl => ident { name: 44, ctxt: 0 },
+                Let => ident { name: 45, ctxt: 0 },
+                __Log => ident { name: 46, ctxt: 0 },
+                Loop => ident { name: 47, ctxt: 0 },
+                Match => ident { name: 48, ctxt: 0 },
+                Mod => ident { name: 49, ctxt: 0 },
+                Mut => ident { name: 50, ctxt: 0 },
+                Once => ident { name: 51, ctxt: 0 },
+                Priv => ident { name: 52, ctxt: 0 },
+                Pub => ident { name: 53, ctxt: 0 },
+                Pure => ident { name: 54, ctxt: 0 },
+                Ref => ident { name: 55, ctxt: 0 },
+                Return => ident { name: 56, ctxt: 0 },
+                Static => ident { name: 27, ctxt: 0 },
                 Self => ident { name: 8, ctxt: 0 },
-                Struct => ident { name: 60, ctxt: 0 },
-                Super => ident { name: 61, ctxt: 0 },
-                True => ident { name: 62, ctxt: 0 },
-                Trait => ident { name: 63, ctxt: 0 },
-                Type => ident { name: 64, ctxt: 0 },
-                Unsafe => ident { name: 65, ctxt: 0 },
-                Use => ident { name: 66, ctxt: 0 },
-                While => ident { name: 67, ctxt: 0 },
-                Be => ident { name: 68, ctxt: 0 },
+                Struct => ident { name: 57, ctxt: 0 },
+                Super => ident { name: 58, ctxt: 0 },
+                True => ident { name: 59, ctxt: 0 },
+                Trait => ident { name: 60, ctxt: 0 },
+                Type => ident { name: 61, ctxt: 0 },
+                Unsafe => ident { name: 62, ctxt: 0 },
+                Use => ident { name: 63, ctxt: 0 },
+                While => ident { name: 64, ctxt: 0 },
+                Be => ident { name: 65, ctxt: 0 },
             }
         }
     }
@@ -663,7 +657,7 @@ pub fn is_keyword(kw: keywords::Keyword, tok: &Token) -> bool {
 pub fn is_any_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 29 | 35 .. 68 => true,
+            8 | 27 | 32 .. 65 => true,
             _ => false,
         },
         _ => false
@@ -673,7 +667,7 @@ pub fn is_any_keyword(tok: &Token) -> bool {
 pub fn is_strict_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 29 | 35 .. 67 => true,
+            8 | 27 | 32 .. 64 => true,
             _ => false,
         },
         _ => false,
@@ -683,7 +677,7 @@ pub fn is_strict_keyword(tok: &Token) -> bool {
 pub fn is_reserved_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            68 => true,
+            65 => true,
             _ => false,
         },
         _ => false,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 853e917a6f1..0a20526da44 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -458,8 +458,11 @@ pub fn print_foreign_item(s: @ps, item: @ast::foreign_item) {
         word(s.s, ";");
         end(s); // end the outer fn box
       }
-      ast::foreign_item_const(t) => {
+      ast::foreign_item_static(t, m) => {
         head(s, "static");
+        if m {
+            word_space(s, "mut");
+        }
         print_ident(s, item.ident);
         word_space(s, ":");
         print_type(s, t);
@@ -477,8 +480,11 @@ pub fn print_item(s: @ps, item: @ast::item) {
     let ann_node = node_item(s, item);
     (s.ann.pre)(ann_node);
     match item.node {
-      ast::item_const(ty, expr) => {
+      ast::item_static(ty, m, expr) => {
         head(s, visibility_qualified(item.vis, "static"));
+        if m == ast::m_mutbl {
+            word_space(s, "mut");
+        }
         print_ident(s, item.ident);
         word_space(s, ":");
         print_type(s, ty);
@@ -1737,7 +1743,7 @@ pub fn print_bounds(s: @ps, bounds: @OptVec<ast::TyParamBound>) {
     if !bounds.is_empty() {
         word(s.s, ":");
         let mut first = true;
-        for bounds.each |bound| {
+        for bounds.iter().advance |bound| {
             nbsp(s);
             if first {
                 first = false;
diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rs
index 278600bc039..278600bc039 100644
--- a/src/libsyntax/syntax.rc
+++ b/src/libsyntax/syntax.rs
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 5aa38c0348c..5e409be3e6c 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -148,7 +148,7 @@ fn visit_trait_ref<E: Copy>(tref: @ast::trait_ref, (e, v): (E, vt<E>)) {
 
 pub fn visit_item<E: Copy>(i: @item, (e, v): (E, vt<E>)) {
     match i.node {
-        item_const(t, ex) => {
+        item_static(t, _, ex) => {
             (v.visit_ty)(t, (copy e, v));
             (v.visit_expr)(ex, (copy e, v));
         }
@@ -326,7 +326,7 @@ pub fn visit_foreign_item<E: Copy>(ni: @foreign_item, (e, v): (E, vt<E>)) {
             visit_fn_decl(fd, (copy e, v));
             (v.visit_generics)(generics, (e, v));
         }
-        foreign_item_const(t) => {
+        foreign_item_static(t, _) => {
             (v.visit_ty)(t, (e, v));
         }
     }
@@ -334,7 +334,7 @@ pub fn visit_foreign_item<E: Copy>(ni: @foreign_item, (e, v): (E, vt<E>)) {
 
 pub fn visit_ty_param_bounds<E: Copy>(bounds: &OptVec<TyParamBound>,
                                       (e, v): (E, vt<E>)) {
-    for bounds.each |bound| {
+    for bounds.iter().advance |bound| {
         match *bound {
             TraitTyParamBound(ty) => visit_trait_ref(ty, (copy e, v)),
             RegionTyParamBound => {}
@@ -343,7 +343,7 @@ pub fn visit_ty_param_bounds<E: Copy>(bounds: &OptVec<TyParamBound>,
 }
 
 pub fn visit_generics<E: Copy>(generics: &Generics, (e, v): (E, vt<E>)) {
-    for generics.ty_params.each |tp| {
+    for generics.ty_params.iter().advance |tp| {
         visit_ty_param_bounds(tp.bounds, (copy e, v));
     }
 }
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index e476fa0ad5e..de46d7b3e8a 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -154,6 +154,16 @@ debug_abi_2(floats f) {
     return ff;
 }
 
+extern "C" int
+debug_static_mut;
+
+int debug_static_mut = 3;
+
+extern "C" void
+debug_static_mut_check_four() {
+    assert(debug_static_mut == 4);
+}
+
 /* Debug builtins for std::dbg. */
 
 static void
@@ -729,15 +739,6 @@ rust_task_deref(rust_task *task) {
     task->deref();
 }
 
-// Must call on rust stack.
-extern "C" CDECL void
-rust_call_tydesc_glue(void *root, size_t *tydesc, size_t glue_index) {
-    void (*glue_fn)(void *, void *, void *) =
-        (void (*)(void *, void *, void *))tydesc[glue_index];
-    if (glue_fn)
-        glue_fn(0, 0, root);
-}
-
 // Don't run on the Rust stack!
 extern "C" void
 rust_log_str(uint32_t level, const char *str, size_t size) {
diff --git a/src/rt/rust_task.cpp b/src/rt/rust_task.cpp
index fe1b4622137..81ae991623f 100644
--- a/src/rt/rust_task.cpp
+++ b/src/rt/rust_task.cpp
@@ -183,7 +183,11 @@ void task_start_wrapper(spawn_args *a)
     if(env) {
         // free the environment (which should be a unique closure).
         const type_desc *td = env->td;
-        td->drop_glue(NULL, NULL, box_body(env));
+        td->drop_glue(NULL,
+#ifdef _RUST_STAGE0
+                      NULL,
+#endif
+                      box_body(env));
         task->kernel->region()->free(env);
     }
 
diff --git a/src/rt/rust_type.h b/src/rt/rust_type.h
index 6d36d2c960a..30ff5f1fa54 100644
--- a/src/rt/rust_type.h
+++ b/src/rt/rust_type.h
@@ -25,7 +25,11 @@ typedef void (*CDECL spawn_fn)(rust_opaque_box*, void *);
 
 struct type_desc;
 
-typedef void CDECL (glue_fn)(void *, const type_desc **, void *);
+typedef void CDECL (glue_fn)(void *,
+#ifdef _RUST_STAGE0
+                             const type_desc **,
+#endif
+                             void *);
 
 // Corresponds to the boxed data in the @ region.  The body follows the
 // header; you can obtain a ptr via box_body() below.
@@ -57,8 +61,6 @@ struct type_desc {
     glue_fn *drop_glue;
     glue_fn *free_glue;
     glue_fn *visit_glue;
-    const uint8_t *unused;
-    const uint8_t *unused2;
 };
 
 extern "C" type_desc *rust_clone_type_desc(type_desc*);
diff --git a/src/rt/rust_util.cpp b/src/rt/rust_util.cpp
index 8d80a344063..4a15830e529 100644
--- a/src/rt/rust_util.cpp
+++ b/src/rt/rust_util.cpp
@@ -21,8 +21,6 @@ struct type_desc str_body_tydesc = {
     NULL, // drop_glue
     NULL, // free_glue
     NULL, // visit_glue
-    NULL, // shape
-    NULL, // shape_tables
 };
 
 //
diff --git a/src/rt/rustrt.def.in b/src/rt/rustrt.def.in
index ba7ada04a27..a4876618c97 100644
--- a/src/rt/rustrt.def.in
+++ b/src/rt/rustrt.def.in
@@ -7,6 +7,8 @@ debug_tydesc
 debug_get_stk_seg
 debug_abi_1
 debug_abi_2
+debug_static_mut
+debug_static_mut_check_four
 get_task_id
 get_time
 rust_tzset
@@ -174,7 +176,6 @@ rust_set_task_local_data
 rust_task_local_data_atexit
 rust_task_ref
 rust_task_deref
-rust_call_tydesc_glue
 tdefl_compress_mem_to_heap
 tinfl_decompress_mem_to_heap
 rust_gc_metadata
@@ -239,4 +240,4 @@ rust_valgrind_stack_deregister
 rust_take_env_lock
 rust_drop_env_lock
 rust_update_log_settings
-rust_running_on_valgrind
\ No newline at end of file
+rust_running_on_valgrind
diff --git a/src/snapshots.txt b/src/snapshots.txt
index 1aaf5fee26a..910de5f66b7 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,11 @@
+S 2013-06-23 f827561
+  macos-i386 63ffbcf99b6853d7840bdfe01380068518d0e466
+  macos-x86_64 b34fdf3845f8ef4760817007d8ef820cd32f2e07
+  winnt-i386 6602150074ec442fd376fddb2eaf63f5da6fdff9
+  freebsd-x86_64 a05bdda2d9ec0e66336d81b98bee8a95442a501f
+  linux-i386 b8f4a0f0c2250aa4d76ec1eb57c83bfae5725f93
+  linux-x86_64 caea3402663334d0a3967c21f58a860c060d5474
+
 S 2013-06-21 6759ce4
   macos-i386 6e5395d2fda1db356f64af28ba525031bf9871c7
   macos-x86_64 7b8ded4e1ba1e999a5614eea3a4acacb2c7cef1d
diff --git a/src/test/auxiliary/static_mut_xc.rs b/src/test/auxiliary/static_mut_xc.rs
new file mode 100644
index 00000000000..8dc45c681bf
--- /dev/null
+++ b/src/test/auxiliary/static_mut_xc.rs
@@ -0,0 +1 @@
+pub static mut a: int = 3;
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 14aa65219cd..d21888f12ec 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -86,7 +86,7 @@ fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
         HashSet::new()
     };
 
-    for vec::each(edges) |e| {
+    for edges.iter().advance |e| {
         match *e {
             (i, j) => {
                 graph[i].insert(j);
@@ -441,7 +441,7 @@ fn main() {
     let stop = time::precise_time_s();
 
     let mut total_edges = 0;
-    vec::each(graph, |edges| { total_edges += edges.len(); true });
+    for graph.iter().advance |edges| { total_edges += edges.len(); }
 
     io::stdout().write_line(fmt!("Generated graph with %? edges in %? seconds.",
                                  total_edges / 2,
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 7a9be754884..102f7f17065 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -83,7 +83,7 @@ fn run(args: &[~str]) {
         server(&from_parent, &to_parent);
     }
 
-    for vec::each(worker_results) |r| {
+    for worker_results.iter().advance |r| {
         r.recv();
     }
 
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 796072c8485..b8d91bb93e2 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -79,7 +79,7 @@ fn run(args: &[~str]) {
         server(&from_parent, &to_parent);
     }
 
-    for vec::each(worker_results) |r| {
+    for worker_results.iter().advance |r| {
         r.recv();
     }
 
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index 3ff123b027a..96c7e4e9b37 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -188,7 +188,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
 
     // save each creature's meeting stats
     let mut report = ~[];
-    for vec::each(to_creature) |_to_one| {
+    for to_creature.iter().advance |_to_one| {
         report.push(from_creatures_log.recv());
     }
 
@@ -196,7 +196,7 @@ fn rendezvous(nn: uint, set: ~[color]) {
     io::println(show_color_list(set));
 
     // print each creature's stats
-    for vec::each(report) |rep| {
+    for report.iter().advance |rep| {
         io::println(*rep);
     }
 
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index c33c2258864..20042aa0e91 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -56,7 +56,7 @@ fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
    let mut pairs = ~[];
 
    // map -> [(k,%)]
-   for mm.each |&key, &val| {
+   for mm.iter().advance |(&key, &val)| {
       pairs.push((key, pct(val, total)));
    }
 
diff --git a/src/test/compile-fail/block-must-not-have-result-for.rs b/src/test/compile-fail/block-must-not-have-result-for.rs
index 778309122cb..1aa05a9477d 100644
--- a/src/test/compile-fail/block-must-not-have-result-for.rs
+++ b/src/test/compile-fail/block-must-not-have-result-for.rs
@@ -8,10 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::vec;
-
 fn main() {
-    for vec::each(~[0]) |_i| {  //~ ERROR A for-loop body must return (), but
+    for 2.times {  //~ ERROR A for-loop body must return (), but
         true
     }
 }
diff --git a/src/test/compile-fail/borrowck-insert-during-each.rs b/src/test/compile-fail/borrowck-insert-during-each.rs
index 1a0bec7d723..189a0ef9d70 100644
--- a/src/test/compile-fail/borrowck-insert-during-each.rs
+++ b/src/test/compile-fail/borrowck-insert-during-each.rs
@@ -16,7 +16,7 @@ struct Foo {
 
 impl Foo {
     pub fn foo(&mut self, fun: &fn(&int)) {
-        for self.n.each |f| {
+        for self.n.iter().advance |f| {
             fun(f);
         }
     }
diff --git a/src/test/compile-fail/issue-2151.rs b/src/test/compile-fail/issue-2151.rs
index 8f4bbe4eabc..5559ba344ed 100644
--- a/src/test/compile-fail/issue-2151.rs
+++ b/src/test/compile-fail/issue-2151.rs
@@ -8,10 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::vec;
-
 fn main() {
-    for vec::each(fail!()) |i| {
-        let _ = i * 2; //~ ERROR the type of this value must be known
-   };
+    let x = fail!();
+    x.clone(); //~ ERROR the type of this value must be known in this context
 }
diff --git a/src/test/compile-fail/issue-3099-b.rs b/src/test/compile-fail/issue-3099-b.rs
index 3d22a59d6bd..5502b18f094 100644
--- a/src/test/compile-fail/issue-3099-b.rs
+++ b/src/test/compile-fail/issue-3099-b.rs
@@ -10,6 +10,6 @@
 
 pub mod a {}
 
-pub mod a {} //~ ERROR duplicate definition of type `a`
+pub mod a {} //~ ERROR duplicate definition of module `a`
 
 fn main() {}
diff --git a/src/test/compile-fail/lint-change-warnings.rs b/src/test/compile-fail/lint-change-warnings.rs
new file mode 100644
index 00000000000..977abc4dc0d
--- /dev/null
+++ b/src/test/compile-fail/lint-change-warnings.rs
@@ -0,0 +1,30 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deny(warnings)];
+
+fn main() {
+    while true {} //~ ERROR: infinite
+}
+
+#[allow(warnings)]
+fn foo() {
+    while true {}
+}
+
+#[warn(warnings)]
+fn bar() {
+    while true {} //~ WARNING: infinite
+}
+
+#[forbid(warnings)]
+fn baz() {
+    while true {} //~ ERROR: warnings
+}
diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs
index ec4f3f9a3fd..fbb6d03b220 100644
--- a/src/test/compile-fail/liveness-issue-2163.rs
+++ b/src/test/compile-fail/liveness-issue-2163.rs
@@ -12,7 +12,7 @@ use std::vec;
 
 fn main() {
     let a: ~[int] = ~[];
-    vec::each(a, |_| -> bool {
+    a.iter().advance(|_| -> bool {
         //~^ ERROR mismatched types
     });
 }
diff --git a/src/test/compile-fail/static-mut-bad-types.rs b/src/test/compile-fail/static-mut-bad-types.rs
new file mode 100644
index 00000000000..7aed3ce30bc
--- /dev/null
+++ b/src/test/compile-fail/static-mut-bad-types.rs
@@ -0,0 +1,17 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static mut a: int = 3;
+
+fn main() {
+    unsafe {
+        a = true; //~ ERROR: mismatched types
+    }
+}
diff --git a/src/test/compile-fail/static-mut-foreign-requires-unsafe.rs b/src/test/compile-fail/static-mut-foreign-requires-unsafe.rs
new file mode 100644
index 00000000000..7b371cf708d
--- /dev/null
+++ b/src/test/compile-fail/static-mut-foreign-requires-unsafe.rs
@@ -0,0 +1,21 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::libc;
+
+extern {
+    static mut a: libc::c_int;
+}
+
+fn main() {
+    a += 3;     //~ ERROR: requires unsafe
+    a = 4;      //~ ERROR: requires unsafe
+    let _b = a; //~ ERROR: requires unsafe
+}
diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs
new file mode 100644
index 00000000000..61d3ed7fd18
--- /dev/null
+++ b/src/test/compile-fail/static-mut-not-constant.rs
@@ -0,0 +1,13 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static mut a: ~int = ~3; //~ ERROR: disallowed operator in constant
+
+fn main() {}
diff --git a/src/test/compile-fail/static-mut-not-pat.rs b/src/test/compile-fail/static-mut-not-pat.rs
new file mode 100644
index 00000000000..997003a28d4
--- /dev/null
+++ b/src/test/compile-fail/static-mut-not-pat.rs
@@ -0,0 +1,26 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Constants (static variables) can be used to match in patterns, but mutable
+// statics cannot. This ensures that there's some form of error if this is
+// attempted.
+
+static mut a: int = 3;
+
+fn main() {
+    // If they can't be matched against, then it's possible to capture the same
+    // name as a variable, hence this should be an unreachable pattern situation
+    // instead of spitting out a custom error about some identifier collisions
+    // (we should allow shadowing)
+    match 4 {
+        a => {}
+        _ => {} //~ ERROR: unreachable pattern
+    }
+}
diff --git a/src/test/compile-fail/static-mut-requires-unsafe.rs b/src/test/compile-fail/static-mut-requires-unsafe.rs
new file mode 100644
index 00000000000..7337920cce6
--- /dev/null
+++ b/src/test/compile-fail/static-mut-requires-unsafe.rs
@@ -0,0 +1,17 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static mut a: int = 3;
+
+fn main() {
+    a += 3;         //~ ERROR: requires unsafe
+    a = 4;          //~ ERROR: requires unsafe
+    let _b = a;     //~ ERROR: requires unsafe
+}
diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs
index 5d2341ae42d..b65b18e1ab3 100644
--- a/src/test/run-pass/assignability-trait.rs
+++ b/src/test/run-pass/assignability-trait.rs
@@ -12,21 +12,19 @@
 // making method calls, but only if there aren't any matches without
 // it.
 
-use std::vec;
-
 trait iterable<A> {
     fn iterate(&self, blk: &fn(x: &A) -> bool) -> bool;
 }
 
 impl<'self,A> iterable<A> for &'self [A] {
     fn iterate(&self, f: &fn(x: &A) -> bool) -> bool {
-        vec::each(*self, f)
+        self.iter().advance(f)
     }
 }
 
 impl<A> iterable<A> for ~[A] {
     fn iterate(&self, f: &fn(x: &A) -> bool) -> bool {
-        vec::each(*self, f)
+        self.iter().advance(f)
     }
 }
 
diff --git a/src/test/run-pass/attr-no-drop-flag-size.rs b/src/test/run-pass/attr-no-drop-flag-size.rs
new file mode 100644
index 00000000000..e6f05970cce
--- /dev/null
+++ b/src/test/run-pass/attr-no-drop-flag-size.rs
@@ -0,0 +1,25 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::sys::size_of;
+
+#[no_drop_flag]
+struct Test<T> {
+    a: T
+}
+
+#[unsafe_destructor]
+impl<T> Drop for Test<T> {
+    fn finalize(&self) { }
+}
+
+fn main() {
+    assert_eq!(size_of::<int>(), size_of::<Test<int>>());
+}
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index f148c509d4d..185a5a6407c 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::vec;
-
 pub fn main() {
     let mut sum = 0;
-    for vec::each(~[1, 2, 3, 4, 5]) |x| {
+    let xs = ~[1, 2, 3, 4, 5];
+    for xs.iter().advance |x| {
         sum += *x;
     }
     assert_eq!(sum, 15);
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index d860c84dfce..ff5d0e9f05c 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -15,7 +15,7 @@ pub fn main() {
     let v = ~[-1f, 0f, 1f, 2f, 3f];
 
     // Statement form does not require parentheses:
-    for vec::each(v) |i| {
+    for v.iter().advance |i| {
         info!("%?", *i);
     }
 
diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
index d63ebf7d24d..8f74e6cdc29 100644
--- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
+++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs
@@ -8,12 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::vec;
-
 fn want_slice(v: &[int]) -> int {
     let mut sum = 0;
-    for vec::each(v) |i| { sum += *i; }
-    return sum;
+    for v.iter().advance |i| { sum += *i; }
+    sum
 }
 
 fn has_mut_vec(v: ~[int]) -> int {
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 2edb270762c..85c6f90a742 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -16,7 +16,8 @@ pub fn main() {
     assert_eq!(i, 10);
     loop { i += 1; if i == 20 { break; } }
     assert_eq!(i, 20);
-    for vec::each(~[1, 2, 3, 4, 5, 6]) |x| {
+    let xs = [1, 2, 3, 4, 5, 6];
+    for xs.iter().advance |x| {
         if *x == 3 { break; } assert!((*x <= 3));
     }
     i = 0;
@@ -26,7 +27,8 @@ pub fn main() {
         i += 1; if i % 2 == 0 { loop; } assert!((i % 2 != 0));
         if i >= 10 { break; }
     }
-    for vec::each(~[1, 2, 3, 4, 5, 6]) |x| {
+    let ys = ~[1, 2, 3, 4, 5, 6];
+    for ys.iter().advance |x| {
         if *x % 2 == 0 { loop; }
         assert!((*x % 2 != 0));
     }
diff --git a/src/test/run-pass/class-impl-very-parameterized-trait.rs b/src/test/run-pass/class-impl-very-parameterized-trait.rs
index c54b8db46c8..2805fec6fce 100644
--- a/src/test/run-pass/class-impl-very-parameterized-trait.rs
+++ b/src/test/run-pass/class-impl-very-parameterized-trait.rs
@@ -61,29 +61,8 @@ impl<T> Mutable for cat<T> {
 }
 
 impl<T> Map<int, T> for cat<T> {
-    fn each<'a>(&'a self, f: &fn(&int, &'a T) -> bool) -> bool {
-        let mut n = int::abs(self.meows);
-        while n > 0 {
-            if !f(&n, &self.name) { return false; }
-            n -= 1;
-        }
-        return true;
-    }
-
     fn contains_key(&self, k: &int) -> bool { *k <= self.meows }
 
-    fn each_key(&self, f: &fn(v: &int) -> bool) -> bool {
-        self.each(|k, _| f(k))
-    }
-
-    fn each_value<'a>(&'a self, f: &fn(v: &'a T) -> bool) -> bool {
-        self.each(|_, v| f(v))
-    }
-
-    fn mutate_values(&mut self, _f: &fn(&int, &mut T) -> bool) -> bool {
-        fail!("nope")
-    }
-
     fn insert(&mut self, k: int, _: T) -> bool {
         self.meows += k;
         true
diff --git a/src/test/run-pass/const-vec-of-fns.rs b/src/test/run-pass/const-vec-of-fns.rs
index 9fc68cd1127..45302363c38 100644
--- a/src/test/run-pass/const-vec-of-fns.rs
+++ b/src/test/run-pass/const-vec-of-fns.rs
@@ -8,7 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-fast
+// xfail-test
+// FIXME: #7385: hits a codegen bug on OS X x86_64
 
 /*!
  * Try to double-check that static fns have the right size (with or
@@ -23,6 +24,6 @@ struct S<'self>(&'self fn());
 static closures: &'static [S<'static>] = &[S(f), S(f)];
 
 pub fn main() {
-    for std::vec::each(bare_fns) |&bare_fn| { bare_fn() }
-    for std::vec::each(closures) |&closure| { (*closure)() }
+    for bare_fns.iter().advance |&bare_fn| { bare_fn() }
+    for closures.iter().advance |&closure| { (*closure)() }
 }
diff --git a/src/test/run-pass/extern-pub.rs b/src/test/run-pass/extern-pub.rs
index 29b0457fc05..27c45893930 100644
--- a/src/test/run-pass/extern-pub.rs
+++ b/src/test/run-pass/extern-pub.rs
@@ -1,11 +1,5 @@
-use std::libc;
-use std::sys;
-use std::vec;
-
 extern {
-    pub unsafe fn vec_reserve_shared_actual(t: *sys::TypeDesc,
-                                            v: **vec::raw::VecRepr,
-                                            n: libc::size_t);
+    pub unsafe fn free(p: *u8);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs
index 4926dbd0086..dd1cda22e65 100644
--- a/src/test/run-pass/for-destruct.rs
+++ b/src/test/run-pass/for-destruct.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-test: #3511: does not currently compile, due to rvalue issues
+
 use std::vec;
 
 struct Pair { x: int, y: int }
-
 pub fn main() {
     for vec::each(~[Pair {x: 10, y: 20}, Pair {x: 30, y: 0}]) |elt| {
         assert_eq!(elt.x + elt.y, 30);
diff --git a/src/test/run-pass/rcvr-borrowed-to-slice.rs b/src/test/run-pass/rcvr-borrowed-to-slice.rs
index 5eaf12f6a51..b62475ded54 100644
--- a/src/test/run-pass/rcvr-borrowed-to-slice.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-slice.rs
@@ -18,7 +18,7 @@ trait sum {
 impl<'self> sum for &'self [int] {
     fn sum(self) -> int {
         let mut sum = 0;
-        for vec::each(self) |e| { sum += *e; }
+        for self.iter().advance |e| { sum += *e; }
         return sum;
     }
 }
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
index a8571ab7325..176e49e0ea1 100644
--- a/src/test/run-pass/reflect-visit-data.rs
+++ b/src/test/run-pass/reflect-visit-data.rs
@@ -10,15 +10,14 @@
 
 // xfail-fast
 
-use std::bool;
 use std::int;
 use std::libc::c_void;
 use std::ptr;
 use std::sys;
 use std::vec::UnboxedVecRepr;
-use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
+use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
 
-#[doc = "High-level interfaces to `intrinsic::visit_ty` reflection system."]
+#[doc = "High-level interfaces to `std::unstable::intrinsics::visit_ty` reflection system."]
 
 /// Trait for visitor that wishes to reflect on data.
 trait movable_ptr {
@@ -637,7 +636,9 @@ impl TyVisitor for my_visitor {
 }
 
 fn get_tydesc_for<T>(_t: T) -> *TyDesc {
-    get_tydesc::<T>()
+    unsafe {
+        get_tydesc::<T>()
+    }
 }
 
 struct Triple { x: int, y: int, z: int }
@@ -651,8 +652,8 @@ pub fn main() {
                                        vals: ~[]});
         let v = ptr_visit_adaptor(Inner {inner: u});
         let td = get_tydesc_for(r);
-        unsafe { error!("tydesc sz: %u, align: %u",
-                        (*td).size, (*td).align); }
+        error!("tydesc sz: %u, align: %u",
+               (*td).size, (*td).align);
         let v = @v as @TyVisitor;
         visit_tydesc(td, v);
 
@@ -661,8 +662,7 @@ pub fn main() {
             println(fmt!("val: %s", *s));
         }
         error!("%?", u.vals.clone());
-        assert!(u.vals == ~[
-            ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"
-        ]);
+        assert_eq!(u.vals.clone(),
+                   ~[ ~"1", ~"2", ~"3", ~"true", ~"false", ~"5", ~"4", ~"3", ~"12"]);
     }
- }
+}
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index 8a7fef95614..bb1c92dfa8a 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -8,141 +8,153 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// xfail-test
-use intrinsic::{TyDesc, get_tydesc, visit_tydesc, TyVisitor};
-struct my_visitor(@mut { types: ~[str] });
+use std::unstable::intrinsics::{TyDesc, get_tydesc, visit_tydesc, TyVisitor, Opaque};
 
-impl TyVisitor for my_visitor {
-    fn visit_bot() -> bool {
-        self.types += ~["bot"];
+struct MyVisitor {
+    types: @mut ~[~str],
+}
+
+impl TyVisitor for MyVisitor {
+    fn visit_bot(&self) -> bool {
+        self.types.push(~"bot");
         error!("visited bot type");
         true
     }
-    fn visit_nil() -> bool {
-        self.types += ~["nil"];
+    fn visit_nil(&self) -> bool {
+        self.types.push(~"nil");
         error!("visited nil type");
         true
     }
-    fn visit_bool() -> bool {
-        self.types += ~["bool"];
+    fn visit_bool(&self) -> bool {
+        self.types.push(~"bool");
         error!("visited bool type");
         true
     }
-    fn visit_int() -> bool {
-        self.types += ~["int"];
+    fn visit_int(&self) -> bool {
+        self.types.push(~"int");
         error!("visited int type");
         true
     }
-    fn visit_i8() -> bool {
-        self.types += ~["i8"];
+    fn visit_i8(&self) -> bool {
+        self.types.push(~"i8");
         error!("visited i8 type");
         true
     }
-    fn visit_i16() -> bool {
-        self.types += ~["i16"];
+    fn visit_i16(&self) -> bool {
+        self.types.push(~"i16");
         error!("visited i16 type");
         true
     }
-    fn visit_i32() -> bool { true }
-    fn visit_i64() -> bool { true }
-
-    fn visit_uint() -> bool { true }
-    fn visit_u8() -> bool { true }
-    fn visit_u16() -> bool { true }
-    fn visit_u32() -> bool { true }
-    fn visit_u64() -> bool { true }
-
-    fn visit_float() -> bool { true }
-    fn visit_f32() -> bool { true }
-    fn visit_f64() -> bool { true }
-
-    fn visit_char() -> bool { true }
-    fn visit_str() -> bool { true }
-
-    fn visit_estr_box() -> bool { true }
-    fn visit_estr_uniq() -> bool { true }
-    fn visit_estr_slice() -> bool { true }
-    fn visit_estr_fixed(_sz: uint, _sz: uint,
+    fn visit_i32(&self) -> bool { true }
+    fn visit_i64(&self) -> bool { true }
+
+    fn visit_uint(&self) -> bool { true }
+    fn visit_u8(&self) -> bool { true }
+    fn visit_u16(&self) -> bool { true }
+    fn visit_u32(&self) -> bool { true }
+    fn visit_u64(&self) -> bool { true }
+
+    fn visit_float(&self) -> bool { true }
+    fn visit_f32(&self) -> bool { true }
+    fn visit_f64(&self) -> bool { true }
+
+    fn visit_char(&self) -> bool { true }
+    fn visit_str(&self) -> bool { true }
+
+    fn visit_estr_box(&self) -> bool { true }
+    fn visit_estr_uniq(&self) -> bool { true }
+    fn visit_estr_slice(&self) -> bool { true }
+    fn visit_estr_fixed(&self,
+                        _sz: uint, _sz: uint,
                         _align: uint) -> bool { true }
 
-    fn visit_box(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_uniq(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_ptr(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_rptr(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-
-    fn visit_vec(_mtbl: uint, inner: *TyDesc) -> bool {
-        self.types += ~["["];
-        visit_tydesc(inner, my_visitor(*self) as TyVisitor);
-        self.types += ~["]"];
+    fn visit_box(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_uniq(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_ptr(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_rptr(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+
+    fn visit_vec(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_unboxed_vec(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_box(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_uniq(&self, _mtbl: uint, inner: *TyDesc) -> bool {
+        self.types.push(~"[");
+        unsafe {
+            visit_tydesc(inner, (@*self) as @TyVisitor);
+        }
+        self.types.push(~"]");
         true
     }
-    fn visit_unboxed_vec(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_box(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_uniq(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_slice(_mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_evec_fixed(_n: uint, _sz: uint, _align: uint,
+    fn visit_evec_slice(&self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_fixed(&self, _n: uint, _sz: uint, _align: uint,
                         _mtbl: uint, _inner: *TyDesc) -> bool { true }
 
-    fn visit_enter_rec(_n_fields: uint,
+    fn visit_enter_rec(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
-    fn visit_rec_field(_i: uint, _name: &str,
+    fn visit_rec_field(&self, _i: uint, _name: &str,
                        _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_rec(_n_fields: uint,
+    fn visit_leave_rec(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_class(_n_fields: uint,
+    fn visit_enter_class(&self, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
-    fn visit_class_field(_i: uint, _name: &str,
+    fn visit_class_field(&self, _i: uint, _name: &str,
                          _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_class(_n_fields: uint,
+    fn visit_leave_class(&self, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_tup(_n_fields: uint,
+    fn visit_enter_tup(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
-    fn visit_tup_field(_i: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_tup(_n_fields: uint,
+    fn visit_tup_field(&self, _i: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_tup(&self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_enum(_n_variants: uint,
+    fn visit_enter_enum(&self, _n_variants: uint,
+                        _get_disr: extern unsafe fn(ptr: *Opaque) -> int,
                         _sz: uint, _align: uint) -> bool { true }
-    fn visit_enter_enum_variant(_variant: uint,
+    fn visit_enter_enum_variant(&self,
+                                _variant: uint,
                                 _disr_val: int,
                                 _n_fields: uint,
                                 _name: &str) -> bool { true }
-    fn visit_enum_variant_field(_i: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_enum_variant(_variant: uint,
+    fn visit_enum_variant_field(&self, _i: uint, _offset: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_enum_variant(&self,
+                                _variant: uint,
                                 _disr_val: int,
                                 _n_fields: uint,
                                 _name: &str) -> bool { true }
-    fn visit_leave_enum(_n_variants: uint,
+    fn visit_leave_enum(&self,
+                        _n_variants: uint,
+                        _get_disr: extern unsafe fn(ptr: *Opaque) -> int,
                         _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_fn(_purity: uint, _proto: uint,
+    fn visit_enter_fn(&self, _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,
+    fn visit_fn_input(&self, _i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_fn_output(&self, _retstyle: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_leave_fn(&self, _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 { true }
-    fn visit_constr(_inner: *TyDesc) -> bool { true }
-    fn visit_closure_ptr(_ck: uint) -> bool { true }
+    fn visit_trait(&self) -> bool { true }
+    fn visit_var(&self) -> bool { true }
+    fn visit_var_integral(&self) -> bool { true }
+    fn visit_param(&self, _i: uint) -> bool { true }
+    fn visit_self(&self) -> bool { true }
+    fn visit_type(&self) -> bool { true }
+    fn visit_opaque_box(&self) -> bool { true }
+    fn visit_constr(&self, _inner: *TyDesc) -> bool { true }
+    fn visit_closure_ptr(&self, _ck: uint) -> bool { true }
 }
 
-fn visit_ty<T>(v: TyVisitor) {
-    visit_tydesc(get_tydesc::<T>(), v);
+fn visit_ty<T>(v: @TyVisitor) {
+    unsafe {
+        visit_tydesc(get_tydesc::<T>(), v);
+    }
 }
 
 pub fn main() {
-    let v = my_visitor(@mut {types: ~[]});
-    let vv = v as TyVisitor;
+    let v = @MyVisitor {types: @mut ~[]};
+    let vv = v as @TyVisitor;
 
     visit_ty::<bool>(vv);
     visit_ty::<int>(vv);
@@ -150,9 +162,8 @@ pub fn main() {
     visit_ty::<i16>(vv);
     visit_ty::<~[int]>(vv);
 
-    for (v.types.clone()).each {|s|
-        io::println(fmt!("type: %s", s));
+    for v.types.iter().advance |&s| {
+        println(fmt!("type: %s", s));
     }
-    assert!(v.types == ["bool", "int", "i8", "i16",
-                       "[", "int", "]"]);
+    assert_eq!((*v.types).clone(), ~[~"bool", ~"int", ~"i8", ~"i16", ~"[", ~"int", ~"]"]);
 }
diff --git a/src/test/run-pass/static-mut-foreign.rs b/src/test/run-pass/static-mut-foreign.rs
new file mode 100644
index 00000000000..7af143a1529
--- /dev/null
+++ b/src/test/run-pass/static-mut-foreign.rs
@@ -0,0 +1,46 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Constants (static variables) can be used to match in patterns, but mutable
+// statics cannot. This ensures that there's some form of error if this is
+// attempted.
+
+use std::libc;
+
+#[nolink]
+extern {
+    static mut debug_static_mut: libc::c_int;
+    pub fn debug_static_mut_check_four();
+}
+
+unsafe fn static_bound(_: &'static libc::c_int) {}
+
+fn static_bound_set(a: &'static mut libc::c_int) {
+    *a = 3;
+}
+
+unsafe fn run() {
+    assert!(debug_static_mut == 3);
+    debug_static_mut = 4;
+    assert!(debug_static_mut == 4);
+    debug_static_mut_check_four();
+    debug_static_mut += 1;
+    assert!(debug_static_mut == 5);
+    debug_static_mut *= 3;
+    assert!(debug_static_mut == 15);
+    debug_static_mut = -3;
+    assert!(debug_static_mut == -3);
+    static_bound(&debug_static_mut);
+    static_bound_set(&mut debug_static_mut);
+}
+
+pub fn main() {
+    unsafe { run() }
+}
diff --git a/src/test/run-pass/static-mut-xc.rs b/src/test/run-pass/static-mut-xc.rs
new file mode 100644
index 00000000000..ab6bdc20c49
--- /dev/null
+++ b/src/test/run-pass/static-mut-xc.rs
@@ -0,0 +1,46 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Constants (static variables) can be used to match in patterns, but mutable
+// statics cannot. This ensures that there's some form of error if this is
+// attempted.
+
+// xfail-fast
+// aux-build:static_mut_xc.rs
+
+extern mod static_mut_xc;
+
+unsafe fn static_bound(_: &'static int) {}
+
+fn static_bound_set(a: &'static mut int) {
+    *a = 3;
+}
+
+unsafe fn run() {
+    assert!(static_mut_xc::a == 3);
+    static_mut_xc::a = 4;
+    assert!(static_mut_xc::a == 4);
+    static_mut_xc::a += 1;
+    assert!(static_mut_xc::a == 5);
+    static_mut_xc::a *= 3;
+    assert!(static_mut_xc::a == 15);
+    static_mut_xc::a = -3;
+    assert!(static_mut_xc::a == -3);
+    static_bound(&static_mut_xc::a);
+    static_bound_set(&mut static_mut_xc::a);
+}
+
+pub fn main() {
+    unsafe { run() }
+}
+
+pub mod inner {
+    pub static mut a: int = 4;
+}
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index c25cdc85cb6..dc6bdbf5c1a 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -31,7 +31,10 @@ trait map<T> {
 impl<T> map<T> for ~[T] {
     fn map<U:Copy>(&self, f: &fn(&T) -> U) -> ~[U] {
         let mut r = ~[];
-        for std::vec::each(*self) |x| { r += ~[f(x)]; }
+        // FIXME: #7355 generates bad code with Iterator
+        for std::uint::range(0, self.len()) |i| {
+            r += ~[f(&self[i])];
+        }
         r
     }
 }