Merge pull request #4613 from erickt/incoming

convert most of libcore and libstd to structs, work around tzset race

12 files changed, 555 insertions, 418 deletions

diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs
index 7ac11ecc5cc..eef84ae2422 100644
--- a/src/libstd/arena.rs
+++ b/src/libstd/arena.rs
@@ -68,7 +68,11 @@ const 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.
-type Chunk = {data: @[u8], mut fill: uint, is_pod: bool};
+struct Chunk {
+    data: @[u8],
+    mut fill: uint,
+    is_pod: bool,
+}
 
 pub struct Arena {
     // The head is seperated out from the list as a unbenchmarked
@@ -93,13 +97,19 @@ impl Arena : Drop {
 fn chunk(size: uint, is_pod: bool) -> Chunk {
     let mut v: @[const u8] = @[];
     unsafe { at_vec::raw::reserve(&mut v, size); }
-    { data: unsafe { cast::transmute(v) }, mut fill: 0u, is_pod: is_pod }
+    Chunk {
+        data: unsafe { cast::transmute(v) },
+        fill: 0u,
+        is_pod: is_pod,
+    }
 }
 
 pub fn arena_with_size(initial_size: uint) -> Arena {
-    return Arena {mut head: chunk(initial_size, false),
-                  mut pod_head: chunk(initial_size, true),
-                  mut chunks: @Nil};
+    Arena {
+        head: chunk(initial_size, false),
+        pod_head: chunk(initial_size, true),
+        chunks: @Nil,
+    }
 }
 
 pub fn Arena() -> Arena {
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 71d8743a361..b4217dfb39d 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -61,10 +61,12 @@ pub fn create<T: Copy>() -> Deque<T> {
         match (*elts).get_elt(i) { Some(move t) => t, _ => fail }
     }
 
-    type Repr<T> = {mut nelts: uint,
-                    mut lo: uint,
-                    mut hi: uint,
-                    elts: DVec<Cell<T>>};
+    struct Repr<T> {
+        mut nelts: uint,
+        mut lo: uint,
+        mut hi: uint,
+        elts: DVec<Cell<T>>,
+    }
 
     impl <T: Copy> Repr<T>: Deque<T> {
         fn size() -> uint { return self.nelts; }
@@ -119,15 +121,14 @@ pub fn create<T: Copy>() -> Deque<T> {
         }
     }
 
-    let repr: Repr<T> = {
-        mut nelts: 0u,
-        mut lo: 0u,
-        mut hi: 0u,
-        elts:
-            dvec::from_vec(
-                vec::from_elem(initial_capacity, None))
+    let repr: Repr<T> = Repr {
+        nelts: 0u,
+        lo: 0u,
+        hi: 0u,
+        elts: dvec::from_vec(vec::from_elem(initial_capacity, None)),
     };
-    (move repr) as Deque::<T>
+
+    repr as Deque::<T>
 }
 
 #[cfg(test)]
@@ -254,7 +255,11 @@ mod tests {
         Onepar(int), Twopar(int, int), Threepar(int, int, int),
     }
 
-    type RecCy = {x: int, y: int, t: Taggy};
+    struct RecCy {
+        x: int,
+        y: int,
+        t: Taggy,
+    }
 
     impl Taggy : Eq {
         pure fn eq(&self, other: &Taggy) -> bool {
@@ -335,10 +340,10 @@ mod tests {
 
     #[test]
     fn test_param_reccy() {
-        let reccy1: RecCy = {x: 1, y: 2, t: One(1)};
-        let reccy2: RecCy = {x: 345, y: 2, t: Two(1, 2)};
-        let reccy3: RecCy = {x: 1, y: 777, t: Three(1, 2, 3)};
-        let reccy4: RecCy = {x: 19, y: 252, t: Two(17, 42)};
+        let reccy1 = RecCy { x: 1, y: 2, t: One(1) };
+        let reccy2 = RecCy { x: 345, y: 2, t: Two(1, 2) };
+        let reccy3 = RecCy { x: 1, y: 777, t: Three(1, 2, 3) };
+        let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) };
         test_parameterized::<RecCy>(reccy1, reccy2, reccy3, reccy4);
     }
 }
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 4c05dd154ca..3c890ef0654 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -107,7 +107,11 @@ pub trait Map<K:Eq IterBytes Hash Copy, V: Copy> {
 }
 
 pub mod util {
-    pub type Rational = {num: int, den: int}; // : int::positive(*.den);
+    pub struct Rational {
+        // : int::positive(*.den);
+        num: int,
+        den: int,
+    }
 
     pub pure fn rational_leq(x: Rational, y: Rational) -> bool {
         // NB: Uses the fact that rationals have positive denominators WLOG:
@@ -265,9 +269,11 @@ pub mod chained {
 
                 // consider rehashing if more 3/4 full
                 let nchains = vec::len(self.chains);
-                let load = {num: (self.count + 1u) as int,
-                            den: nchains as int};
-                if !util::rational_leq(load, {num:3, den:4}) {
+                let load = util::Rational {
+                    num: (self.count + 1u) as int,
+                    den: nchains as int,
+                };
+                if !util::rational_leq(load, util::Rational {num:3, den:4}) {
                     self.rehash();
                 }
 
@@ -324,9 +330,11 @@ pub mod chained {
 
                 // consider rehashing if more 3/4 full
                 let nchains = vec::len(self.chains);
-                let load = {num: (self.count + 1u) as int,
-                            den: nchains as int};
-                if !util::rational_leq(load, {num:3, den:4}) {
+                let load = util::Rational {
+                    num: (self.count + 1u) as int,
+                    den: nchains as int,
+                };
+                if !util::rational_leq(load, util::Rational {num:3, den:4}) {
                     self.rehash();
                 }
 
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index d273138ed3d..84c3b755649 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -48,9 +48,9 @@ pub enum IpAddr {
 }
 
 /// Human-friendly feedback on why a parse_addr attempt failed
-pub type ParseAddrErr = {
-    err_msg: ~str
-};
+pub struct ParseAddrErr {
+    err_msg: ~str,
+}
 
 /**
  * Convert a `IpAddr` to a str
@@ -122,7 +122,7 @@ pub fn get_addr(node: &str, iotask: iotask)
                 log(debug, fmt!("slice len %?", len));
                 let handle = create_uv_getaddrinfo_t();
                 let handle_ptr = ptr::addr_of(&handle);
-                let handle_data: GetAddrData = {
+                let handle_data = GetAddrData {
                     output_ch: output_ch
                 };
                 let handle_data_ptr = ptr::addr_of(&handle_data);
@@ -187,7 +187,7 @@ pub mod v4 {
     }
     // the simple, old style numberic representation of
     // ipv4
-    pub type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
+    pub struct Ipv4Rep { a: u8, b: u8, c: u8, d: u8 }
 
     pub trait AsUnsafeU32 {
         unsafe fn as_u32() -> u32;
@@ -207,14 +207,14 @@ pub mod v4 {
             }
         });
         if parts.len() != 4 {
-                result::Err(fmt!("'%s' doesn't have 4 parts", ip))
-                }
-        else if parts.contains(&256) {
-                result::Err(fmt!("invalid octal in addr '%s'", ip))
-                }
-        else {
-            result::Ok({a: parts[0] as u8, b: parts[1] as u8,
-                        c: parts[2] as u8, d: parts[3] as u8})
+            Err(fmt!("'%s' doesn't have 4 parts", ip))
+        } else if parts.contains(&256) {
+            Err(fmt!("invalid octal in addr '%s'", ip))
+        } else {
+            Ok(Ipv4Rep {
+                a: parts[0] as u8, b: parts[1] as u8,
+                c: parts[2] as u8, d: parts[3] as u8,
+            })
         }
     }
     pub fn try_parse_addr(ip: &str) -> result::Result<IpAddr,ParseAddrErr> {
@@ -223,7 +223,7 @@ pub mod v4 {
             let ip_rep_result = parse_to_ipv4_rep(ip);
             if result::is_err(&ip_rep_result) {
                 let err_str = result::get_err(&ip_rep_result);
-                return result::Err({err_msg: err_str})
+                return result::Err(ParseAddrErr { err_msg: err_str })
             }
             // ipv4_rep.as_u32 is unsafe :/
             let input_is_inaddr_none =
@@ -236,15 +236,16 @@ pub mod v4 {
             let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
             if result::is_err(&ref_ip_rep_result) {
                 let err_str = result::get_err(&ref_ip_rep_result);
-                return result::Err({err_msg: err_str})
+                return Err(ParseAddrErr { err_msg: err_str })
             }
+
             if result::get(&ref_ip_rep_result).as_u32() == INADDR_NONE &&
                  !input_is_inaddr_none {
-                return result::Err(
-                    {err_msg: ~"uv_ip4_name produced invalid result."})
-            }
-            else {
-                result::Ok(Ipv4(copy(new_addr)))
+                Err(ParseAddrErr {
+                    err_msg: ~"uv_ip4_name produced invalid result.",
+                })
+            } else {
+                Ok(Ipv4(copy(new_addr)))
             }
         }
     }
@@ -289,19 +290,18 @@ pub mod v6 {
             // '::' appears to be uv_ip6_name() returns for bogus
             // parses..
             if  ip != &"::" && reparsed_name == ~"::" {
-                result::Err({err_msg:fmt!("failed to parse '%s'",
-                                           ip)})
+                Err(ParseAddrErr { err_msg:fmt!("failed to parse '%s'", ip) })
             }
             else {
-                result::Ok(Ipv6(new_addr))
+                Ok(Ipv6(new_addr))
             }
         }
     }
 }
 
-type GetAddrData = {
+struct GetAddrData {
     output_ch: oldcomm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
-};
+}
 
 extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                       res: *addrinfo) {
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index aeb0c2cb613..aa5eec2b43c 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -83,10 +83,11 @@ pub fn TcpSocketBuf(data: @TcpBufferedSocketData) -> TcpSocketBuf {
 }
 
 /// Contains raw, string-based, error information returned from libuv
-pub type TcpErrData = {
+pub struct TcpErrData {
     err_name: ~str,
-    err_msg: ~str
-};
+    err_msg: ~str,
+}
+
 /// Details returned as part of a `result::err` result from `tcp::listen`
 pub enum TcpListenErrData {
     /**
@@ -155,7 +156,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
         let reader_po = oldcomm::Port::<result::Result<~[u8], TcpErrData>>();
         let stream_handle_ptr = malloc_uv_tcp_t();
         *(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
-        let socket_data = @{
+        let socket_data = @TcpSocketData {
             reader_po: reader_po,
             reader_ch: oldcomm::Chan(&reader_po),
             stream_handle_ptr: stream_handle_ptr,
@@ -231,7 +232,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                         // ip or somesuch
                         let err_data = uv::ll::get_last_err_data(loop_ptr);
                         oldcomm::send((*conn_data_ptr).result_ch,
-                                   ConnFailure(err_data.to_tcp_err()));
+                                   ConnFailure(err_data));
                         uv::ll::set_data_for_uv_handle(stream_handle_ptr,
                                                        conn_data_ptr);
                         uv::ll::close(stream_handle_ptr,
@@ -243,7 +244,7 @@ pub fn connect(input_ip: ip::IpAddr, port: uint,
                     // failure to create a tcp handle
                     let err_data = uv::ll::get_last_err_data(loop_ptr);
                     oldcomm::send((*conn_data_ptr).result_ch,
-                               ConnFailure(err_data.to_tcp_err()));
+                               ConnFailure(err_data));
                   }
                 }
             }
@@ -513,7 +514,7 @@ pub fn accept(new_conn: TcpNewConnection)
             let iotask = (*server_data_ptr).iotask;
             let stream_handle_ptr = malloc_uv_tcp_t();
             *(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
-            let client_socket_data = @{
+            let client_socket_data = @TcpSocketData {
                 reader_po: reader_po,
                 reader_ch: oldcomm::Chan(&reader_po),
                 stream_handle_ptr : stream_handle_ptr,
@@ -785,7 +786,7 @@ fn listen_common(host_ip: ip::IpAddr, port: uint, backlog: uint,
  * A buffered wrapper that you can cast as an `io::reader` or `io::writer`
  */
 pub fn socket_buf(sock: TcpSocket) -> TcpSocketBuf {
-    TcpSocketBuf(@{ sock: move sock, mut buf: ~[] })
+    TcpSocketBuf(@TcpBufferedSocketData { sock: sock, buf: ~[] })
 }
 
 /// Convenience methods extending `net::tcp::tcp_socket`
@@ -979,7 +980,7 @@ fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
             match move read_result {
               None => {
                 log(debug, ~"tcp::read: timed out..");
-                let err_data = {
+                let err_data = TcpErrData {
                     err_name: ~"TIMEOUT",
                     err_msg: ~"req timed out"
                 };
@@ -1020,9 +1021,10 @@ fn read_stop_common_impl(socket_data: *TcpSocketData) ->
                 }
             }
         };
+
         match oldcomm::recv(stop_po) {
-          Some(ref err_data) => result::Err(err_data.to_tcp_err()),
-          None => result::Ok(())
+          Some(move err_data) => Err(err_data),
+          None => Ok(())
         }
     }
 }
@@ -1108,8 +1110,8 @@ fn write_common_impl(socket_data_ptr: *TcpSocketData,
         // ownership of everything to the I/O task and let it deal with the
         // aftermath, so we don't have to sit here blocking.
         match oldcomm::recv(result_po) {
-          TcpWriteSuccess => result::Ok(()),
-          TcpWriteError(ref err_data) => result::Err(err_data.to_tcp_err())
+            TcpWriteSuccess => Ok(()),
+            TcpWriteError(move err_data) => Err(err_data)
         }
     }
 }
@@ -1118,15 +1120,15 @@ enum TcpNewConnection {
     NewTcpConn(*uv::ll::uv_tcp_t)
 }
 
-type TcpListenFcData = {
+struct TcpListenFcData {
     server_stream_ptr: *uv::ll::uv_tcp_t,
     stream_closed_ch: oldcomm::Chan<()>,
     kill_ch: oldcomm::Chan<Option<TcpErrData>>,
     on_connect_cb: fn~(*uv::ll::uv_tcp_t),
     iotask: IoTask,
     ipv6: bool,
-    mut active: bool
-};
+    mut active: bool,
+}
 
 extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) {
     unsafe {
@@ -1191,7 +1193,7 @@ trait ToTcpErr {
 
 impl uv::ll::uv_err_data: ToTcpErr {
     fn to_tcp_err() -> TcpErrData {
-        { err_name: self.err_name, err_msg: self.err_msg }
+        TcpErrData { err_name: self.err_name, err_msg: self.err_msg }
     }
 }
 
@@ -1244,9 +1246,9 @@ extern fn on_alloc_cb(handle: *libc::c_void,
     }
 }
 
-type TcpSocketCloseData = {
-    closed_ch: oldcomm::Chan<()>
-};
+struct TcpSocketCloseData {
+    closed_ch: oldcomm::Chan<()>,
+}
 
 extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) {
     unsafe {
@@ -1273,19 +1275,19 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             log(debug, ~"failure to write");
             oldcomm::send((*write_data_ptr).result_ch,
-                             TcpWriteError(err_data));
+                             TcpWriteError(err_data.to_tcp_err()));
         }
     }
 }
 
-type WriteReqData = {
-    result_ch: oldcomm::Chan<TcpWriteResult>
-};
+struct WriteReqData {
+    result_ch: oldcomm::Chan<TcpWriteResult>,
+}
 
-type ConnectReqData = {
+struct ConnectReqData {
     result_ch: oldcomm::Chan<ConnAttempt>,
-    closed_signal_ch: oldcomm::Chan<()>
-};
+    closed_signal_ch: oldcomm::Chan<()>,
+}
 
 extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) {
     unsafe {
@@ -1337,20 +1339,20 @@ enum ConnAttempt {
     ConnFailure(uv::ll::uv_err_data)
 }
 
-type TcpSocketData = {
+struct TcpSocketData {
     reader_po: oldcomm::Port<result::Result<~[u8], TcpErrData>>,
     reader_ch: oldcomm::Chan<result::Result<~[u8], TcpErrData>>,
     stream_handle_ptr: *uv::ll::uv_tcp_t,
     connect_req: uv::ll::uv_connect_t,
     write_req: uv::ll::uv_write_t,
     ipv6: bool,
-    iotask: IoTask
-};
+    iotask: IoTask,
+}
 
-type TcpBufferedSocketData = {
+struct TcpBufferedSocketData {
     sock: TcpSocket,
-    mut buf: ~[u8]
-};
+    mut buf: ~[u8],
+}
 
 //#[cfg(test)]
 pub mod test {
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index c469824f48d..8c6d77c8828 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -595,12 +595,12 @@ pub mod node {
      *     string can be shared between several ropes, e.g. for indexing
      *     purposes.
      */
-    pub type Leaf = {
+    pub struct Leaf {
         byte_offset: uint,
-        byte_len:    uint,
-        char_len:   uint,
-        content:    @~str
-    };
+        byte_len: uint,
+        char_len: uint,
+        content: @~str,
+    }
 
     /**
      * A node obtained from the concatenation of two other nodes
@@ -619,14 +619,14 @@ pub mod node {
      *
      *     Used for rebalancing and to allocate stacks for traversals.
      */
-    pub type Concat = {
+    pub struct Concat {
         //FIXME (#2744): Perhaps a `vec` instead of `left`/`right`
-        left:     @Node,
-        right:    @Node,
+        left: @Node,
+        right: @Node,
         char_len: uint,
         byte_len: uint,
-        height:   uint
-    };
+        height: uint,
+    }
 
     pub enum Node {
         /// A leaf consisting in a `str`
@@ -709,11 +709,12 @@ pub mod node {
     pub fn of_substr_unsafer(str: @~str, byte_start: uint, byte_len: uint,
                              char_len: uint) -> @Node {
         assert(byte_start + byte_len <= str::len(*str));
-        let candidate = @Leaf({
-                byte_offset: byte_start,
-                byte_len:    byte_len,
-                char_len:    char_len,
-                content:     str});
+        let candidate = @Leaf(Leaf {
+            byte_offset: byte_start,
+            byte_len: byte_len,
+            char_len: char_len,
+            content: str,
+        });
         if char_len <= hint_max_leaf_char_len {
             return candidate;
         } else {
@@ -736,11 +737,11 @@ pub mod node {
                     else { hint_max_leaf_char_len };
                 let chunk_byte_len =
                     str::count_bytes(*str, offset, chunk_char_len);
-                nodes[i] = @Leaf({
+                nodes[i] = @Leaf(Leaf {
                     byte_offset: offset,
-                    byte_len:    chunk_byte_len,
-                    char_len:    chunk_char_len,
-                    content:     str
+                    byte_len: chunk_byte_len,
+                    char_len: chunk_char_len,
+                    content: str,
                 });
 
                 offset += chunk_byte_len;
@@ -767,15 +768,15 @@ pub mod node {
     pub pure fn byte_len(node: @Node) -> uint {
         //FIXME (#2744): Could we do this without the pattern-matching?
         match (*node) {
-          Leaf(y)   => return y.byte_len,
-          Concat(ref y) => return y.byte_len
+          Leaf(y) => y.byte_len,
+          Concat(ref y) => y.byte_len
         }
     }
 
     pub pure fn char_len(node: @Node) -> uint {
         match (*node) {
-          Leaf(y)   => return y.char_len,
-          Concat(ref y) => return y.char_len
+          Leaf(y) => y.char_len,
+          Concat(ref y) => y.char_len
         }
     }
 
@@ -867,15 +868,15 @@ pub mod node {
     pub fn flatten(node: @Node) -> @Node {
         unsafe {
             match (*node) {
-              Leaf(_) => return node,
-              Concat(ref x) => {
-                return @Leaf({
-                    byte_offset: 0u,
-                    byte_len:    x.byte_len,
-                    char_len:    x.char_len,
-                    content:     @serialize_node(node)
-                })
-              }
+                Leaf(_) => node,
+                Concat(ref x) => {
+                    @Leaf(Leaf {
+                        byte_offset: 0u,
+                        byte_len: x.byte_len,
+                        char_len: x.char_len,
+                        content: @serialize_node(node),
+                    })
+                }
             }
         }
     }
@@ -943,10 +944,12 @@ pub mod node {
               node::Leaf(x) => {
                 let char_len =
                     str::count_chars(*x.content, byte_offset, byte_len);
-                return @Leaf({byte_offset: byte_offset,
-                                byte_len:    byte_len,
-                                char_len:    char_len,
-                                content:     x.content});
+                return @Leaf(Leaf {
+                    byte_offset: byte_offset,
+                    byte_len: byte_len,
+                    char_len: char_len,
+                    content: x.content,
+                });
               }
               node::Concat(ref x) => {
                 let left_len: uint = node::byte_len(x.left);
@@ -1007,10 +1010,12 @@ pub mod node {
                     str::count_bytes(*x.content, 0u, char_offset);
                 let byte_len    =
                     str::count_bytes(*x.content, byte_offset, char_len);
-                return @Leaf({byte_offset: byte_offset,
-                           byte_len:    byte_len,
-                           char_len:    char_len,
-                           content:     x.content});
+                return @Leaf(Leaf {
+                    byte_offset: byte_offset,
+                    byte_len: byte_len,
+                    char_len: char_len,
+                    content: x.content,
+                });
               }
               node::Concat(ref x) => {
                 if char_offset == 0u && char_len == x.char_len {return node;}
@@ -1040,18 +1045,19 @@ pub mod node {
     }
 
     pub fn concat2(left: @Node, right: @Node) -> @Node {
-        return @Concat({left    : left,
-                     right   : right,
-             char_len: char_len(left) + char_len(right),
-                     byte_len: byte_len(left) + byte_len(right),
-             height: uint::max(height(left), height(right)) + 1u
-                    })
+        @Concat(Concat {
+            left: left,
+            right: right,
+            char_len: char_len(left) + char_len(right),
+            byte_len: byte_len(left) + byte_len(right),
+            height: uint::max(height(left), height(right)) + 1u,
+        })
     }
 
     pub pure fn height(node: @Node) -> uint {
         match (*node) {
-          Leaf(_)   => return 0u,
-          Concat(ref x) => return x.height
+          Leaf(_) => 0u,
+          Concat(ref x) => x.height,
         }
     }
 
@@ -1135,7 +1141,7 @@ pub mod node {
         loop {
             match *node {
               Leaf(x) => return str::char_at(*x.content, pos),
-              Concat({left, right, _}) => {
+              Concat(Concat {left, right, _}) => {
                 let left_len = char_len(left);
                 node = if left_len > pos { left }
                        else { pos -= left_len; right };
@@ -1151,22 +1157,22 @@ pub mod node {
         use core::prelude::*;
         use core::vec;
 
-        pub type T = {
-            stack:            ~[mut @Node],
-            mut stackpos: int
-        };
+        pub struct T {
+            stack: ~[mut @Node],
+            mut stackpos: int,
+        }
 
         pub fn empty() -> T {
             let stack : ~[mut @Node] = ~[mut];
-            return {stack: move stack, mut stackpos: -1}
+            T { stack: stack, stackpos: -1 }
         }
 
         pub fn start(node: @Node) -> T {
             let stack = vec::cast_to_mut(
                 vec::from_elem(height(node)+1u, node));
-            return {
-                stack:         move stack,
-                mut stackpos:  0
+            T {
+                stack: stack,
+                stackpos:  0,
             }
         }
 
@@ -1196,25 +1202,25 @@ pub mod node {
         use core::prelude::*;
         use core::str;
 
-        pub type T = {
+        pub struct T {
             leaf_iterator: leaf_iterator::T,
             mut leaf:  Option<Leaf>,
-            mut leaf_byte_pos: uint
-        };
+            mut leaf_byte_pos: uint,
+        }
 
         pub fn start(node: @Node) -> T {
-            return {
+            T {
                 leaf_iterator: leaf_iterator::start(node),
-                mut leaf:          option::None,
-                mut leaf_byte_pos: 0u
+                leaf: option::None,
+                leaf_byte_pos: 0u,
             }
         }
 
         pub fn empty() -> T {
-            return {
+            T {
                 leaf_iterator: leaf_iterator::empty(),
-                mut leaf:  option::None,
-                mut leaf_byte_pos: 0u
+                leaf:  option::None,
+                leaf_byte_pos: 0u,
             }
         }
 
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 7a524eb7985..51c209b1b5f 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -284,7 +284,10 @@ mod tests {
     #[test]
     fn test() {
         unsafe {
-            type Test = {input: ~str, output: ~[u8]};
+            struct Test {
+                input: ~str,
+                output: ~[u8],
+            }
 
             fn a_million_letter_a() -> ~str {
                 let mut i = 0;
@@ -297,47 +300,64 @@ mod tests {
             }
             // Test messages from FIPS 180-1
 
-            let fips_180_1_tests: ~[Test] =
-                ~[{input: ~"abc",
-                  output:
-                      ~[0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
-                       0x47u8, 0x06u8, 0x81u8, 0x6Au8,
-                       0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
-                       0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
-                       0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8]},
-                 {input:
-                      ~"abcdbcdecdefdefgefghfghighij" +
-                      ~"hijkijkljklmklmnlmnomnopnopq",
-                  output:
-                      ~[0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
-                       0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
-                       0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
-                       0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
-                       0xE5u8, 0x46u8, 0x70u8, 0xF1u8]},
-                 {input: a_million_letter_a(),
-                  output:
-                      ~[0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
-                       0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
-                       0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
-                       0xDBu8, 0xADu8, 0x27u8, 0x31u8,
-                       0x65u8, 0x34u8, 0x01u8, 0x6Fu8]}];
+            let fips_180_1_tests = ~[
+                Test {
+                    input: ~"abc",
+                    output: ~[
+                        0xA9u8, 0x99u8, 0x3Eu8, 0x36u8,
+                        0x47u8, 0x06u8, 0x81u8, 0x6Au8,
+                        0xBAu8, 0x3Eu8, 0x25u8, 0x71u8,
+                        0x78u8, 0x50u8, 0xC2u8, 0x6Cu8,
+                        0x9Cu8, 0xD0u8, 0xD8u8, 0x9Du8,
+                    ],
+                },
+                Test {
+                    input:
+                         ~"abcdbcdecdefdefgefghfghighij" +
+                         ~"hijkijkljklmklmnlmnomnopnopq",
+                    output: ~[
+                        0x84u8, 0x98u8, 0x3Eu8, 0x44u8,
+                        0x1Cu8, 0x3Bu8, 0xD2u8, 0x6Eu8,
+                        0xBAu8, 0xAEu8, 0x4Au8, 0xA1u8,
+                        0xF9u8, 0x51u8, 0x29u8, 0xE5u8,
+                        0xE5u8, 0x46u8, 0x70u8, 0xF1u8,
+                    ],
+                },
+                Test {
+                    input: a_million_letter_a(),
+                    output: ~[
+                        0x34u8, 0xAAu8, 0x97u8, 0x3Cu8,
+                        0xD4u8, 0xC4u8, 0xDAu8, 0xA4u8,
+                        0xF6u8, 0x1Eu8, 0xEBu8, 0x2Bu8,
+                        0xDBu8, 0xADu8, 0x27u8, 0x31u8,
+                        0x65u8, 0x34u8, 0x01u8, 0x6Fu8,
+                    ],
+                },
+            ];
             // Examples from wikipedia
 
-            let wikipedia_tests: ~[Test] =
-                ~[{input: ~"The quick brown fox jumps over the lazy dog",
-                  output:
-                      ~[0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
-                       0x7au8, 0x2du8, 0x28u8, 0xfcu8,
-                       0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
-                       0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
-                       0x1bu8, 0x93u8, 0xebu8, 0x12u8]},
-                 {input: ~"The quick brown fox jumps over the lazy cog",
-                  output:
-                      ~[0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
-                       0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
-                       0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
-                       0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
-                       0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
+            let wikipedia_tests = ~[
+                Test {
+                    input: ~"The quick brown fox jumps over the lazy dog",
+                    output: ~[
+                        0x2fu8, 0xd4u8, 0xe1u8, 0xc6u8,
+                        0x7au8, 0x2du8, 0x28u8, 0xfcu8,
+                        0xedu8, 0x84u8, 0x9eu8, 0xe1u8,
+                        0xbbu8, 0x76u8, 0xe7u8, 0x39u8,
+                        0x1bu8, 0x93u8, 0xebu8, 0x12u8,
+                    ],
+                },
+                Test {
+                    input: ~"The quick brown fox jumps over the lazy cog",
+                    output: ~[
+                        0xdeu8, 0x9fu8, 0x2cu8, 0x7fu8,
+                        0xd2u8, 0x5eu8, 0x1bu8, 0x3au8,
+                        0xfau8, 0xd3u8, 0xe8u8, 0x5au8,
+                        0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
+                        0x10u8, 0x0du8, 0xb4u8, 0xb3u8,
+                    ],
+                },
+            ];
             let tests = fips_180_1_tests + wikipedia_tests;
             fn check_vec_eq(v0: ~[u8], v1: ~[u8]) {
                 assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index dbcb0c6aeec..feabb678d66 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -25,7 +25,9 @@ use core::prelude::*;
 
 // FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
 // requires this to be.
-type SmallIntMap_<T: Copy> = {v: DVec<Option<T>>};
+struct SmallIntMap_<T: Copy> {
+    v: DVec<Option<T>>,
+}
 
 pub enum SmallIntMap<T:Copy> {
     SmallIntMap_(@SmallIntMap_<T>)
@@ -34,7 +36,7 @@ pub enum SmallIntMap<T:Copy> {
 /// Create a smallintmap
 pub fn mk<T: Copy>() -> SmallIntMap<T> {
     let v = DVec();
-    return SmallIntMap_(@{v: move v});
+    SmallIntMap_(@SmallIntMap_ { v: v } )
 }
 
 /**
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 95523c1e578..7b94702f974 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -74,8 +74,11 @@ pub fn test_main(args: &[~str], tests: &[TestDesc]) {
     if !run_tests_console(&opts, tests) { fail ~"Some tests failed"; }
 }
 
-pub type TestOpts = {filter: Option<~str>, run_ignored: bool,
-                  logfile: Option<~str>};
+pub struct TestOpts {
+    filter: Option<~str>,
+    run_ignored: bool,
+    logfile: Option<~str>,
+}
 
 type OptRes = Either<TestOpts, ~str>;
 
@@ -97,10 +100,13 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
     let run_ignored = getopts::opt_present(&matches, ~"ignored");
     let logfile = getopts::opt_maybe_str(&matches, ~"logfile");
 
-    let test_opts = {filter: filter, run_ignored: run_ignored,
-                     logfile: logfile};
+    let test_opts = TestOpts {
+        filter: filter,
+        run_ignored: run_ignored,
+        logfile: logfile,
+    };
 
-    return either::Left(test_opts);
+    either::Left(test_opts)
 }
 
 #[deriving_eq]
@@ -396,7 +402,10 @@ pub fn filter_tests(opts: &TestOpts,
     move filtered
 }
 
-type TestFuture = {test: TestDesc, wait: fn@() -> TestResult};
+struct TestFuture {
+    test: TestDesc,
+    wait: fn@() -> TestResult,
+}
 
 pub fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
     if test.ignore {
@@ -431,7 +440,7 @@ mod tests {
     #[legacy_exports];
 
     use test::{TrFailed, TrIgnored, TrOk, filter_tests, parse_opts, TestDesc};
-    use test::{run_test};
+    use test::{TestOpts, run_test};
 
     use core::either;
     use core::oldcomm;
@@ -528,13 +537,26 @@ mod tests {
         // When we run ignored tests the test filter should filter out all the
         // unignored tests and flip the ignore flag on the rest to false
 
-        let opts = {filter: option::None, run_ignored: true,
-            logfile: option::None};
-        let tests =
-            ~[TestDesc {name: ~"1", testfn: fn~() { },
-                        ignore: true, should_fail: false},
-              TestDesc {name: ~"2", testfn: fn~() { },
-                        ignore: false, should_fail: false}];
+        let opts = TestOpts {
+            filter: option::None,
+            run_ignored: true,
+            logfile: option::None,
+        };
+
+        let tests = ~[
+            TestDesc {
+                name: ~"1",
+                testfn: fn~() { },
+                ignore: true,
+                should_fail: false,
+            },
+            TestDesc {
+                name: ~"2",
+                testfn: fn~() { },
+                ignore: false,
+                should_fail: false,
+            },
+        ];
         let filtered = filter_tests(&opts, tests);
 
         assert (vec::len(filtered) == 1u);
@@ -544,8 +566,11 @@ mod tests {
 
     #[test]
     fn sort_tests() {
-        let opts = {filter: option::None, run_ignored: false,
-            logfile: option::None};
+        let opts = TestOpts {
+            filter: option::None,
+            run_ignored: false,
+            logfile: option::None,
+        };
 
         let names =
             ~[~"sha1::test", ~"int::test_to_str", ~"int::test_pow",
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 61202401359..731767d475f 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -902,7 +902,6 @@ mod tests {
     use core::uint;
     use core::vec;
 
-    #[test]
     fn test_get_time() {
         const some_recent_date: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
         const some_future_date: i64 = 1577836800i64; // 2020-01-01T00:00:00Z
@@ -926,7 +925,6 @@ mod tests {
         }
     }
 
-    #[test]
     fn test_precise_time() {
         let s0 = precise_time_s();
         let ns1 = precise_time_ns();
@@ -944,7 +942,6 @@ mod tests {
         assert ns2 >= ns1;
     }
 
-    #[test]
     fn test_at_utc() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -966,7 +963,6 @@ mod tests {
         assert utc.tm_nsec == 54321_i32;
     }
 
-    #[test]
     fn test_at() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -995,7 +991,6 @@ mod tests {
         assert local.tm_nsec == 54321_i32;
     }
 
-    #[test]
     fn test_to_timespec() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -1007,7 +1002,6 @@ mod tests {
         assert utc.to_local().to_timespec() == time;
     }
 
-    #[test]
     fn test_conversions() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -1024,7 +1018,6 @@ mod tests {
         assert utc.to_local().to_utc() == utc;
     }
 
-    #[test]
     fn test_strptime() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -1179,8 +1172,6 @@ mod tests {
         assert test(~"%", ~"%%");
     }
 
-    #[test]
-    #[ignore(reason = "randomred")]
     fn test_ctime() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -1195,8 +1186,6 @@ mod tests {
         assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";
     }
 
-    #[test]
-    #[ignore(reason = "randomred")]
     fn test_strftime() {
         os::setenv(~"TZ", ~"America/Los_Angeles");
         tzset();
@@ -1270,7 +1259,6 @@ mod tests {
         assert utc.rfc3339() == ~"2009-02-13T23:31:30Z";
     }
 
-    #[test]
     fn test_timespec_eq_ord() {
         use core::cmp::{eq, ge, gt, le, lt, ne};
 
@@ -1303,4 +1291,20 @@ mod tests {
         assert gt(c, b);
         assert gt(d, c);
     }
+
+    #[test]
+    fn run_tests() {
+        // The tests race on tzset. So instead of having many independent
+        // tests, we will just call the functions now.
+        test_get_time();
+        test_precise_time();
+        test_at_utc();
+        test_at();
+        test_to_timespec();
+        test_conversions();
+        test_strptime();
+        test_ctime();
+        test_strftime();
+        test_timespec_eq_ord();
+    }
 }
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 667708cfb3f..0a3d64a02a4 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -111,7 +111,7 @@ fn run_loop(iotask_ch: Chan<IoTask>) {
         ll::async_init(loop_ptr, async_handle, wake_up_cb);
 
         // initialize our loop data and store it in the loop
-        let data: IoTaskLoopData = {
+        let data = IoTaskLoopData {
             async_handle: async_handle,
             msg_po: Port()
         };
@@ -134,10 +134,10 @@ fn run_loop(iotask_ch: Chan<IoTask>) {
 }
 
 // data that lives for the lifetime of the high-evel oo
-type IoTaskLoopData = {
+struct IoTaskLoopData {
     async_handle: *ll::uv_async_t,
-    msg_po: Port<IoTaskMsg>
-};
+    msg_po: Port<IoTaskMsg>,
+}
 
 fn send_msg(iotask: IoTask, msg: IoTaskMsg) {
     unsafe {
@@ -214,10 +214,10 @@ mod test {
             ll::close(handle, async_close_cb);
         }
     }
-    type AhData = {
+    struct AhData {
         iotask: IoTask,
-        exit_ch: oldcomm::Chan<()>
-    };
+        exit_ch: oldcomm::Chan<()>,
+    }
     fn impl_uv_iotask_async(iotask: IoTask) {
         unsafe {
             let async_handle = ll::async_t();
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 17b11945028..5060ae1a722 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -41,10 +41,10 @@ use core::str;
 use core::vec;
 
 // libuv struct mappings
-pub type uv_ip4_addr = {
+pub struct uv_ip4_addr {
     ip: ~[u8],
-    port: int
-};
+    port: int,
+}
 pub type uv_ip6_addr = uv_ip4_addr;
 
 pub enum uv_handle_type {
@@ -67,31 +67,31 @@ pub enum uv_handle_type {
 
 pub type handle_type = libc::c_uint;
 
-pub type uv_handle_fields = {
+pub struct uv_handle_fields {
    loop_handle: *libc::c_void,
    type_: handle_type,
    close_cb: *u8,
    mut data: *libc::c_void,
-};
+}
 
 // unix size: 8
-pub type uv_err_t = {
+pub struct uv_err_t {
     code: libc::c_int,
     sys_errno_: libc::c_int
-};
+}
 
 // don't create one of these directly. instead,
 // count on it appearing in libuv callbacks or embedded
 // in other types as a pointer to be used in other
 // operations (so mostly treat it as opaque, once you
 // have it in this form..)
-pub type uv_stream_t = {
-    fields: uv_handle_fields
-};
+pub struct uv_stream_t {
+    fields: uv_handle_fields,
+}
 
 // 64bit unix size: 272
 #[cfg(unix)]
-pub type uv_tcp_t = {
+pub struct uv_tcp_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
@@ -101,24 +101,24 @@ pub type uv_tcp_t = {
     a20: *u8, a21: *u8, a22: *u8, a23: *u8,
     a24: *u8, a25: *u8, a26: *u8, a27: *u8,
     a28: *u8,
-    a30: uv_tcp_t_32bit_unix_riders
-};
+    a30: uv_tcp_t_32bit_unix_riders,
+}
 // 32bit unix size: 328 (164)
 #[cfg(target_arch="x86_64")]
-pub type uv_tcp_t_32bit_unix_riders = {
-    a29: *u8
-};
+pub struct uv_tcp_t_32bit_unix_riders {
+    a29: *u8,
+}
 #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-pub type uv_tcp_t_32bit_unix_riders = {
+pub struct uv_tcp_t_32bit_unix_riders {
     a29: *u8, a30: *u8, a31: *u8,
     a32: *u8, a33: *u8, a34: *u8,
-    a35: *u8, a36: *u8
-};
+    a35: *u8, a36: *u8,
+}
 
 // 32bit win32 size: 240 (120)
 #[cfg(windows)]
-pub type uv_tcp_t = {
+pub struct uv_tcp_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
@@ -126,140 +126,140 @@ pub type uv_tcp_t = {
     a12: *u8, a13: *u8, a14: *u8, a15: *u8,
     a16: *u8, a17: *u8, a18: *u8, a19: *u8,
     a20: *u8, a21: *u8, a22: *u8, a23: *u8,
-    a24: *u8, a25: *u8
-};
+    a24: *u8, a25: *u8,
+}
 
 // unix size: 48
 #[cfg(unix)]
-pub type uv_connect_t = {
+pub struct uv_connect_t {
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
-    a04: *u8, a05: *u8
-};
+    a04: *u8, a05: *u8,
+}
 // win32 size: 88 (44)
 #[cfg(windows)]
-pub type uv_connect_t = {
+pub struct uv_connect_t {
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
-    a08: *u8, a09: *u8, a10: *u8
-};
+    a08: *u8, a09: *u8, a10: *u8,
+}
 
 // unix size: 16
-pub type uv_buf_t = {
+pub struct uv_buf_t {
     base: *u8,
-    len: libc::size_t
-};
+    len: libc::size_t,
+}
 // no gen stub method.. should create
 // it via uv::direct::buf_init()
 
 // unix size: 144
 #[cfg(unix)]
-pub type uv_write_t = {
+pub struct uv_write_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
     a08: *u8, a09: *u8, a10: *u8, a11: *u8,
     a12: *u8,
-    a14: uv_write_t_32bit_unix_riders
-};
+    a14: uv_write_t_32bit_unix_riders,
+}
 #[cfg(target_arch="x86_64")]
-pub type uv_write_t_32bit_unix_riders = {
-    a13: *u8
-};
+pub struct uv_write_t_32bit_unix_riders {
+    a13: *u8,
+}
 #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-pub type uv_write_t_32bit_unix_riders = {
-    a13: *u8, a14: *u8
-};
+pub struct uv_write_t_32bit_unix_riders {
+    a13: *u8, a14: *u8,
+}
 // win32 size: 136 (68)
 #[cfg(windows)]
-pub type uv_write_t = {
+pub struct uv_write_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
     a08: *u8, a09: *u8, a10: *u8, a11: *u8,
-    a12: *u8
-};
+    a12: *u8,
+}
 // 64bit unix size: 120
 // 32bit unix size: 152 (76)
 #[cfg(unix)]
-pub type uv_async_t = {
+pub struct uv_async_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
     a08: *u8, a09: *u8,
-    a11: uv_async_t_32bit_unix_riders
-};
+    a11: uv_async_t_32bit_unix_riders,
+}
 #[cfg(target_arch="x86_64")]
-pub type uv_async_t_32bit_unix_riders = {
-    a10: *u8
-};
+pub struct uv_async_t_32bit_unix_riders {
+    a10: *u8,
+}
 #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-pub type uv_async_t_32bit_unix_riders = {
-    a10: *u8, a11: *u8, a12: *u8, a13: *u8
-};
+pub struct uv_async_t_32bit_unix_riders {
+    a10: *u8, a11: *u8, a12: *u8, a13: *u8,
+}
 // win32 size 132 (68)
 #[cfg(windows)]
-pub type uv_async_t = {
+pub struct uv_async_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
     a08: *u8, a09: *u8, a10: *u8, a11: *u8,
-    a12: *u8
-};
+    a12: *u8,
+}
 
 // 64bit unix size: 128
 // 32bit unix size: 84
 #[cfg(unix)]
-pub type uv_timer_t = {
+pub struct uv_timer_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
     a08: *u8, a09: *u8,
-    a11: uv_timer_t_32bit_unix_riders
-};
+    a11: uv_timer_t_32bit_unix_riders,
+}
 #[cfg(target_arch="x86_64")]
-pub type uv_timer_t_32bit_unix_riders = {
-    a10: *u8, a11: *u8
-};
+pub struct uv_timer_t_32bit_unix_riders {
+    a10: *u8, a11: *u8,
+}
 #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-pub type uv_timer_t_32bit_unix_riders = {
+pub struct uv_timer_t_32bit_unix_riders {
     a10: *u8, a11: *u8, a12: *u8, a13: *u8,
-    a14: *u8, a15: *u8, a16: *u8
-};
+    a14: *u8, a15: *u8, a16: *u8,
+}
 // win32 size: 64
 #[cfg(windows)]
-pub type uv_timer_t = {
+pub struct uv_timer_t {
     fields: uv_handle_fields,
     a00: *u8, a01: *u8, a02: *u8, a03: *u8,
     a04: *u8, a05: *u8, a06: *u8, a07: *u8,
-    a08: *u8, a09: *u8, a10: *u8, a11: *u8
-};
+    a08: *u8, a09: *u8, a10: *u8, a11: *u8,
+}
 
 // unix size: 16
-pub type sockaddr_in = {
+pub struct sockaddr_in {
     mut sin_family: u16,
     mut sin_port: u16,
     mut sin_addr: u32, // in_addr: this is an opaque, per-platform struct
-    mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8)
-};
+    mut sin_zero: (u8, u8, u8, u8, u8, u8, u8, u8),
+}
 
 // unix size: 28 .. FIXME #1645
 // stuck with 32 becuse of rust padding structs?
 #[cfg(target_arch="x86_64")]
-pub type sockaddr_in6 = {
+pub struct sockaddr_in6 {
     a0: *u8, a1: *u8,
-    a2: *u8, a3: *u8
-};
+    a2: *u8, a3: *u8,
+}
 #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-pub type sockaddr_in6 = {
+pub struct sockaddr_in6 {
     a0: *u8, a1: *u8,
     a2: *u8, a3: *u8,
     a4: *u8, a5: *u8,
-    a6: *u8, a7: *u8
-};
+    a6: *u8, a7: *u8,
+}
 
 // unix size: 28 .. FIXME #1645
 // stuck with 32 becuse of rust padding structs?
@@ -267,25 +267,25 @@ pub type addr_in = addr_in_impl::addr_in;
 #[cfg(unix)]
 pub mod addr_in_impl {
     #[cfg(target_arch="x86_64")]
-    pub type addr_in = {
+    pub struct addr_in {
         a0: *u8, a1: *u8,
-        a2: *u8, a3: *u8
-    };
+        a2: *u8, a3: *u8,
+    }
     #[cfg(target_arch="x86")]
 #[cfg(target_arch="arm")]
-    pub type addr_in = {
+    pub struct addr_in {
         a0: *u8, a1: *u8,
         a2: *u8, a3: *u8,
         a4: *u8, a5: *u8,
         a6: *u8, a7: *u8,
-    };
+    }
 }
 #[cfg(windows)]
 pub mod addr_in_impl {
-    pub type addr_in = {
+    pub struct addr_in {
         a0: *u8, a1: *u8,
-        a2: *u8, a3: *u8
-    };
+        a2: *u8, a3: *u8,
+    }
 }
 
 // unix size: 48, 32bit: 32
@@ -294,42 +294,60 @@ pub type addrinfo = addrinfo_impl::addrinfo;
 #[cfg(target_os="android")]
 pub mod addrinfo_impl {
     #[cfg(target_arch="x86_64")]
-    pub type addrinfo = {
+    pub struct addrinfo {
         a00: *u8, a01: *u8, a02: *u8, a03: *u8,
-        a04: *u8, a05: *u8
-    };
+        a04: *u8, a05: *u8,
+    }
     #[cfg(target_arch="x86")]
     #[cfg(target_arch="arm")]
-    pub type addrinfo = {
+    pub struct addrinfo {
         a00: *u8, a01: *u8, a02: *u8, a03: *u8,
-        a04: *u8, a05: *u8, a06: *u8, a07: *u8
-    };
+        a04: *u8, a05: *u8, a06: *u8, a07: *u8,
+    }
 }
 #[cfg(target_os="macos")]
 #[cfg(target_os="freebsd")]
 pub mod addrinfo_impl {
-    pub type addrinfo = {
+    pub struct addrinfo {
         a00: *u8, a01: *u8, a02: *u8, a03: *u8,
-        a04: *u8, a05: *u8
-    };
+        a04: *u8, a05: *u8,
+    }
 }
 #[cfg(windows)]
 pub mod addrinfo_impl {
-    pub type addrinfo = {
+    pub struct addrinfo {
         a00: *u8, a01: *u8, a02: *u8, a03: *u8,
-        a04: *u8, a05: *u8
-    };
+        a04: *u8, a05: *u8,
+    }
 }
 
 // unix size: 72
-pub type uv_getaddrinfo_t = {
+pub struct uv_getaddrinfo_t {
     a00: *u8, a01: *u8, a02: *u8, a03: *u8, a04: *u8, a05: *u8,
-    a06: *u8, a07: *u8, a08: *u8
-};
+    a06: *u8, a07: *u8, a08: *u8,
+}
 
 pub mod uv_ll_struct_stubgen {
-    use uv_ll::{uv_async_t, uv_connect_t, uv_getaddrinfo_t, uv_tcp_t};
-    use uv_ll::{uv_timer_t, uv_write_t};
+    use uv_ll::{
+        uv_async_t,
+        uv_connect_t,
+        uv_getaddrinfo_t,
+        uv_handle_fields,
+        uv_tcp_t,
+        uv_timer_t,
+        uv_write_t,
+    };
+
+    #[cfg(target_os = "linux")]
+    #[cfg(target_os = "android")]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "freebsd")]
+    use uv_ll::{
+        uv_async_t_32bit_unix_riders,
+        uv_tcp_t_32bit_unix_riders,
+        uv_timer_t_32bit_unix_riders,
+        uv_write_t_32bit_unix_riders,
+    };
 
     use core::ptr;
 
@@ -343,9 +361,12 @@ pub mod uv_ll_struct_stubgen {
             return gen_stub_arch();
             #[cfg(target_arch="x86_64")]
             pub fn gen_stub_arch() -> uv_tcp_t {
-                return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                                close_cb: ptr::null(),
-                                mut data: ptr::null() },
+                uv_tcp_t {
+                    fields: uv_handle_fields {
+                        loop_handle: ptr::null(), type_: 0u32,
+                        close_cb: ptr::null(),
+                        data: ptr::null(),
+                    },
                     a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                     a03: 0 as *u8,
                     a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@@ -361,17 +382,18 @@ pub mod uv_ll_struct_stubgen {
                     a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8,
                     a27: 0 as *u8,
                     a28: 0 as *u8,
-                    a30: {
-                        a29: 0 as *u8
-                    }
-                };
+                    a30: uv_tcp_t_32bit_unix_riders { a29: 0 as *u8 },
+                }
             }
             #[cfg(target_arch="x86")]
             #[cfg(target_arch="arm")]
             pub fn gen_stub_arch() -> uv_tcp_t {
-                return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                                close_cb: ptr::null(),
-                                mut data: ptr::null() },
+                uv_tcp_t {
+                    fields: uv_handle_fields {
+                        loop_handle: ptr::null(), type_: 0u32,
+                        close_cb: ptr::null(),
+                        data: ptr::null(),
+                    },
                     a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                     a03: 0 as *u8,
                     a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@@ -387,19 +409,22 @@ pub mod uv_ll_struct_stubgen {
                     a24: 0 as *u8, a25: 0 as *u8, a26: 0 as *u8,
                     a27: 0 as *u8,
                     a28: 0 as *u8,
-                    a30: {
+                    a30: uv_tcp_t_32bit_unix_riders {
                         a29: 0 as *u8, a30: 0 as *u8, a31: 0 as *u8,
                         a32: 0 as *u8, a33: 0 as *u8, a34: 0 as *u8,
-                        a35: 0 as *u8, a36: 0 as *u8
-                    }
-                };
+                        a35: 0 as *u8, a36: 0 as *u8,
+                    },
+                }
             }
         }
         #[cfg(windows)]
         pub fn gen_stub_os() -> uv_tcp_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_tcp_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@@ -412,58 +437,62 @@ pub mod uv_ll_struct_stubgen {
                 a19: 0 as *u8,
                 a20: 0 as *u8, a21: 0 as *u8, a22: 0 as *u8,
                 a23: 0 as *u8,
-                a24: 0 as *u8, a25: 0 as *u8
-            };
+                a24: 0 as *u8, a25: 0 as *u8,
+            }
         }
     }
     #[cfg(unix)]
     pub fn gen_stub_uv_connect_t() -> uv_connect_t {
-        return {
+        uv_connect_t {
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
             a03: 0 as *u8,
-            a04: 0 as *u8, a05: 0 as *u8
-        };
+            a04: 0 as *u8, a05: 0 as *u8,
+        }
     }
     #[cfg(windows)]
     pub fn gen_stub_uv_connect_t() -> uv_connect_t {
-        return {
+        uv_connect_t {
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
             a03: 0 as *u8,
             a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
             a07: 0 as *u8,
-            a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8
-        };
+            a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
+        }
     }
     #[cfg(unix)]
     pub fn gen_stub_uv_async_t() -> uv_async_t {
         return gen_stub_arch();
         #[cfg(target_arch = "x86_64")]
         pub fn gen_stub_arch() -> uv_async_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_async_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8,
-                a11: {
-                    a10: 0 as *u8
-                }
-            };
+                a11: uv_async_t_32bit_unix_riders { a10: 0 as *u8 },
+            }
         }
         #[cfg(target_arch = "x86")]
         #[cfg(target_arch="arm")]
         pub fn gen_stub_arch() -> uv_async_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_async_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8,
-                a11: {
+                a11: uv_async_t_32bit_unix_riders {
                     a10: 0 as *u8, a11: 0 as *u8,
                     a12: 0 as *u8, a13: 0 as *u8
                 }
@@ -472,107 +501,133 @@ pub mod uv_ll_struct_stubgen {
     }
     #[cfg(windows)]
     pub fn gen_stub_uv_async_t() -> uv_async_t {
-        return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                        close_cb: ptr::null(),
-                        mut data: ptr::null() },
+        uv_async_t {
+            fields: uv_handle_fields {
+                loop_handle: ptr::null(), type_: 0u32,
+                close_cb: ptr::null(),
+                data: ptr::null(),
+            },
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
             a03: 0 as *u8,
             a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
             a07: 0 as *u8,
             a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
             a11: 0 as *u8,
-            a12: 0 as *u8
-        };
+            a12: 0 as *u8,
+        }
     }
     #[cfg(unix)]
     pub fn gen_stub_uv_timer_t() -> uv_timer_t {
         return gen_stub_arch();
         #[cfg(target_arch = "x86_64")]
         pub fn gen_stub_arch() -> uv_timer_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_timer_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8,
-                a11: {
+                a11: uv_timer_t_32bit_unix_riders {
                     a10: 0 as *u8, a11: 0 as *u8
-                }
-            };
+                },
+            }
         }
         #[cfg(target_arch = "x86")]
         #[cfg(target_arch="arm")]
         pub fn gen_stub_arch() -> uv_timer_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_timer_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8,
-                a11: {
+                a11: uv_timer_t_32bit_unix_riders {
                     a10: 0 as *u8, a11: 0 as *u8,
                     a12: 0 as *u8, a13: 0 as *u8,
                     a14: 0 as *u8, a15: 0 as *u8,
-                    a16: 0 as *u8
-                }
-            };
+                    a16: 0 as *u8,
+                },
+            }
         }
     }
     #[cfg(windows)]
     pub fn gen_stub_uv_timer_t() -> uv_timer_t {
-        return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                        close_cb: ptr::null(),
-                        mut data: ptr::null() },
+        uv_timer_t {
+            fields: uv_handle_fields {
+                loop_handle: ptr::null(), type_: 0u32,
+                close_cb: ptr::null(),
+                data: ptr::null(),
+            },
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
             a03: 0 as *u8,
             a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
             a07: 0 as *u8,
             a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
-            a11: 0 as *u8
-        };
+            a11: 0 as *u8,
+        }
     }
     #[cfg(unix)]
     pub fn gen_stub_uv_write_t() -> uv_write_t {
         return gen_stub_arch();
         #[cfg(target_arch="x86_64")]
         pub fn gen_stub_arch() -> uv_write_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_write_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
                 a11: 0 as *u8,
-                a12: 0 as *u8, a14: { a13: 0 as *u8 }
-            };
+                a12: 0 as *u8,
+                a14: uv_write_t_32bit_unix_riders { a13: 0 as *u8 },
+            }
         }
         #[cfg(target_arch="x86")]
         #[cfg(target_arch="arm")]
         pub fn gen_stub_arch() -> uv_write_t {
-            return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                            close_cb: ptr::null(),
-                            mut data: ptr::null() },
+            uv_write_t {
+                fields: uv_handle_fields {
+                    loop_handle: ptr::null(), type_: 0u32,
+                    close_cb: ptr::null(),
+                    data: ptr::null(),
+                },
                 a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
                 a03: 0 as *u8,
                 a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
                 a07: 0 as *u8,
                 a08: 0 as *u8, a09: 0 as *u8, a10: 0 as *u8,
                 a11: 0 as *u8,
-                a12: 0 as *u8, a14: { a13: 0 as *u8, a14: 0 as *u8 }
+                a12: 0 as *u8,
+                a14: uv_write_t_32bit_unix_riders {
+                    a13: 0 as *u8,
+                    a14: 0 as *u8,
+                }
             };
         }
     }
     #[cfg(windows)]
     pub fn gen_stub_uv_write_t() -> uv_write_t {
-        return { fields: { loop_handle: ptr::null(), type_: 0u32,
-                        close_cb: ptr::null(),
-                        mut data: ptr::null() },
+        uv_write_t {
+            fields: uv_handle_fields {
+                loop_handle: ptr::null(), type_: 0u32,
+                close_cb: ptr::null(),
+                data: ptr::null(),
+            },
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8,
             a03: 0 as *u8,
             a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8,
@@ -583,7 +638,7 @@ pub mod uv_ll_struct_stubgen {
         };
     }
     pub fn gen_stub_uv_getaddrinfo_t() -> uv_getaddrinfo_t {
-        {
+        uv_getaddrinfo_t {
             a00: 0 as *u8, a01: 0 as *u8, a02: 0 as *u8, a03: 0 as *u8,
             a04: 0 as *u8, a05: 0 as *u8, a06: 0 as *u8, a07: 0 as *u8,
             a08: 0 as *u8
@@ -851,7 +906,7 @@ pub unsafe fn async_send(async_handle: *uv_async_t) {
     return rustrt::rust_uv_async_send(async_handle);
 }
 pub unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
-    let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
+    let out_buf = uv_buf_t { base: ptr::null(), len: 0 as libc::size_t };
     let out_buf_ptr = ptr::addr_of(&out_buf);
     log(debug, fmt!("buf_init - input %u len %u out_buf: %u",
                      input as uint,
@@ -1043,13 +1098,13 @@ pub unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
     let err_ptr = ptr::addr_of(&err);
     let err_name = str::raw::from_c_str(err_name(err_ptr));
     let err_msg = str::raw::from_c_str(strerror(err_ptr));
-    { err_name: err_name, err_msg: err_msg }
+    uv_err_data { err_name: err_name, err_msg: err_msg }
 }
 
-pub type uv_err_data = {
+pub struct uv_err_data {
     err_name: ~str,
-    err_msg: ~str
-};
+    err_msg: ~str,
+}
 
 pub unsafe fn is_ipv4_addrinfo(input: *addrinfo) -> bool {
     rustrt::rust_uv_is_ipv4_addrinfo(input)
@@ -1090,11 +1145,11 @@ pub mod test {
         tcp_read_error
     }
 
-    type request_wrapper = {
+    struct request_wrapper {
         write_req: *uv_write_t,
         req_buf: *~[uv_buf_t],
-        read_chan: *oldcomm::Chan<~str>
-    };
+        read_chan: *oldcomm::Chan<~str>,
+    }
 
     extern fn after_close_cb(handle: *libc::c_void) {
         log(debug, fmt!("after uv_close! handle ptr: %?",
@@ -1424,18 +1479,18 @@ pub mod test {
         }
     }
 
-    type tcp_server_data = {
+    struct tcp_server_data {
         client: *uv_tcp_t,
         server: *uv_tcp_t,
         server_kill_msg: ~str,
         server_resp_buf: *~[uv_buf_t],
         server_chan: *oldcomm::Chan<~str>,
-        server_write_req: *uv_write_t
-    };
+        server_write_req: *uv_write_t,
+    }
 
-    type async_handle_data = {
-        continue_chan: *oldcomm::Chan<bool>
-    };
+    struct async_handle_data {
+        continue_chan: *oldcomm::Chan<bool>,
+    }
 
     extern fn async_close_cb(handle: *libc::c_void) {
         log(debug, fmt!("SERVER: closing async cb... h: %?",
@@ -1489,7 +1544,7 @@ pub mod test {
                 { continue_chan: continue_chan };
             let async_data_ptr = ptr::addr_of(&async_data);
 
-            let server_data: tcp_server_data = {
+            let server_data = tcp_server_data {
                 client: tcp_client_ptr,
                 server: tcp_server_ptr,
                 server_kill_msg: kill_server_msg,