From 118158729ec694e6d21d94b5a51a7cbb57d9a37a Mon Sep 17 00:00:00 2001
From: Corey Richardson <corey@octayn.net>
Date: Sat, 3 Aug 2013 22:14:01 -0400
Subject: [PATCH 01/29] Work around #8256, do not fail the task, just return
 None

---
 src/librustc/middle/resolve.rs |  2 +-
 src/libsyntax/codemap.rs       | 15 +++++++++++----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 5a70f251aca46..cb2da855c22b7 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -3097,7 +3097,7 @@ impl Resolver {
         let imports: &mut ~[@ImportDirective] = &mut *module_.imports;
         let import_count = imports.len();
         if index != import_count {
-            let sn = self.session.codemap.span_to_snippet(imports[index].span);
+            let sn = self.session.codemap.span_to_snippet(imports[index].span).unwrap();
             if sn.contains("::") {
                 self.session.span_err(imports[index].span, "unresolved import");
             } else {
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 04b9fdce666e8..203341790ff91 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -369,12 +369,19 @@ impl CodeMap {
         return @FileLines {file: lo.file, lines: lines};
     }
 
-    pub fn span_to_snippet(&self, sp: span) -> ~str {
+    pub fn span_to_snippet(&self, sp: span) -> Option<~str> {
         let begin = self.lookup_byte_offset(sp.lo);
         let end = self.lookup_byte_offset(sp.hi);
-        assert_eq!(begin.fm.start_pos, end.fm.start_pos);
-        return begin.fm.src.slice(
-                          begin.pos.to_uint(), end.pos.to_uint()).to_owned();
+
+        // FIXME #8256: this used to be an assert but whatever precondition
+        // it's testing isn't true for all spans in the AST, so to allow the
+        // caller to not have to fail (and it can't catch it since the CodeMap
+        // isn't sendable), return None
+        if begin.fm.start_pos != end.fm.start_pos {
+            None
+        } else {
+            Some(begin.fm.src.slice( begin.pos.to_uint(), end.pos.to_uint()).to_owned())
+        }
     }
 
     pub fn get_filemap(&self, filename: &str) -> @FileMap {

From c327835a44d8d6b499f760fdd03112457bf23005 Mon Sep 17 00:00:00 2001
From: Daniel Micay <danielmicay@gmail.com>
Date: Sun, 4 Aug 2013 18:21:29 -0400
Subject: [PATCH 02/29] fix warning still mentioning the `again` keyword

---
 src/librustc/middle/check_loop.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs
index fb12f97c50cb0..cbd1d3cd9ad81 100644
--- a/src/librustc/middle/check_loop.rs
+++ b/src/librustc/middle/check_loop.rs
@@ -52,7 +52,7 @@ pub fn check_crate(tcx: ty::ctxt, crate: &Crate) {
               }
               expr_again(_) => {
                 if !cx.in_loop {
-                    tcx.sess.span_err(e.span, "`again` outside of loop");
+                    tcx.sess.span_err(e.span, "`loop` outside of loop");
                 }
               }
               expr_ret(oe) => {

From d49bb43fc130976582f7f7930bafdf8571cf40a8 Mon Sep 17 00:00:00 2001
From: Dmitry Ermolov <epdmitry@yandex.ru>
Date: Mon, 5 Aug 2013 02:26:38 +0400
Subject: [PATCH 03/29] Implemented iterator for TrieMap

Closes #5506.
---
 src/libstd/trie.rs | 96 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 679d36b87f18e..93a11bdea98d5 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -14,6 +14,7 @@ use prelude::*;
 use iterator::{IteratorUtil, FromIterator, Extendable};
 use uint;
 use util::{swap, replace};
+use vec;
 
 // FIXME: #5244: need to manually update the TrieNode constructor
 static SHIFT: uint = 4;
@@ -146,6 +147,15 @@ impl<T> TrieMap<T> {
     pub fn each_value_reverse(&self, f: &fn(&T) -> bool) -> bool {
         self.each_reverse(|_, v| f(v))
     }
+
+    /// Get an iterator over the key-value pairs in the map
+    pub fn iter<'a>(&'a self) -> TrieMapIterator<'a, T> {
+        TrieMapIterator {
+            stack: ~[self.root.children.iter()],
+            remaining_min: self.length,
+            remaining_max: self.length
+        }
+    }
 }
 
 impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T> {
@@ -217,6 +227,12 @@ impl TrieSet {
     pub fn each_reverse(&self, f: &fn(&uint) -> bool) -> bool {
         self.map.each_key_reverse(f)
     }
+
+    /// Get an iterator over the values in the set
+    #[inline]
+    pub fn iter<'a>(&'a self) -> TrieSetIterator<'a> {
+        TrieSetIterator{iter: self.map.iter()}
+    }
 }
 
 impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {
@@ -366,6 +382,61 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
     return ret;
 }
 
+/// Forward iterator over a map
+pub struct TrieMapIterator<'self, T> {
+    priv stack: ~[vec::VecIterator<'self, Child<T>>],
+    priv remaining_min: uint,
+    priv remaining_max: uint
+}
+
+impl<'self, T> Iterator<(uint, &'self T)> for TrieMapIterator<'self, T> {
+    fn next(&mut self) -> Option<(uint, &'self T)> {
+        while !self.stack.is_empty() {
+            match self.stack[self.stack.len() - 1].next() {
+                None => {
+                    self.stack.pop();
+                }
+                Some(ref child) => {
+                    match **child {
+                        Internal(ref node) => {
+                            self.stack.push(node.children.iter());
+                        }
+                        External(key, ref value) => {
+                            self.remaining_max -= 1;
+                            if self.remaining_min > 0 {
+                                self.remaining_min -= 1;
+                            }
+                            return Some((key, value));
+                        }
+                        Nothing => {}
+                    }
+                }
+            }
+        }
+        return None;
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        (self.remaining_min, Some(self.remaining_max))
+    }
+}
+
+/// Forward iterator over a set
+pub struct TrieSetIterator<'self> {
+    priv iter: TrieMapIterator<'self, ()>
+}
+
+impl<'self> Iterator<uint> for TrieSetIterator<'self> {
+    fn next(&mut self) -> Option<uint> {
+        do self.iter.next().map |&(key, _)| { key }
+    }
+
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        self.iter.size_hint()
+    }
+}
+
 #[cfg(test)]
 pub fn check_integrity<T>(trie: &TrieNode<T>) {
     assert!(trie.count != 0);
@@ -553,6 +624,31 @@ mod test_map {
             assert_eq!(map.find(&k), Some(&v));
         }
     }
+
+    #[test]
+    fn test_iteration() {
+        let empty_map : TrieMap<uint> = TrieMap::new();
+        assert_eq!(empty_map.iter().next(), None);
+
+        let first = uint::max_value - 10000;
+        let last = uint::max_value;
+
+        let mut map = TrieMap::new();
+        do uint::range_rev(last, first) |x| {
+            printfln!("%x", x);
+            map.insert(x, x / 2);
+            true
+        };
+
+        let mut i = 0;
+        for (k, &v) in map.iter() {
+            printfln!("%x", k);
+            assert_eq!(k, first + i);
+            assert_eq!(v, k / 2);
+            i += 1;
+        }
+        assert_eq!(i, last - first);
+    }
 }
 
 #[cfg(test)]

From 28165d5ad8f944eb4d3225b113d03fdeefa662a0 Mon Sep 17 00:00:00 2001
From: Dmitry Ermolov <epdmitry@yandex.ru>
Date: Mon, 5 Aug 2013 02:51:43 +0400
Subject: [PATCH 04/29] Remove debug printing.

---
 src/libstd/trie.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 93a11bdea98d5..6f61d29780f04 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -635,14 +635,12 @@ mod test_map {
 
         let mut map = TrieMap::new();
         do uint::range_rev(last, first) |x| {
-            printfln!("%x", x);
             map.insert(x, x / 2);
             true
         };
 
         let mut i = 0;
         for (k, &v) in map.iter() {
-            printfln!("%x", k);
             assert_eq!(k, first + i);
             assert_eq!(v, k / 2);
             i += 1;

From 180d050138bc27958291dda3ea46374e4d115848 Mon Sep 17 00:00:00 2001
From: darkf <lw9k123@gmail.com>
Date: Sun, 4 Aug 2013 21:54:24 -0700
Subject: [PATCH 05/29] Open files in binary mode. Closes #3948

---
 src/libstd/io.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index f750f3f3195e7..55e60f03ea9c6 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -1041,7 +1041,7 @@ pub fn stdin() -> @Reader {
 
 pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
     let f = do path.to_str().as_c_str |pathbuf| {
-        do "r".as_c_str |modebuf| {
+        do "rb".as_c_str |modebuf| {
             unsafe { libc::fopen(pathbuf, modebuf as *libc::c_char) }
         }
     };

From 476dfc24b311a837f931e678c4bdfbb99d29f4e4 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Mon, 5 Aug 2013 17:52:03 +0200
Subject: [PATCH 06/29] std: Use correct lifetime parameter on
 str::raw::slice_bytes

fn slice_bytes is marked unsafe since it allows violating the valid
string encoding property; but the function did also allow extending the
lifetime of the slice by mistake, since it's returning `&str`.

Use the annotation `slice_bytes<'a>(&'a str, ...) -> &'a str` so
that all uses of slice_bytes are region checked correctly.
---
 src/libstd/str.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 5c6895fea43c9..f1a44c4b38639 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -885,7 +885,7 @@ pub mod raw {
     /// If begin is greater than end.
     /// If end is greater than the length of the string.
     #[inline]
-    pub unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> &str {
+    pub unsafe fn slice_bytes<'a>(s: &'a str, begin: uint, end: uint) -> &'a str {
         do s.as_imm_buf |sbuf, n| {
              assert!((begin <= end));
              assert!((end <= n));

From bcf62e790151eda088896cd5aeda4b727ec1572a Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Mon, 29 Jul 2013 13:44:53 -0700
Subject: [PATCH 07/29] Make node_id_to_str print more useful info in some
 cases. Closes #2410.

---
 src/libsyntax/ast_map.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 5cba22a8e2375..6b4da9671a963 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -466,11 +466,11 @@ pub fn node_id_to_str(map: map, id: NodeId, itr: @ident_interner) -> ~str {
       Some(&node_local(ident)) => {
         fmt!("local (id=%?, name=%s)", id, itr.get(ident.name))
       }
-      Some(&node_block(_)) => {
-        fmt!("block")
+      Some(&node_block(ref block)) => {
+        fmt!("block %s (id=%?)", pprust::block_to_str(block, itr), id)
       }
-      Some(&node_struct_ctor(*)) => {
-        fmt!("struct_ctor")
+      Some(&node_struct_ctor(_, _, path)) => {
+        fmt!("struct_ctor %s (id=%?)", path_to_str(*path, itr), id)
       }
     }
 }

From a20081666becc9c48b8818a493349c20c480ef06 Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Mon, 29 Jul 2013 14:19:04 -0700
Subject: [PATCH 08/29] Fix an unused variable warning and clean up some dead
 code/names.

---
 src/librustc/middle/trans/base.rs    | 30 ++++++++++------------------
 src/librustc/middle/trans/foreign.rs |  2 +-
 src/libsyntax/ast_util.rs            |  2 +-
 3 files changed, 13 insertions(+), 21 deletions(-)

diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 0a28da5f88a7c..6b35f4ae9a4ee 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -2218,23 +2218,14 @@ pub fn trans_mod(ccx: @mut CrateContext, m: &ast::_mod) {
 pub fn register_fn(ccx: @mut CrateContext,
                    sp: span,
                    sym: ~str,
-                   node_id: ast::NodeId)
-                -> ValueRef {
-    let t = ty::node_id_to_type(ccx.tcx, node_id);
-    register_fn_full(ccx, sp, sym, node_id, t)
-}
-
-pub fn register_fn_full(ccx: @mut CrateContext,
-                        sp: span,
-                        sym: ~str,
-                        node_id: ast::NodeId,
-                        node_type: ty::t)
-                     -> ValueRef {
+                   node_id: ast::NodeId,
+                   node_type: ty::t)
+                   -> ValueRef {
     let llfty = type_of_fn_from_ty(ccx, node_type);
-    register_fn_fuller(ccx, sp, sym, node_id, lib::llvm::CCallConv, llfty)
+    register_fn_llvmty(ccx, sp, sym, node_id, lib::llvm::CCallConv, llfty)
 }
 
-pub fn register_fn_fuller(ccx: @mut CrateContext,
+pub fn register_fn_llvmty(ccx: @mut CrateContext,
                           sp: span,
                           sym: ~str,
                           node_id: ast::NodeId,
@@ -2449,7 +2440,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
 
                         ast::item_fn(_, purity, _, _, _) => {
                             let llfn = if purity != ast::extern_fn {
-                                register_fn_full(ccx, i.span, sym, i.id, ty)
+                                register_fn(ccx, i.span, sym, i.id, ty)
                             } else {
                                 foreign::register_foreign_fn(ccx, i.span, sym, i.id)
                             };
@@ -2499,7 +2490,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                             let path = vec::append((*pth).clone(), [path_name(ni.ident)]);
                             let sym = exported_name(ccx, path, ty, ni.attrs);
 
-                            register_fn_full(ccx, ni.span, sym, ni.id, ty)
+                            register_fn(ccx, ni.span, sym, ni.id, ty)
                         }
                         ast::foreign_item_static(*) => {
                             let ident = token::ident_to_str(&ni.ident);
@@ -2527,7 +2518,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
 
                             llfn = match enm.node {
                                 ast::item_enum(_, _) => {
-                                    register_fn_full(ccx, (*v).span, sym, id, ty)
+                                    register_fn(ccx, (*v).span, sym, id, ty)
                                 }
                                 _ => fail!("node_variant, shouldn't happen")
                             };
@@ -2551,7 +2542,8 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::NodeId) -> ValueRef {
                             let ty = ty::node_id_to_type(ccx.tcx, ctor_id);
                             let sym = exported_name(ccx, (*struct_path).clone(), ty,
                                                     struct_item.attrs);
-                            let llfn = register_fn_full(ccx, struct_item.span, sym, ctor_id, ty);
+                            let llfn = register_fn(ccx, struct_item.span,
+                                                   sym, ctor_id, ty);
                             set_inline_hint(llfn);
                             llfn
                         }
@@ -2586,7 +2578,7 @@ pub fn register_method(ccx: @mut CrateContext,
 
     let sym = exported_name(ccx, path, mty, m.attrs);
 
-    let llfn = register_fn_full(ccx, m.span, sym, id, mty);
+    let llfn = register_fn(ccx, m.span, sym, id, mty);
     set_inline_hint_if_appr(m.attrs, llfn);
     llfn
 }
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index 20c8e69129d74..ede2292725cc9 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -1157,6 +1157,6 @@ pub fn register_foreign_fn(ccx: @mut CrateContext,
 
     let tys = shim_types(ccx, node_id);
     do tys.fn_ty.decl_fn |fnty| {
-        register_fn_fuller(ccx, sp, sym.take(), node_id, lib::llvm::CCallConv, fnty)
+        register_fn_llvmty(ccx, sp, sym.take(), node_id, lib::llvm::CCallConv, fnty)
     }
 }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 11d3740be3f51..84e6544f78092 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -410,7 +410,7 @@ impl IdVisitor {
 impl Visitor<()> for IdVisitor {
     fn visit_mod(@mut self,
                  module: &_mod,
-                 span: span,
+                 _span: span,
                  node_id: NodeId,
                  env: ()) {
         (self.visit_callback)(node_id);

From fd01031f3a1b26e0ee1f4b46d2e6f8c8f481a38c Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Tue, 30 Jul 2013 15:40:19 -0700
Subject: [PATCH 09/29] Warn when using -o option on libraries. Closes #6554.

---
 mk/target.mk                  |  8 ++++----
 mk/tools.mk                   |  8 ++++----
 src/librustc/driver/driver.rs | 13 ++++++-------
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/mk/target.mk b/mk/target.mk
index b9221a56b9d85..fce6e8a9e2fcc 100644
--- a/mk/target.mk
+++ b/mk/target.mk
@@ -48,7 +48,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2)): \
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(STDLIB_GLOB_$(2)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(STDLIB_GLOB_$(2)),$$(notdir $$@))
 
 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_EXTRALIB_$(2)): \
@@ -58,7 +58,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_EXTRALIB_$(2)): \
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(EXTRALIB_GLOB_$(2)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(EXTRALIB_GLOB_$(2)),$$(notdir $$@))
 
 $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3)): \
@@ -69,7 +69,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3)): \
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
 
 # Only build the compiler for host triples
@@ -90,7 +90,7 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)):		\
 		| $$(TLIB$(1)_T_$(2)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(2)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
 
 $$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X_$(3)):			\
diff --git a/mk/tools.mk b/mk/tools.mk
index 56aad4f10a259..32c034d878cb9 100644
--- a/mk/tools.mk
+++ b/mk/tools.mk
@@ -49,7 +49,7 @@ $$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTPKG_$(4)):		\
 		| $$(TLIB$(1)_T_$(4)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTPKG_GLOB_$(4)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTPKG_GLOB_$(4)),$$(notdir $$@))
 
 $$(TBIN$(1)_T_$(4)_H_$(3))/rustpkg$$(X_$(4)):				\
@@ -67,7 +67,7 @@ $$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTDOC_$(4)):		\
 		| $$(TLIB$(1)_T_$(4)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
 
 $$(TBIN$(1)_T_$(4)_H_$(3))/rustdoc$$(X_$(4)):			\
@@ -85,7 +85,7 @@ $$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUSTI_$(4)):		\
 		| $$(TLIB$(1)_T_$(4)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
 
 $$(TBIN$(1)_T_$(4)_H_$(3))/rusti$$(X_$(4)):			\
@@ -106,7 +106,7 @@ $$(TLIB$(1)_T_$(4)_H_$(3))/$(CFG_LIBRUST_$(4)):		\
 		| $$(TLIB$(1)_T_$(4)_H_$(3))/
 	@$$(call E, compile_and_link: $$@)
 	$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
-	$$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+	$$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
 	$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
 
 $$(TBIN$(1)_T_$(4)_H_$(3))/rust$$(X_$(4)):			\
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index ea679d19f73b8..3daacf38036ae 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -408,11 +408,10 @@ pub fn stop_after_phase_5(sess: Session) -> bool {
 #[fixed_stack_segment]
 pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
                      outdir: &Option<Path>, output: &Option<Path>) {
-    let outputs = build_output_filenames(input, outdir, output, [], sess);
     // We need nested scopes here, because the intermediate results can keep
     // large chunks of memory alive and we want to free them as soon as
     // possible to keep the peak memory usage low
-    let trans = {
+    let (outputs, trans) = {
         let expanded_crate = {
             let crate = phase_1_parse_input(sess, cfg.clone(), input);
             if stop_after_phase_1(sess) { return; }
@@ -420,7 +419,10 @@ pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
         };
         let analysis = phase_3_run_analysis_passes(sess, expanded_crate);
         if stop_after_phase_3(sess) { return; }
-        phase_4_translate_to_llvm(sess, expanded_crate, &analysis, outputs)
+        let outputs = build_output_filenames(input, outdir, output, [], sess);
+        let trans = phase_4_translate_to_llvm(sess, expanded_crate,
+                                              &analysis, outputs);
+        (outputs, trans)
     };
     phase_5_run_llvm_passes(sess, &trans, outputs);
     if stop_after_phase_5(sess) { return; }
@@ -957,10 +959,7 @@ pub fn build_output_filenames(input: &input,
         };
 
         if *sess.building_library {
-            // FIXME (#2401): We might want to warn here; we're actually not
-            // going to respect the user's choice of library name when it
-            // comes time to link, we'll be linking to
-            // lib<basename>-<hash>-<version>.so no matter what.
+            sess.warn("ignoring specified output filename for library.");
         }
 
         if *odir != None {

From 7dbc5ae79fc55bf6d6611da271031eed8acafe4c Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Tue, 30 Jul 2013 16:47:22 -0700
Subject: [PATCH 10/29] Get rid of some NOTEs.

---
 src/compiletest/compiletest.rs       | 1 -
 src/librustc/middle/cfg/construct.rs | 2 +-
 src/libstd/rt/io/flate.rs            | 2 +-
 3 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index b01de242590d0..ce715ac2db5ad 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -11,7 +11,6 @@
 #[crate_type = "bin"];
 
 #[allow(non_camel_case_types)];
-#[allow(unrecognized_lint)]; // NOTE: remove after snapshot
 #[deny(warnings)];
 
 extern mod extra;
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index f34b28e1642fc..767c2b4ee2ed7 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -225,7 +225,7 @@ impl CFGBuilder {
                 // Note that `break` and `loop` statements
                 // may cause additional edges.
 
-                // NOTE: Is the condition considered part of the loop?
+                // Is the condition considered part of the loop?
                 let loopback = self.add_dummy_node([pred]);           // 1
                 let cond_exit = self.expr(cond, loopback);            // 2
                 let expr_exit = self.add_node(expr.id, [cond_exit]);  // 3
diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs
index e57b80658eef2..cbcc441811de6 100644
--- a/src/libstd/rt/io/flate.rs
+++ b/src/libstd/rt/io/flate.rs
@@ -10,7 +10,7 @@
 
 //! Some various other I/O types
 
-// NOTE: These ultimately belong somewhere else
+// FIXME(#3660): should move to libextra
 
 use prelude::*;
 use super::*;

From 53c6de56840b72a75909d5d51babb4511dee5a83 Mon Sep 17 00:00:00 2001
From: Michael Sullivan <sully@msully.net>
Date: Fri, 2 Aug 2013 10:34:33 -0700
Subject: [PATCH 11/29] Improve debug spew in _match.

---
 src/librustc/middle/trans/_match.rs | 81 ++++++++++++++---------------
 src/librustc/util/ppaux.rs          | 10 ++--
 2 files changed, 47 insertions(+), 44 deletions(-)

diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 725beee6604e7..0a008b2215ae5 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -171,6 +171,7 @@ use middle::trans::tvec;
 use middle::trans::type_of;
 use middle::ty;
 use util::common::indenter;
+use util::ppaux::{Repr, vec_map_to_str};
 
 use std::hashmap::HashMap;
 use std::vec;
@@ -179,7 +180,6 @@ use syntax::ast::ident;
 use syntax::ast_util::path_to_ident;
 use syntax::ast_util;
 use syntax::codemap::{span, dummy_sp};
-use syntax::print::pprust::pat_to_str;
 
 // An option identifying a literal: either a unit-like struct or an
 // expression.
@@ -353,19 +353,17 @@ pub struct Match<'self> {
     data: ArmData<'self>
 }
 
-pub fn match_to_str(bcx: @mut Block, m: &Match) -> ~str {
-    if bcx.sess().verbose() {
-        // for many programs, this just take too long to serialize
-        fmt!("%?", m.pats.map(|p| pat_to_str(*p, bcx.sess().intr())))
-    } else {
-        fmt!("%u pats", m.pats.len())
+impl<'self> Repr for Match<'self> {
+    fn repr(&self, tcx: ty::ctxt) -> ~str {
+        if tcx.sess.verbose() {
+            // for many programs, this just take too long to serialize
+            self.pats.repr(tcx)
+        } else {
+            fmt!("%u pats", self.pats.len())
+        }
     }
 }
 
-pub fn matches_to_str(bcx: @mut Block, m: &[Match]) -> ~str {
-    fmt!("%?", m.map(|n| match_to_str(bcx, n)))
-}
-
 pub fn has_nested_bindings(m: &[Match], col: uint) -> bool {
     for br in m.iter() {
         match br.pats[col].node {
@@ -381,9 +379,9 @@ pub fn expand_nested_bindings<'r>(bcx: @mut Block,
                                   col: uint,
                                   val: ValueRef)
                               -> ~[Match<'r>] {
-    debug!("expand_nested_bindings(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("expand_nested_bindings(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -416,7 +414,7 @@ pub fn assert_is_binding_or_wild(bcx: @mut Block, p: @ast::pat) {
         bcx.sess().span_bug(
             p.span,
             fmt!("Expected an identifier pattern but found p: %s",
-                 pat_to_str(p, bcx.sess().intr())));
+                 p.repr(bcx.tcx())));
     }
 }
 
@@ -429,9 +427,9 @@ pub fn enter_match<'r>(bcx: @mut Block,
                        val: ValueRef,
                        e: enter_pat)
                     -> ~[Match<'r>] {
-    debug!("enter_match(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_match(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -467,7 +465,7 @@ pub fn enter_match<'r>(bcx: @mut Block,
         }
     }
 
-    debug!("result=%s", matches_to_str(bcx, result));
+    debug!("result=%s", result.repr(bcx.tcx()));
 
     return result;
 }
@@ -478,9 +476,9 @@ pub fn enter_default<'r>(bcx: @mut Block,
                          col: uint,
                          val: ValueRef)
                       -> ~[Match<'r>] {
-    debug!("enter_default(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_default(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -525,9 +523,9 @@ pub fn enter_opt<'r>(bcx: @mut Block,
                      variant_size: uint,
                      val: ValueRef)
                   -> ~[Match<'r>] {
-    debug!("enter_opt(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_opt(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -637,9 +635,9 @@ pub fn enter_rec_or_struct<'r>(bcx: @mut Block,
                                fields: &[ast::ident],
                                val: ValueRef)
                             -> ~[Match<'r>] {
-    debug!("enter_rec_or_struct(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_rec_or_struct(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -672,9 +670,9 @@ pub fn enter_tup<'r>(bcx: @mut Block,
                      val: ValueRef,
                      n_elts: uint)
                   -> ~[Match<'r>] {
-    debug!("enter_tup(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_tup(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -698,9 +696,9 @@ pub fn enter_tuple_struct<'r>(bcx: @mut Block,
                               val: ValueRef,
                               n_elts: uint)
                           -> ~[Match<'r>] {
-    debug!("enter_tuple_struct(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_tuple_struct(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -723,9 +721,9 @@ pub fn enter_box<'r>(bcx: @mut Block,
                      col: uint,
                      val: ValueRef)
                  -> ~[Match<'r>] {
-    debug!("enter_box(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_box(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -750,9 +748,9 @@ pub fn enter_uniq<'r>(bcx: @mut Block,
                       col: uint,
                       val: ValueRef)
                   -> ~[Match<'r>] {
-    debug!("enter_uniq(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_uniq(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -777,9 +775,9 @@ pub fn enter_region<'r>(bcx: @mut Block,
                         col: uint,
                         val: ValueRef)
                     -> ~[Match<'r>] {
-    debug!("enter_region(bcx=%s, m=%s, col=%u, val=%?)",
+    debug!("enter_region(bcx=%s, m=%s, col=%u, val=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
+           m.repr(bcx.tcx()),
            col,
            bcx.val_to_str(val));
     let _indenter = indenter();
@@ -1213,11 +1211,11 @@ pub fn compile_guard(bcx: @mut Block,
                      vals: &[ValueRef],
                      chk: Option<mk_fail>)
                   -> @mut Block {
-    debug!("compile_guard(bcx=%s, guard_expr=%s, m=%s, vals=%?)",
+    debug!("compile_guard(bcx=%s, guard_expr=%s, m=%s, vals=%s)",
            bcx.to_str(),
            bcx.expr_to_str(guard_expr),
-           matches_to_str(bcx, m),
-           vals.map(|v| bcx.val_to_str(*v)));
+           m.repr(bcx.tcx()),
+           vec_map_to_str(vals, |v| bcx.val_to_str(*v)));
     let _indenter = indenter();
 
     let mut bcx = bcx;
@@ -1267,10 +1265,10 @@ pub fn compile_submatch(bcx: @mut Block,
                         m: &[Match],
                         vals: &[ValueRef],
                         chk: Option<mk_fail>) {
-    debug!("compile_submatch(bcx=%s, m=%s, vals=%?)",
+    debug!("compile_submatch(bcx=%s, m=%s, vals=%s)",
            bcx.to_str(),
-           matches_to_str(bcx, m),
-           vals.map(|v| bcx.val_to_str(*v)));
+           m.repr(bcx.tcx()),
+           vec_map_to_str(vals, |v| bcx.val_to_str(*v)));
     let _indenter = indenter();
 
     /*
@@ -1427,6 +1425,7 @@ fn compile_submatch_continue(mut bcx: @mut Block,
 
     // Decide what kind of branch we need
     let opts = get_options(bcx, m, col);
+    debug!("options=%?", opts);
     let mut kind = no_branch;
     let mut test_val = val;
     if opts.len() > 0u {
@@ -1914,12 +1913,12 @@ fn bind_irrefutable_pat(bcx: @mut Block,
 
     debug!("bind_irrefutable_pat(bcx=%s, pat=%s, binding_mode=%?)",
            bcx.to_str(),
-           pat_to_str(pat, bcx.sess().intr()),
+           pat.repr(bcx.tcx()),
            binding_mode);
 
     if bcx.sess().asm_comments() {
         add_comment(bcx, fmt!("bind_irrefutable_pat(pat=%s)",
-                              pat_to_str(pat, bcx.sess().intr())));
+                              pat.repr(bcx.tcx())));
     }
 
     let _indenter = indenter();
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 8f0dd51457074..f396ed7f510a6 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -280,9 +280,13 @@ pub fn vstore_ty_to_str(cx: ctxt, mt: &mt, vs: ty::vstore) -> ~str {
     }
 }
 
+pub fn vec_map_to_str<T>(ts: &[T], f: &fn(t: &T) -> ~str) -> ~str {
+    let tstrs = ts.map(f);
+    fmt!("[%s]", tstrs.connect(", "))
+}
+
 pub fn tys_to_str(cx: ctxt, ts: &[t]) -> ~str {
-    let tstrs = ts.map(|t| ty_to_str(cx, *t));
-    fmt!("(%s)", tstrs.connect(", "))
+    vec_map_to_str(ts, |t| ty_to_str(cx, *t))
 }
 
 pub fn fn_sig_to_str(cx: ctxt, typ: &ty::FnSig) -> ~str {
@@ -529,7 +533,7 @@ impl<T:Repr> Repr for ~T {
 }
 
 fn repr_vec<T:Repr>(tcx: ctxt, v: &[T]) -> ~str {
-    fmt!("[%s]", v.map(|t| t.repr(tcx)).connect(","))
+    vec_map_to_str(v, |t| t.repr(tcx))
 }
 
 impl<'self, T:Repr> Repr for &'self [T] {

From 991648d099be6f004668280873f9a2c85a949eaf Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 5 Aug 2013 10:37:53 -0700
Subject: [PATCH 12/29] Use TreeMap's ord implementation for Json

Closes #4430
---
 src/libextra/json.rs | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/src/libextra/json.rs b/src/libextra/json.rs
index cd35cbdf30980..ec9cb902d3d29 100644
--- a/src/libextra/json.rs
+++ b/src/libextra/json.rs
@@ -26,7 +26,6 @@ use std::to_str;
 
 use serialize::Encodable;
 use serialize;
-use sort::Sort;
 use treemap::TreeMap;
 
 /// Represents a json value
@@ -1152,23 +1151,7 @@ impl Ord for Json {
             Object(ref d0) => {
                 match *other {
                     Number(_) | String(_) | Boolean(_) | List(_) => false,
-                    Object(ref d1) => {
-                        let mut d0_flat = ~[];
-                        let mut d1_flat = ~[];
-
-                        // FIXME #4430: this is horribly inefficient...
-                        for (k, v) in d0.iter() {
-                             d0_flat.push((@(*k).clone(), @(*v).clone()));
-                        }
-                        d0_flat.qsort();
-
-                        for (k, v) in d1.iter() {
-                            d1_flat.push((@(*k).clone(), @(*v).clone()));
-                        }
-                        d1_flat.qsort();
-
-                        d0_flat < d1_flat
-                    }
+                    Object(ref d1) => d0 < d1,
                     Null => true
                 }
             }

From 0ac7a219f043d3b1c8c239089d9dd6e6c9fa830b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marvin=20L=C3=B6bel?= <loebel.marvin@gmail.com>
Date: Sun, 4 Aug 2013 01:59:24 +0200
Subject: [PATCH 13/29] Updated std::Option, std::Either and std::Result

- Made naming schemes consistent between Option, Result and Either
- Changed Options Add implementation to work like the maybe monad (return None if any of the inputs is None)
- Removed duplicate Option::get and renamed all related functions to use the term `unwrap` instead
---
 src/compiletest/compiletest.rs                |   6 +-
 src/compiletest/runtest.rs                    |  12 +-
 src/libextra/base64.rs                        |  20 +-
 src/libextra/fileinput.rs                     |   4 +-
 src/libextra/getopts.rs                       |   8 +-
 src/libextra/num/bigint.rs                    |  12 +-
 src/libextra/ringbuf.rs                       |  12 +-
 src/libextra/semver.rs                        |   4 +-
 src/libextra/smallintmap.rs                   |   6 +-
 src/libextra/test.rs                          |  57 ++-
 src/libextra/url.rs                           |   4 +-
 src/librustc/back/link.rs                     |   4 +-
 src/librustc/back/passes.rs                   |   6 +-
 src/librustc/driver/driver.rs                 |   2 +-
 src/librustc/front/test.rs                    |   4 +-
 src/librustc/middle/astencode.rs              |  10 +-
 src/librustc/middle/borrowck/check_loans.rs   |   2 +-
 src/librustc/middle/check_match.rs            |  12 +-
 src/librustc/middle/const_eval.rs             |   4 +-
 src/librustc/middle/privacy.rs                |   2 +-
 src/librustc/middle/resolve.rs                |   4 +-
 src/librustc/middle/trans/_match.rs           |   8 +-
 src/librustc/middle/trans/adt.rs              |   2 +-
 src/librustc/middle/trans/base.rs             |  22 +-
 src/librustc/middle/trans/build.rs            |   4 +-
 src/librustc/middle/trans/cabi.rs             |   2 +-
 src/librustc/middle/trans/closure.rs          |   4 +-
 src/librustc/middle/trans/common.rs           |   4 +-
 src/librustc/middle/trans/controlflow.rs      |   4 +-
 src/librustc/middle/trans/debuginfo.rs        |   4 +-
 src/librustc/middle/trans/foreign.rs          |  20 +-
 src/librustc/middle/trans/glue.rs             |   4 +-
 src/librustc/middle/trans/monomorphize.rs     |   4 +-
 src/librustc/middle/trans/reflect.rs          |   4 +-
 src/librustc/middle/trans/type_of.rs          |   2 +-
 src/librustc/middle/ty.rs                     |  32 +-
 src/librustc/middle/typeck/astconv.rs         |   6 +-
 src/librustc/middle/typeck/check/_match.rs    |   4 +-
 src/librustc/middle/typeck/check/method.rs    |   6 +-
 src/librustc/middle/typeck/check/mod.rs       |   4 +-
 src/librustc/middle/typeck/infer/glb.rs       |   2 +-
 src/librustc/middle/typeck/mod.rs             |   2 +-
 src/librustc/middle/typeck/rscope.rs          |   1 +
 src/librustc/util/enum_set.rs                 |   2 +-
 src/librustdoc/attr_pass.rs                   |   4 +-
 src/librustdoc/config.rs                      |  30 +-
 src/librustdoc/desc_to_brief_pass.rs          |   2 +-
 src/librustdoc/doc.rs                         |   2 +-
 src/librustdoc/markdown_index_pass.rs         |  12 +-
 src/librustdoc/markdown_pass.rs               |   8 +-
 src/librustdoc/sectionalize_pass.rs           |   4 +-
 src/librustdoc/tystr_pass.rs                  |   6 +-
 src/librusti/rusti.rs                         |  10 +-
 src/librustpkg/rustpkg.rs                     |   4 +-
 src/librustpkg/util.rs                        |   2 +-
 src/libstd/at_vec.rs                          |   6 +-
 src/libstd/either.rs                          | 366 +++++++++---------
 src/libstd/local_data.rs                      |  14 +-
 src/libstd/num/strconv.rs                     |   2 +-
 src/libstd/option.rs                          | 212 +++++-----
 src/libstd/os.rs                              |   6 +-
 src/libstd/rand.rs                            |   4 +-
 src/libstd/result.rs                          | 327 +++++++---------
 src/libstd/rt/io/flate.rs                     |   2 +-
 src/libstd/rt/io/mod.rs                       |  36 +-
 src/libstd/rt/mod.rs                          |   2 +-
 src/libstd/rt/task.rs                         |   4 +-
 src/libstd/rt/test.rs                         |   4 +-
 src/libstd/rt/util.rs                         |   4 +-
 src/libstd/rt/uv/net.rs                       |   6 +-
 src/libstd/rt/uv/uvio.rs                      |   2 +-
 src/libstd/str.rs                             |   4 +-
 src/libstd/task/mod.rs                        |   2 +-
 src/libstd/vec.rs                             |   6 +-
 src/libsyntax/abi.rs                          |   4 +-
 src/libsyntax/ast.rs                          |   4 +-
 src/libsyntax/attr.rs                         |   2 +-
 src/libsyntax/ext/base.rs                     |  16 +-
 src/libsyntax/ext/deriving/generic.rs         |   2 +-
 src/libsyntax/ext/expand.rs                   |   4 +-
 src/libsyntax/ext/source_util.rs              |   6 +-
 src/libsyntax/parse/parser.rs                 |   8 +-
 src/libsyntax/print/pprust.rs                 |  10 +-
 src/test/bench/core-map.rs                    |   2 +-
 src/test/bench/core-set.rs                    |   2 +-
 src/test/bench/core-uint-to-str.rs            |   2 +-
 src/test/bench/graph500-bfs.rs                |   4 +-
 src/test/bench/msgsend-pipes-shared.rs        |   4 +-
 src/test/bench/msgsend-pipes.rs               |   4 +-
 src/test/bench/msgsend-ring-mutex-arcs.rs     |   4 +-
 src/test/bench/msgsend-ring-rw-arcs.rs        |   4 +-
 src/test/bench/shootout-ackermann.rs          |   2 +-
 src/test/bench/shootout-binarytrees.rs        |   2 +-
 src/test/bench/shootout-chameneos-redux.rs    |   2 +-
 src/test/bench/shootout-fannkuch-redux.rs     |   2 +-
 src/test/bench/shootout-fasta-redux.rs        |   2 +-
 src/test/bench/shootout-fasta.rs              |   2 +-
 src/test/bench/shootout-fibo.rs               |   2 +-
 src/test/bench/shootout-mandelbrot.rs         |   2 +-
 src/test/bench/shootout-nbody.rs              |   2 +-
 src/test/bench/shootout-pfib.rs               |   2 +-
 src/test/bench/shootout-spectralnorm.rs       |   2 +-
 src/test/bench/shootout-threadring.rs         |   4 +-
 src/test/bench/std-smallintmap.rs             |   4 +-
 src/test/bench/sudoku.rs                      |   6 +-
 .../bench/task-perf-jargon-metal-smoke.rs     |   2 +-
 src/test/bench/task-perf-linked-failure.rs    |   2 +-
 src/test/bench/task-perf-spawnalot.rs         |   2 +-
 .../arc-rw-read-mode-shouldnt-escape.rs       |   2 +-
 .../arc-rw-write-mode-shouldnt-escape.rs      |   2 +-
 src/test/run-fail/result-get-fail.rs          |   4 +-
 .../run-pass/borrowck-wg-borrow-mut-to-imm.rs |   2 +-
 .../run-pass/borrowed-ptr-pattern-option.rs   |   2 +-
 src/test/run-pass/option_addition.rs          |  32 +-
 src/test/run-pass/region-dependent-addr-of.rs |   6 +-
 115 files changed, 792 insertions(+), 817 deletions(-)

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index b01de242590d0..094d176980b81 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -131,7 +131,7 @@ pub fn parse_config(args: ~[~str]) -> config {
         ratchet_noise_percent:
             getopts::opt_maybe_str(matches,
                                    "ratchet-noise-percent").map(|s|
-                                                                f64::from_str(*s).get()),
+                                                                f64::from_str(*s).unwrap()),
         runtool: getopts::opt_maybe_str(matches, "runtool"),
         rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
         jit: getopts::opt_present(matches, "jit"),
@@ -267,7 +267,7 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
           _ => ~[~".rc", ~".rs"]
         };
     let invalid_prefixes = ~[~".", ~"#", ~"~"];
-    let name = testfile.filename().get();
+    let name = testfile.filename().unwrap();
 
     let mut valid = false;
 
@@ -300,7 +300,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
     fn shorten(path: &Path) -> ~str {
         let filename = path.filename();
         let dir = path.pop().filename();
-        fmt!("%s/%s", dir.get_or_default(~""), filename.get_or_default(~""))
+        fmt!("%s/%s", dir.unwrap_or_default(~""), filename.unwrap_or_default(~""))
     }
 
     test::DynTestName(fmt!("[%s] %s",
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index 74b4a1de5e0d1..5c1cc78d678f3 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -145,7 +145,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
     let rounds =
         match props.pp_exact { Some(_) => 1, None => 2 };
 
-    let mut srcs = ~[io::read_whole_file_str(testfile).get()];
+    let mut srcs = ~[io::read_whole_file_str(testfile).unwrap()];
 
     let mut round = 0;
     while round < rounds {
@@ -166,7 +166,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
         match props.pp_exact {
           Some(ref file) => {
             let filepath = testfile.dir_path().push_rel(file);
-            io::read_whole_file_str(&filepath).get()
+            io::read_whole_file_str(&filepath).unwrap()
           }
           None => { srcs[srcs.len() - 2u].clone() }
         };
@@ -448,7 +448,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if opt.is_none() {
         return false;
     }
-    *idx = opt.get();
+    *idx = opt.unwrap();
     return true;
 }
 
@@ -709,7 +709,7 @@ fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
 }
 
 fn output_testname(testfile: &Path) -> Path {
-    Path(testfile.filestem().get())
+    Path(testfile.filestem().unwrap())
 }
 
 fn output_base_name(config: &config, testfile: &Path) -> Path {
@@ -878,7 +878,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
     if suffix.len() == 0 {
         (*p).clone()
     } else {
-        let stem = p.filestem().get();
+        let stem = p.filestem().unwrap();
         p.with_filestem(stem + "-" + suffix)
     }
 }
@@ -938,7 +938,7 @@ fn disassemble_extract(config: &config, _props: &TestProps,
 
 
 fn count_extracted_lines(p: &Path) -> uint {
-    let x = io::read_whole_file_str(&p.with_filetype("ll")).get();
+    let x = io::read_whole_file_str(&p.with_filetype("ll")).unwrap();
     x.line_iter().len_()
 }
 
diff --git a/src/libextra/base64.rs b/src/libextra/base64.rs
index f2cbcf86935e7..550b891a4db16 100644
--- a/src/libextra/base64.rs
+++ b/src/libextra/base64.rs
@@ -322,24 +322,24 @@ mod test {
 
     #[test]
     fn test_from_base64_basic() {
-        assert_eq!("".from_base64().get(), "".as_bytes().to_owned());
-        assert_eq!("Zg==".from_base64().get(), "f".as_bytes().to_owned());
-        assert_eq!("Zm8=".from_base64().get(), "fo".as_bytes().to_owned());
-        assert_eq!("Zm9v".from_base64().get(), "foo".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==".from_base64().get(), "foob".as_bytes().to_owned());
-        assert_eq!("Zm9vYmE=".from_base64().get(), "fooba".as_bytes().to_owned());
-        assert_eq!("Zm9vYmFy".from_base64().get(), "foobar".as_bytes().to_owned());
+        assert_eq!("".from_base64().unwrap(), "".as_bytes().to_owned());
+        assert_eq!("Zg==".from_base64().unwrap(), "f".as_bytes().to_owned());
+        assert_eq!("Zm8=".from_base64().unwrap(), "fo".as_bytes().to_owned());
+        assert_eq!("Zm9v".from_base64().unwrap(), "foo".as_bytes().to_owned());
+        assert_eq!("Zm9vYg==".from_base64().unwrap(), "foob".as_bytes().to_owned());
+        assert_eq!("Zm9vYmE=".from_base64().unwrap(), "fooba".as_bytes().to_owned());
+        assert_eq!("Zm9vYmFy".from_base64().unwrap(), "foobar".as_bytes().to_owned());
     }
 
     #[test]
     fn test_from_base64_newlines() {
-        assert_eq!("Zm9v\r\nYmFy".from_base64().get(),
+        assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
                    "foobar".as_bytes().to_owned());
     }
 
     #[test]
     fn test_from_base64_urlsafe() {
-        assert_eq!("-_8".from_base64().get(), "+/8=".from_base64().get());
+        assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap());
     }
 
     #[test]
@@ -364,7 +364,7 @@ mod test {
                     push(random());
                 }
             };
-            assert_eq!(v.to_base64(STANDARD).from_base64().get(), v);
+            assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
         }
     }
 
diff --git a/src/libextra/fileinput.rs b/src/libextra/fileinput.rs
index a161989c37516..7a36b25eac57a 100644
--- a/src/libextra/fileinput.rs
+++ b/src/libextra/fileinput.rs
@@ -526,8 +526,8 @@ mod test {
 
         do input_vec_state(filenames) |line, state| {
             let nums: ~[&str] = line.split_iter(' ').collect();
-            let file_num = uint::from_str(nums[0]).get();
-            let line_num = uint::from_str(nums[1]).get();
+            let file_num = uint::from_str(nums[0]).unwrap();
+            let line_num = uint::from_str(nums[1]).unwrap();
             assert_eq!(line_num, state.line_num_file);
             assert_eq!(file_num * 3 + line_num, state.line_num);
             true
diff --git a/src/libextra/getopts.rs b/src/libextra/getopts.rs
index b9ee38317f321..15aac8ef47c9e 100644
--- a/src/libextra/getopts.rs
+++ b/src/libextra/getopts.rs
@@ -196,7 +196,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> {
  * The type returned when the command line does not conform to the
  * expected format. Pass this value to <fail_str> to get an error message.
  */
-#[deriving(Clone, Eq)]
+#[deriving(Clone, Eq, ToStr)]
 pub enum Fail_ {
     ArgumentMissing(~str),
     UnrecognizedOption(~str),
@@ -288,7 +288,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                       None => {
                         let arg_follows =
                             last_valid_opt_id.is_some() &&
-                            match opts[last_valid_opt_id.get()]
+                            match opts[last_valid_opt_id.unwrap()]
                               .hasarg {
 
                               Yes | Maybe => true,
@@ -322,7 +322,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                   }
                   Maybe => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val((i_arg.clone()).get()));
+                        vals[optid].push(Val((i_arg.clone()).unwrap()));
                     } else if name_pos < names.len() ||
                                   i + 1 == l || is_arg(args[i + 1]) {
                         vals[optid].push(Given);
@@ -330,7 +330,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                   }
                   Yes => {
                     if !i_arg.is_none() {
-                        vals[optid].push(Val(i_arg.clone().get()));
+                        vals[optid].push(Val(i_arg.clone().unwrap()));
                     } else if i + 1 == l {
                         return Err(ArgumentMissing(name_str(nm)));
                     } else { i += 1; vals[optid].push(Val(args[i].clone())); }
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index ab843fe65464b..bced00902c95f 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -1510,11 +1510,11 @@ mod biguint_tests {
 
     #[test]
     fn test_is_even() {
-        assert!(FromStr::from_str::<BigUint>("1").get().is_odd());
-        assert!(FromStr::from_str::<BigUint>("2").get().is_even());
-        assert!(FromStr::from_str::<BigUint>("1000").get().is_even());
-        assert!(FromStr::from_str::<BigUint>("1000000000000000000000").get().is_even());
-        assert!(FromStr::from_str::<BigUint>("1000000000000000000001").get().is_odd());
+        assert!(FromStr::from_str::<BigUint>("1").unwrap().is_odd());
+        assert!(FromStr::from_str::<BigUint>("2").unwrap().is_even());
+        assert!(FromStr::from_str::<BigUint>("1000").unwrap().is_even());
+        assert!(FromStr::from_str::<BigUint>("1000000000000000000000").unwrap().is_even());
+        assert!(FromStr::from_str::<BigUint>("1000000000000000000001").unwrap().is_odd());
         assert!((BigUint::from_uint(1) << 64).is_even());
         assert!(((BigUint::from_uint(1) << 64) + BigUint::from_uint(1)).is_odd());
     }
@@ -1595,7 +1595,7 @@ mod biguint_tests {
             let &(ref n, ref rs) = num_pair;
             for str_pair in rs.iter() {
                 let &(ref radix, ref str) = str_pair;
-                assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).get());
+                assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).unwrap());
             }
         }
 
diff --git a/src/libextra/ringbuf.rs b/src/libextra/ringbuf.rs
index 89d23191a7634..9833bd5d1cbf2 100644
--- a/src/libextra/ringbuf.rs
+++ b/src/libextra/ringbuf.rs
@@ -437,12 +437,12 @@ mod tests {
         assert_eq!(deq.len(), 3);
         deq.push_back(d.clone());
         assert_eq!(deq.len(), 4);
-        assert_eq!((*deq.front().get()).clone(), b.clone());
-        assert_eq!((*deq.back().get()).clone(), d.clone());
-        assert_eq!(deq.pop_front().get(), b.clone());
-        assert_eq!(deq.pop_back().get(), d.clone());
-        assert_eq!(deq.pop_back().get(), c.clone());
-        assert_eq!(deq.pop_back().get(), a.clone());
+        assert_eq!((*deq.front().unwrap()).clone(), b.clone());
+        assert_eq!((*deq.back().unwrap()).clone(), d.clone());
+        assert_eq!(deq.pop_front().unwrap(), b.clone());
+        assert_eq!(deq.pop_back().unwrap(), d.clone());
+        assert_eq!(deq.pop_back().unwrap(), c.clone());
+        assert_eq!(deq.pop_back().unwrap(), a.clone());
         assert_eq!(deq.len(), 0);
         deq.push_back(c.clone());
         assert_eq!(deq.len(), 1);
diff --git a/src/libextra/semver.rs b/src/libextra/semver.rs
index 8c298a7373d96..b0f89e219d8d8 100644
--- a/src/libextra/semver.rs
+++ b/src/libextra/semver.rs
@@ -386,8 +386,8 @@ fn test_spec_order() {
               "1.0.0"];
     let mut i = 1;
     while i < vs.len() {
-        let a = parse(vs[i-1]).get();
-        let b = parse(vs[i]).get();
+        let a = parse(vs[i-1]).unwrap();
+        let b = parse(vs[i]).unwrap();
         assert!(a < b);
         i += 1;
     }
diff --git a/src/libextra/smallintmap.rs b/src/libextra/smallintmap.rs
index 52e6c1fcc1c90..3f62317eb8908 100644
--- a/src/libextra/smallintmap.rs
+++ b/src/libextra/smallintmap.rs
@@ -366,9 +366,9 @@ mod test_map {
         map.update_with_key(3, 2, addMoreToCount);
 
         // check the total counts
-        assert_eq!(map.find(&3).get(), &10);
-        assert_eq!(map.find(&5).get(), &3);
-        assert_eq!(map.find(&9).get(), &1);
+        assert_eq!(map.find(&3).unwrap(), &10);
+        assert_eq!(map.find(&5).unwrap(), &3);
+        assert_eq!(map.find(&9).unwrap(), &1);
 
         // sadly, no sevens were counted
         assert!(map.find(&7).is_none());
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 02481693eb971..e87be14622674 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -247,9 +247,8 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
     let ratchet_metrics = getopts::opt_maybe_str(&matches, "ratchet-metrics");
     let ratchet_metrics = ratchet_metrics.map(|s| Path(*s));
 
-    let ratchet_noise_percent =
-        getopts::opt_maybe_str(&matches, "ratchet-noise-percent");
-    let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).get());
+    let ratchet_noise_percent = getopts::opt_maybe_str(&matches, "ratchet-noise-percent");
+    let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).unwrap());
 
     let save_metrics = getopts::opt_maybe_str(&matches, "save-metrics");
     let save_metrics = save_metrics.map(|s| Path(*s));
@@ -631,8 +630,8 @@ fn should_sort_failures_before_printing_them() {
         st.write_failures();
     };
 
-    let apos = s.find_str("a").get();
-    let bpos = s.find_str("b").get();
+    let apos = s.find_str("a").unwrap();
+    let bpos = s.find_str("b").unwrap();
     assert!(apos < bpos);
 }
 
@@ -868,7 +867,7 @@ impl MetricMap {
     pub fn load(p: &Path) -> MetricMap {
         assert!(os::path_exists(p));
         let f = io::file_reader(p).unwrap();
-        let mut decoder = json::Decoder(json::from_reader(f).get());
+        let mut decoder = json::Decoder(json::from_reader(f).unwrap());
         MetricMap(Decodable::decode(&mut decoder))
     }
 
@@ -1207,7 +1206,7 @@ mod tests {
           either::Left(o) => o,
           _ => fail!("Malformed arg in first_free_arg_should_be_a_filter")
         };
-        assert!("filter" == opts.filter.clone().get());
+        assert!("filter" == opts.filter.clone().unwrap());
     }
 
     #[test]
@@ -1346,28 +1345,28 @@ mod tests {
 
         let diff1 = m2.compare_to_old(&m1, None);
 
-        assert_eq!(*(diff1.find(&~"in-both-noise").get()), LikelyNoise);
-        assert_eq!(*(diff1.find(&~"in-first-noise").get()), MetricRemoved);
-        assert_eq!(*(diff1.find(&~"in-second-noise").get()), MetricAdded);
-        assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").get()),
+        assert_eq!(*(diff1.find(&~"in-both-noise").unwrap()), LikelyNoise);
+        assert_eq!(*(diff1.find(&~"in-first-noise").unwrap()), MetricRemoved);
+        assert_eq!(*(diff1.find(&~"in-second-noise").unwrap()), MetricAdded);
+        assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").unwrap()),
                    Regression(100.0));
-        assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").get()),
+        assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").unwrap()),
                    Improvement(50.0));
-        assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").get()),
+        assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").unwrap()),
                    Regression(50.0));
-        assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").get()),
+        assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").unwrap()),
                    Improvement(100.0));
         assert_eq!(diff1.len(), 7);
 
         let diff2 = m2.compare_to_old(&m1, Some(200.0));
 
-        assert_eq!(*(diff2.find(&~"in-both-noise").get()), LikelyNoise);
-        assert_eq!(*(diff2.find(&~"in-first-noise").get()), MetricRemoved);
-        assert_eq!(*(diff2.find(&~"in-second-noise").get()), MetricAdded);
-        assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").get()), LikelyNoise);
-        assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").get()), LikelyNoise);
-        assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").get()), LikelyNoise);
-        assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").get()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"in-both-noise").unwrap()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"in-first-noise").unwrap()), MetricRemoved);
+        assert_eq!(*(diff2.find(&~"in-second-noise").unwrap()), MetricAdded);
+        assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").unwrap()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").unwrap()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").unwrap()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").unwrap()), LikelyNoise);
         assert_eq!(diff2.len(), 7);
     }
 
@@ -1391,28 +1390,28 @@ mod tests {
         let (diff1, ok1) = m2.ratchet(&pth, None);
         assert_eq!(ok1, false);
         assert_eq!(diff1.len(), 2);
-        assert_eq!(*(diff1.find(&~"runtime").get()), Regression(10.0));
-        assert_eq!(*(diff1.find(&~"throughput").get()), LikelyNoise);
+        assert_eq!(*(diff1.find(&~"runtime").unwrap()), Regression(10.0));
+        assert_eq!(*(diff1.find(&~"throughput").unwrap()), LikelyNoise);
 
         // Check that it was not rewritten.
         let m3 = MetricMap::load(&pth);
         assert_eq!(m3.len(), 2);
-        assert_eq!(*(m3.find(&~"runtime").get()), Metric { value: 1000.0, noise: 2.0 });
-        assert_eq!(*(m3.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 });
+        assert_eq!(*(m3.find(&~"runtime").unwrap()), Metric { value: 1000.0, noise: 2.0 });
+        assert_eq!(*(m3.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 2.0 });
 
         // Ask for a ratchet with an explicit noise-percentage override,
         // that should advance.
         let (diff2, ok2) = m2.ratchet(&pth, Some(10.0));
         assert_eq!(ok2, true);
         assert_eq!(diff2.len(), 2);
-        assert_eq!(*(diff2.find(&~"runtime").get()), LikelyNoise);
-        assert_eq!(*(diff2.find(&~"throughput").get()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"runtime").unwrap()), LikelyNoise);
+        assert_eq!(*(diff2.find(&~"throughput").unwrap()), LikelyNoise);
 
         // Check that it was rewritten.
         let m4 = MetricMap::load(&pth);
         assert_eq!(m4.len(), 2);
-        assert_eq!(*(m4.find(&~"runtime").get()), Metric { value: 1100.0, noise: 2.0 });
-        assert_eq!(*(m4.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 });
+        assert_eq!(*(m4.find(&~"runtime").unwrap()), Metric { value: 1100.0, noise: 2.0 });
+        assert_eq!(*(m4.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 2.0 });
 
         os::remove_dir_recursive(&dpth);
     }
diff --git a/src/libextra/url.rs b/src/libextra/url.rs
index 523c3521f8665..581bdf2a294db 100644
--- a/src/libextra/url.rs
+++ b/src/libextra/url.rs
@@ -134,7 +134,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str {
             match rdr.read_char() {
               '%' => {
                 let bytes = rdr.read_bytes(2u);
-                let ch = uint::parse_bytes(bytes, 16u).get() as char;
+                let ch = uint::parse_bytes(bytes, 16u).unwrap() as char;
 
                 if full_url {
                     // Only decode some characters:
@@ -257,7 +257,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> HashMap<~str, ~[~str]> {
                     let ch = match ch {
                         '%' => {
                             let bytes = rdr.read_bytes(2u);
-                            uint::parse_bytes(bytes, 16u).get() as char
+                            uint::parse_bytes(bytes, 16u).unwrap() as char
                         }
                         '+' => ' ',
                         ch => ch
diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index f066ede65f976..637ea159d79d0 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -912,7 +912,7 @@ pub fn link_args(sess: Session,
         }
         let dir = cratepath.dirname();
         if dir != ~"" { args.push(~"-L" + dir); }
-        let libarg = unlib(sess.targ_cfg, cratepath.filestem().get());
+        let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap());
         args.push(~"-l" + libarg);
     }
 
@@ -950,7 +950,7 @@ pub fn link_args(sess: Session,
         // be rpathed
         if sess.targ_cfg.os == session::os_macos {
             args.push(~"-Wl,-install_name,@rpath/"
-                      + output.filename().get());
+                      + output.filename().unwrap());
         }
     }
 
diff --git a/src/librustc/back/passes.rs b/src/librustc/back/passes.rs
index b77ed10c21ba4..35d070baa9bac 100644
--- a/src/librustc/back/passes.rs
+++ b/src/librustc/back/passes.rs
@@ -319,7 +319,7 @@ fn passes_exist() {
         if !pass.is_some() {
             failed.push(name);
         } else {
-            unsafe { llvm::LLVMDestroyPass(pass.get()) }
+            unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
         }
     }
     for &(name,_) in transform_passes.iter() {
@@ -327,7 +327,7 @@ fn passes_exist() {
         if !pass.is_some() {
             failed.push(name);
         } else {
-            unsafe { llvm::LLVMDestroyPass(pass.get()) }
+            unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
         }
     }
     for &(name,_) in utility_passes.iter() {
@@ -335,7 +335,7 @@ fn passes_exist() {
         if !pass.is_some() {
             failed.push(name);
         } else {
-            unsafe { llvm::LLVMDestroyPass(pass.get()) }
+            unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
         }
     }
 
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index ea679d19f73b8..356820f8267fe 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -922,7 +922,7 @@ pub fn build_output_filenames(input: &input,
           };
 
           let mut stem = match *input {
-              file_input(ref ifile) => (*ifile).filestem().get().to_managed(),
+              file_input(ref ifile) => (*ifile).filestem().unwrap().to_managed(),
               str_input(_) => @"rust_out"
           };
 
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index 8ca68251cb891..d2d2a8b4be99d 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -308,7 +308,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
             #[main];
             extra::test::test_main_static(::std::os::args(), TESTS);
         }
-    )).get();
+    )).unwrap();
 
     let testmod = ast::_mod {
         view_items: view_items,
@@ -366,7 +366,7 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
         pub static TESTS : &'static [self::extra::test::TestDescAndFn] =
             $test_descs
         ;
-    )).get()
+    )).unwrap()
 }
 
 fn is_extra(cx: &TestCtxt) -> bool {
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 34f4425a871dd..b909f70440a82 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -328,7 +328,7 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
 
     match *ii {
         //hack: we're not dropping items
-        ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
+        ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()),
         ast::ii_method(d, is_provided, m) =>
           ast::ii_method(d, is_provided, fld.fold_method(m)),
         ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i))
@@ -350,7 +350,7 @@ fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
     });
 
     match ii {
-        ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
+        ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()),
         ast::ii_method(d, is_provided, m) =>
           ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m)),
         ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)),
@@ -1275,7 +1275,7 @@ fn mk_ctxt() -> @fake_ext_ctxt {
 fn roundtrip(in_item: Option<@ast::item>) {
     use std::io;
 
-    let in_item = in_item.get();
+    let in_item = in_item.unwrap();
     let bytes = do io::with_bytes_writer |wr| {
         let mut ebml_w = writer::Encoder(wr);
         encode_item_ast(&mut ebml_w, in_item);
@@ -1321,13 +1321,13 @@ fn test_simplification() {
             fn eq_int(a: int, b: int) -> bool { a == b }
             return alist {eq_fn: eq_int, data: ~[]};
         }
-    ).get());
+    ).unwrap());
     let item_out = simplify_ast(&item_in);
     let item_exp = ast::ii_item(quote_item!(
         fn new_int_alist<B>() -> alist<int, B> {
             return alist {eq_fn: eq_int, data: ~[]};
         }
-    ).get());
+    ).unwrap());
     match (item_out, item_exp) {
       (ast::ii_item(item_out), ast::ii_item(item_exp)) => {
         assert!(pprust::item_to_str(item_out,
diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs
index 646840f1e3063..c3bb2000447f7 100644
--- a/src/librustc/middle/borrowck/check_loans.rs
+++ b/src/librustc/middle/borrowck/check_loans.rs
@@ -307,7 +307,7 @@ impl<'self> CheckLoanCtxt<'self> {
         // if they cannot already have been assigned
         if self.is_local_variable(cmt) {
             assert!(cmt.mutbl.is_immutable()); // no "const" locals
-            let lp = opt_loan_path(cmt).get();
+            let lp = opt_loan_path(cmt).unwrap();
             do self.move_data.each_assignment_of(expr.id, lp) |assign| {
                 self.bccx.report_reassigned_immutable_variable(
                     expr.span,
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index 4de096428f26f..1b420b9c06a55 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -109,7 +109,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) {
             let pat_matches_nan: &fn(@pat) -> bool = |p| {
                 match cx.tcx.def_map.find(&p.id) {
                     Some(&def_static(did, false)) => {
-                        let const_expr = lookup_const_by_id(cx.tcx, did).get();
+                        let const_expr = lookup_const_by_id(cx.tcx, did).unwrap();
                         match eval_const_expr(cx.tcx, const_expr) {
                             const_float(f) if f.is_NaN() => true,
                             _ => false
@@ -304,7 +304,7 @@ pub fn is_useful_specialized(cx: &MatchCheckCtxt,
                           -> useful {
     let ms = m.iter().filter_map(|r| specialize(cx, *r, &ctor, arity, lty)).collect::<matrix>();
     let could_be_useful = is_useful(
-        cx, &ms, specialize(cx, v, &ctor, arity, lty).get());
+        cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap());
     match could_be_useful {
       useful_ => useful(lty, ctor),
       ref u => *u,
@@ -319,7 +319,7 @@ pub fn pat_ctor_id(cx: &MatchCheckCtxt, p: @pat) -> Option<ctor> {
         match cx.tcx.def_map.find(&pat.id) {
           Some(&def_variant(_, id)) => Some(variant(id)),
           Some(&def_static(did, false)) => {
-            let const_expr = lookup_const_by_id(cx.tcx, did).get();
+            let const_expr = lookup_const_by_id(cx.tcx, did).unwrap();
             Some(val(eval_const_expr(cx.tcx, const_expr)))
           }
           _ => None
@@ -515,7 +515,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
                     }
                     Some(&def_static(did, _)) => {
                         let const_expr =
-                            lookup_const_by_id(cx.tcx, did).get();
+                            lookup_const_by_id(cx.tcx, did).unwrap();
                         let e_v = eval_const_expr(cx.tcx, const_expr);
                         let match_ = match *ctor_id {
                             val(ref v) => {
@@ -565,7 +565,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
                 match cx.tcx.def_map.get_copy(&pat_id) {
                     def_static(did, _) => {
                         let const_expr =
-                            lookup_const_by_id(cx.tcx, did).get();
+                            lookup_const_by_id(cx.tcx, did).unwrap();
                         let e_v = eval_const_expr(cx.tcx, const_expr);
                         let match_ = match *ctor_id {
                             val(ref v) =>
@@ -867,7 +867,7 @@ pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
                 "cannot bind by-move and by-ref \
                  in the same pattern");
             tcx.sess.span_note(
-                by_ref_span.get(),
+                by_ref_span.unwrap(),
                 "by-ref binding occurs here");
         }
     };
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index 330e44893f04a..77e81709a03d7 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -466,9 +466,9 @@ pub fn lit_to_const(lit: &lit) -> const_val {
       lit_int(n, _) => const_int(n),
       lit_uint(n, _) => const_uint(n),
       lit_int_unsuffixed(n) => const_int(n),
-      lit_float(n, _) => const_float(float::from_str(n).get() as f64),
+      lit_float(n, _) => const_float(float::from_str(n).unwrap() as f64),
       lit_float_unsuffixed(n) =>
-        const_float(float::from_str(n).get() as f64),
+        const_float(float::from_str(n).unwrap() as f64),
       lit_nil => const_int(0i64),
       lit_bool(b) => const_bool(b)
     }
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 76d1d0b05ffbc..9ffeb99ac3559 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -225,7 +225,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
         // the default implementation.
         // Having to do this this is really unfortunate.
         let method_id = ty::method(tcx, method_id).provided_source
-            .get_or_default(method_id);
+            .unwrap_or_default(method_id);
 
         if method_id.crate == LOCAL_CRATE {
             let is_private = method_is_private(span, method_id.node);
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 60ecff39d8554..5ca3a58b137a7 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -1726,7 +1726,7 @@ impl Resolver {
         let mut modules = HashMap::new();
 
         // Create all the items reachable by paths.
-        do each_path(self.session.cstore, root.def_id.get().crate)
+        do each_path(self.session.cstore, root.def_id.unwrap().crate)
                 |path_string, def_like, visibility| {
 
             debug!("(building reduced graph for external crate) found path \
@@ -2350,7 +2350,7 @@ impl Resolver {
         match type_result {
             BoundResult(target_module, name_bindings) => {
                 debug!("(resolving single import) found type target: %?",
-                        name_bindings.type_def.get().type_def);
+                        name_bindings.type_def.unwrap().type_def);
                 import_resolution.type_target =
                     Some(Target(target_module, name_bindings));
                 import_resolution.type_id = directive.id;
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
index 725beee6604e7..d77cebbf23e0b 100644
--- a/src/librustc/middle/trans/_match.rs
+++ b/src/librustc/middle/trans/_match.rs
@@ -210,7 +210,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool {
                         ExprLit(existing_a_expr) => a_expr = existing_a_expr,
                             ConstLit(a_const) => {
                                 let e = const_eval::lookup_const_by_id(tcx, a_const);
-                                a_expr = e.get();
+                                a_expr = e.unwrap();
                             }
                         UnitLikeStructLit(_) => {
                             fail!("UnitLikeStructLit should have been handled \
@@ -223,7 +223,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool {
                         ExprLit(existing_b_expr) => b_expr = existing_b_expr,
                             ConstLit(b_const) => {
                                 let e = const_eval::lookup_const_by_id(tcx, b_const);
-                                b_expr = e.get();
+                                b_expr = e.unwrap();
                             }
                         UnitLikeStructLit(_) => {
                             fail!("UnitLikeStructLit should have been handled \
@@ -922,7 +922,7 @@ pub fn extract_vec_elems(bcx: @mut Block,
         }
     };
     if slice.is_some() {
-        let n = slice.get();
+        let n = slice.unwrap();
         let slice_offset = Mul(bcx, vt.llunit_size,
             C_int(bcx.ccx(), n as int)
         );
@@ -1280,7 +1280,7 @@ pub fn compile_submatch(bcx: @mut Block,
     let _icx = push_ctxt("match::compile_submatch");
     let mut bcx = bcx;
     if m.len() == 0u {
-        Br(bcx, chk.get()());
+        Br(bcx, chk.unwrap()());
         return;
     }
     if m[0].pats.len() == 0u {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index fad5b9ec73b0f..2eb9841c6c757 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -260,7 +260,7 @@ fn generic_fields_of(cx: &mut CrateContext, r: &Repr, sizing: bool) -> ~[Type] {
                     most_aligned = Some(st);
                 }
             }
-            let most_aligned = most_aligned.get();
+            let most_aligned = most_aligned.unwrap();
             let padding = largest_size - most_aligned.size;
 
             struct_llfields(cx, most_aligned, sizing)
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 0a28da5f88a7c..3fc6dbca96475 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -1321,7 +1321,7 @@ pub fn cleanup_and_leave(bcx: @mut Block,
     }
     match leave {
       Some(target) => Br(bcx, target),
-      None => { Resume(bcx, Load(bcx, bcx.fcx.personality.get())); }
+      None => { Resume(bcx, Load(bcx, bcx.fcx.personality.unwrap())); }
     }
 }
 
@@ -1529,7 +1529,7 @@ pub fn alloca_maybe_zeroed(cx: @mut Block, ty: Type, name: &str, zero: bool) ->
     let p = Alloca(cx, ty, name);
     if zero {
         let b = cx.fcx.ccx.builder();
-        b.position_before(cx.fcx.alloca_insert_pt.get());
+        b.position_before(cx.fcx.alloca_insert_pt.unwrap());
         memzero(&b, p, ty);
     }
     p
@@ -1575,7 +1575,7 @@ pub fn make_return_pointer(fcx: @mut FunctionContext, output_type: ty::t) -> Val
             llvm::LLVMGetParam(fcx.llfn, 0)
         } else {
             let lloutputtype = type_of::type_of(fcx.ccx, output_type);
-            let bcx = fcx.entry_bcx.get();
+            let bcx = fcx.entry_bcx.unwrap();
             Alloca(bcx, lloutputtype, "__make_return_pointer")
         }
     }
@@ -1793,7 +1793,7 @@ pub fn finish_fn(fcx: @mut FunctionContext, last_bcx: @mut Block) {
 pub fn build_return_block(fcx: &FunctionContext, ret_cx: @mut Block) {
     // Return the value if this function immediate; otherwise, return void.
     if fcx.llretptr.is_some() && fcx.has_immediate_return_value {
-        Ret(ret_cx, Load(ret_cx, fcx.llretptr.get()))
+        Ret(ret_cx, Load(ret_cx, fcx.llretptr.unwrap()))
     } else {
         RetVoid(ret_cx)
     }
@@ -1843,7 +1843,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
 
     // Create the first basic block in the function and keep a handle on it to
     //  pass to finish_fn later.
-    let bcx_top = fcx.entry_bcx.get();
+    let bcx_top = fcx.entry_bcx.unwrap();
     let mut bcx = bcx_top;
     let block_ty = node_id_type(bcx, body.id);
 
@@ -1861,7 +1861,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
     {
         bcx = controlflow::trans_block(bcx, body, expr::Ignore);
     } else {
-        let dest = expr::SaveIn(fcx.llretptr.get());
+        let dest = expr::SaveIn(fcx.llretptr.unwrap());
         bcx = controlflow::trans_block(bcx, body, dest);
     }
 
@@ -2055,18 +2055,18 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
 
     let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args);
 
-    let bcx = fcx.entry_bcx.get();
+    let bcx = fcx.entry_bcx.unwrap();
     let arg_tys = ty::ty_fn_args(ctor_ty);
 
     insert_synthetic_type_entries(bcx, fn_args, arg_tys);
     let bcx = copy_args_to_allocas(fcx, bcx, fn_args, raw_llargs, arg_tys);
 
     let repr = adt::represent_type(ccx, result_ty);
-    adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr);
+    adt::trans_start_init(bcx, repr, fcx.llretptr.unwrap(), disr);
     for (i, fn_arg) in fn_args.iter().enumerate() {
         let lldestptr = adt::trans_field_ptr(bcx,
                                              repr,
-                                             fcx.llretptr.get(),
+                                             fcx.llretptr.unwrap(),
                                              disr,
                                              i);
         let llarg = fcx.llargs.get_copy(&fn_arg.pat.id);
@@ -2293,7 +2293,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
         // be updated if this assertion starts to fail.
         assert!(fcx.has_immediate_return_value);
 
-        let bcx = fcx.entry_bcx.get();
+        let bcx = fcx.entry_bcx.unwrap();
         // Call main.
         let llenvarg = unsafe {
             let env_arg = fcx.env_arg_pos();
@@ -2782,7 +2782,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> ValueRef {
     }
 
     for key in keys.iter() {
-        let val = *ccx.module_data.find_equiv(key).get();
+        let val = *ccx.module_data.find_equiv(key).unwrap();
         let s_const = C_cstr(ccx, *key);
         let s_ptr = p2i(ccx, s_const);
         let v_ptr = p2i(ccx, val);
diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs
index 07b774105bbde..c8e2a17c3b5f1 100644
--- a/src/librustc/middle/trans/build.rs
+++ b/src/librustc/middle/trans/build.rs
@@ -319,7 +319,7 @@ pub fn Alloca(cx: @mut Block, Ty: Type, name: &str) -> ValueRef {
     unsafe {
         if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
         let b = cx.fcx.ccx.builder();
-        b.position_before(cx.fcx.alloca_insert_pt.get());
+        b.position_before(cx.fcx.alloca_insert_pt.unwrap());
         b.alloca(Ty, name)
     }
 }
@@ -328,7 +328,7 @@ pub fn ArrayAlloca(cx: @mut Block, Ty: Type, Val: ValueRef) -> ValueRef {
     unsafe {
         if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
         let b = cx.fcx.ccx.builder();
-        b.position_before(cx.fcx.alloca_insert_pt.get());
+        b.position_before(cx.fcx.alloca_insert_pt.unwrap());
         b.array_alloca(Ty, Val)
     }
 }
diff --git a/src/librustc/middle/trans/cabi.rs b/src/librustc/middle/trans/cabi.rs
index 3a6577e28b7cc..895bea715c964 100644
--- a/src/librustc/middle/trans/cabi.rs
+++ b/src/librustc/middle/trans/cabi.rs
@@ -169,7 +169,7 @@ impl FnType {
             } else {
                 Load(bcx, llretval)
             };
-            let llretptr = BitCast(bcx, bcx.fcx.llretptr.get(), self.ret_ty.ty.ptr_to());
+            let llretptr = BitCast(bcx, bcx.fcx.llretptr.unwrap(), self.ret_ty.ty.ptr_to());
             Store(bcx, llretval, llretptr);
         }
     }
diff --git a/src/librustc/middle/trans/closure.rs b/src/librustc/middle/trans/closure.rs
index ae3b773af0b63..602d33a197e29 100644
--- a/src/librustc/middle/trans/closure.rs
+++ b/src/librustc/middle/trans/closure.rs
@@ -330,7 +330,7 @@ pub fn load_environment(fcx: @mut FunctionContext,
         return;
     }
 
-    let bcx = fcx.entry_bcx.get();
+    let bcx = fcx.entry_bcx.unwrap();
 
     // Load a pointer to the closure data, skipping over the box header:
     let llcdata = opaque_box_body(bcx, cdata_ty, fcx.llenv);
@@ -443,7 +443,7 @@ pub fn trans_expr_fn(bcx: @mut Block,
                               if is_loop_body.is_some() {
                                   Store(bcx,
                                         C_bool(true),
-                                        bcx.fcx.llretptr.get());
+                                        bcx.fcx.llretptr.unwrap());
                               }
                           });
             rslt(bcx, llbox)
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 527706be6c1f7..f303e7b827597 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -251,7 +251,7 @@ impl FunctionContext {
 
     pub fn cleanup(&mut self) {
         unsafe {
-            llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.get());
+            llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.unwrap());
         }
         // Remove the cycle between fcx and bcx, so memory can be freed
         self.entry_bcx = None;
@@ -262,7 +262,7 @@ impl FunctionContext {
             self.llreturn = Some(base::mk_return_basic_block(self.llfn));
         }
 
-        self.llreturn.get()
+        self.llreturn.unwrap()
     }
 }
 
diff --git a/src/librustc/middle/trans/controlflow.rs b/src/librustc/middle/trans/controlflow.rs
index 4fa64b4130aa9..823b1e0645cbc 100644
--- a/src/librustc/middle/trans/controlflow.rs
+++ b/src/librustc/middle/trans/controlflow.rs
@@ -314,7 +314,7 @@ pub fn trans_break_cont(bcx: @mut Block,
                     Some(bcx) => bcx,
                         // This is a return from a loop body block
                         None => {
-                            Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.get());
+                            Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.unwrap());
                             cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
                             Unreachable(bcx);
                             return bcx;
@@ -346,7 +346,7 @@ pub fn trans_ret(bcx: @mut Block, e: Option<@ast::expr>) -> @mut Block {
         // to false, return flag to true, and then store the value in the
         // parent's retptr.
         Store(bcx, C_bool(true), flagptr);
-        Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
+        Store(bcx, C_bool(false), bcx.fcx.llretptr.unwrap());
         expr::SaveIn(match e {
           Some(x) => PointerCast(bcx, retptr,
                                  type_of(bcx.ccx(), expr_ty(bcx, x)).ptr_to()),
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index e31a27a4c6ca0..624704c2c686c 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -485,8 +485,8 @@ fn lexical_block_metadata(bcx: @mut Block) -> DILexicalBlock {
         }
     }
 
-    let span = bcx.node_info.get().span;
-    let id = bcx.node_info.get().id;
+    let span = bcx.node_info.unwrap().span;
+    let id = bcx.node_info.unwrap().id;
 
     // Check whether we already have a cache entry for this node id
     match dbg_cx(cx).created_blocks.find(&id) {
diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs
index 20c8e69129d74..6d5934592ebcb 100644
--- a/src/librustc/middle/trans/foreign.rs
+++ b/src/librustc/middle/trans/foreign.rs
@@ -149,7 +149,7 @@ fn build_shim_fn_(ccx: @mut CrateContext,
 
     // Declare the body of the shim function:
     let fcx = new_fn_ctxt(ccx, ~[], llshimfn, tys.fn_sig.output, None);
-    let bcx = fcx.entry_bcx.get();
+    let bcx = fcx.entry_bcx.unwrap();
 
     let llargbundle = get_param(llshimfn, 0u);
     let llargvals = arg_builder(bcx, tys, llargbundle);
@@ -190,7 +190,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext,
                   ret_builder: wrap_ret_builder) {
     let _icx = push_ctxt("foreign::build_wrap_fn_");
     let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, tys.fn_sig.output, None);
-    let bcx = fcx.entry_bcx.get();
+    let bcx = fcx.entry_bcx.unwrap();
 
     // Patch up the return type if it's not immediate and we're returning via
     // the C ABI.
@@ -226,7 +226,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext,
     } else {
         // Cast if we have to...
         // XXX: This is ugly.
-        let llretptr = BitCast(return_context, fcx.llretptr.get(), return_type.ptr_to());
+        let llretptr = BitCast(return_context, fcx.llretptr.unwrap(), return_type.ptr_to());
         Ret(return_context, Load(return_context, llretptr));
     }
     fcx.cleanup();
@@ -421,7 +421,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         debug!("build_direct_fn(%s)", link_name(ccx, item));
 
         let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
-        let bcx = fcx.entry_bcx.get();
+        let bcx = fcx.entry_bcx.unwrap();
         let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
         let ty = ty::lookup_item_type(ccx.tcx,
                                       ast_util::local_def(item.id)).ty;
@@ -431,7 +431,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         });
         let retval = Call(bcx, llbasefn, args);
         if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
-            Store(bcx, retval, fcx.llretptr.get());
+            Store(bcx, retval, fcx.llretptr.unwrap());
         }
         finish_fn(fcx, bcx);
     }
@@ -446,7 +446,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         debug!("build_fast_ffi_fn(%s)", link_name(ccx, item));
 
         let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
-        let bcx = fcx.entry_bcx.get();
+        let bcx = fcx.entry_bcx.unwrap();
         let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
         set_no_inline(fcx.llfn);
         set_fixed_stack_segment(fcx.llfn);
@@ -458,7 +458,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
         });
         let retval = Call(bcx, llbasefn, args);
         if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
-            Store(bcx, retval, fcx.llretptr.get());
+            Store(bcx, retval, fcx.llretptr.unwrap());
         }
         finish_fn(fcx, bcx);
     }
@@ -618,7 +618,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
         set_fixed_stack_segment(fcx.llfn);
     }
 
-    let mut bcx = fcx.entry_bcx.get();
+    let mut bcx = fcx.entry_bcx.unwrap();
     let first_real_arg = fcx.arg_pos(0u);
 
     let nm = ccx.sess.str_of(item.ident);
@@ -775,7 +775,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
             let in_type_size = machine::llbitsize_of_real(ccx, llintype);
             let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
             if in_type_size != out_type_size {
-                let sp = match ccx.tcx.items.get_copy(&ref_id.get()) {
+                let sp = match ccx.tcx.items.get_copy(&ref_id.unwrap()) {
                     ast_map::node_expr(e) => e.span,
                     _ => fail!("transmute has non-expr arg"),
                 };
@@ -816,7 +816,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
                     // NB: Do not use a Load and Store here. This causes massive
                     // code bloat when `transmute` is used on large structural
                     // types.
-                    let lldestptr = fcx.llretptr.get();
+                    let lldestptr = fcx.llretptr.unwrap();
                     let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
                     let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());
 
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index 659f56b355e79..948c9ceef8e61 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -311,7 +311,7 @@ pub fn call_tydesc_glue_full(bcx: @mut Block,
     let llrawptr = if static_ti.is_none() || static_glue_fn.is_none() {
         PointerCast(bcx, v, Type::i8p())
     } else {
-        let ty = static_ti.get().ty;
+        let ty = static_ti.unwrap().ty;
         let simpl = simplified_glue_type(ccx.tcx, field, ty);
         if simpl != ty {
             PointerCast(bcx, v, type_of(ccx, simpl).ptr_to())
@@ -708,7 +708,7 @@ pub fn make_generic_glue_inner(ccx: @mut CrateContext,
     // llfn is expected be declared to take a parameter of the appropriate
     // type, so we don't need to explicitly cast the function parameter.
 
-    let bcx = fcx.entry_bcx.get();
+    let bcx = fcx.entry_bcx.unwrap();
     let rawptr0_arg = fcx.arg_pos(0u);
     let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, rawptr0_arg as c_uint) };
     let bcx = helper(bcx, llrawptr0, t);
diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs
index 6fd47436fd884..5f8837b538cdf 100644
--- a/src/librustc/middle/trans/monomorphize.rs
+++ b/src/librustc/middle/trans/monomorphize.rs
@@ -180,7 +180,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
             let idx = psubsts.tys.len() - num_method_ty_params;
             let substs =
                 (psubsts.tys.slice(0, idx) +
-                 &[psubsts.self_ty.get()] +
+                 &[psubsts.self_ty.unwrap()] +
                  psubsts.tys.tailn(idx));
             debug!("static default: changed substitution to %s",
                    substs.repr(ccx.tcx));
@@ -245,7 +245,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
       }
       ast_map::node_variant(ref v, enum_item, _) => {
         let tvs = ty::enum_variants(ccx.tcx, local_def(enum_item.id));
-        let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).get();
+        let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).unwrap();
         let d = mk_lldecl();
         set_inline_hint(d);
         match v.node.kind {
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index e4259c80720e6..609aad0bc201c 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -303,10 +303,10 @@ impl Reflector {
                     //
                     llvm::LLVMGetParam(llfdecl, fcx.arg_pos(0u) as c_uint)
                 };
-                let mut bcx = fcx.entry_bcx.get();
+                let mut bcx = fcx.entry_bcx.unwrap();
                 let arg = BitCast(bcx, arg, llptrty);
                 let ret = adt::trans_get_discr(bcx, repr, arg);
-                Store(bcx, ret, fcx.llretptr.get());
+                Store(bcx, ret, fcx.llretptr.unwrap());
                 match fcx.llreturn {
                     Some(llreturn) => cleanup_and_Br(bcx, bcx, llreturn),
                     None => bcx = cleanup_block(bcx, Some(bcx.llbb))
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
index b743f2e940157..6a382cc1a5d1c 100644
--- a/src/librustc/middle/trans/type_of.rs
+++ b/src/librustc/middle/trans/type_of.rs
@@ -239,7 +239,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
 
       ty::ty_estr(ty::vstore_slice(_)) => {
           // This means we get a nicer name in the output
-          cx.tn.find_type("str_slice").get()
+          cx.tn.find_type("str_slice").unwrap()
       }
 
       ty::ty_estr(ty::vstore_fixed(n)) => {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 29b975cdf99f8..48a003ddaf157 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -33,6 +33,7 @@ use std::hashmap::{HashMap, HashSet};
 use std::ops;
 use std::ptr::to_unsafe_ptr;
 use std::to_bytes;
+use std::to_str::ToStr;
 use std::u32;
 use std::vec;
 use syntax::ast::*;
@@ -116,7 +117,7 @@ pub struct mt {
     mutbl: ast::mutability,
 }
 
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
 pub enum vstore {
     vstore_fixed(uint),
     vstore_uniq,
@@ -124,7 +125,7 @@ pub enum vstore {
     vstore_slice(Region)
 }
 
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
 pub enum TraitStore {
     BoxTraitStore,              // @Trait
     UniqTraitStore,             // ~Trait
@@ -350,6 +351,12 @@ pub struct t_box_ {
 enum t_opaque {}
 pub type t = *t_opaque;
 
+impl ToStr for t {
+    fn to_str(&self) -> ~str {
+        ~"*t_opaque"
+    }
+}
+
 pub fn get(t: t) -> t_box {
     unsafe {
         let t2: t_box = cast::transmute(t);
@@ -410,7 +417,7 @@ pub struct param_ty {
 }
 
 /// Representation of regions:
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
 pub enum Region {
     /// Bound regions are found (primarily) in function types.  They indicate
     /// region parameters that have yet to be replaced with actual regions
@@ -456,13 +463,13 @@ impl Region {
     }
 }
 
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
 pub struct FreeRegion {
     scope_id: NodeId,
     bound_region: bound_region
 }
 
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
 pub enum bound_region {
     /// The self region for structs, impls (&T in a type defn or &'self T)
     br_self,
@@ -620,19 +627,22 @@ pub enum IntVarValue {
     UintType(ast::uint_ty),
 }
 
-#[deriving(Clone)]
+#[deriving(Clone, ToStr)]
 pub enum terr_vstore_kind {
-    terr_vec, terr_str, terr_fn, terr_trait
+    terr_vec,
+    terr_str,
+    terr_fn,
+    terr_trait
 }
 
-#[deriving(Clone)]
+#[deriving(Clone, ToStr)]
 pub struct expected_found<T> {
     expected: T,
     found: T
 }
 
 // Data structures used in type unification
-#[deriving(Clone)]
+#[deriving(Clone, ToStr)]
 pub enum type_err {
     terr_mismatch,
     terr_purity_mismatch(expected_found<purity>),
@@ -674,7 +684,7 @@ pub struct ParamBounds {
 
 pub type BuiltinBounds = EnumSet<BuiltinBound>;
 
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, IterBytes, ToStr)]
 pub enum BuiltinBound {
     BoundStatic,
     BoundSend,
@@ -725,7 +735,7 @@ pub enum InferTy {
     FloatVar(FloatVid)
 }
 
-#[deriving(Clone, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr)]
 pub enum InferRegion {
     ReVar(RegionVid),
     ReSkolemized(uint, bound_region)
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index ebf9d0944c9fb..53853e4fe1a78 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -531,7 +531,7 @@ pub fn ty_of_arg<AC:AstConv,
                  expected_ty: Option<ty::t>)
                  -> ty::t {
     match a.ty.node {
-        ast::ty_infer if expected_ty.is_some() => expected_ty.get(),
+        ast::ty_infer if expected_ty.is_some() => expected_ty.unwrap(),
         ast::ty_infer => this.ty_infer(a.ty.span),
         _ => ast_ty_to_ty(this, rscope, &a.ty),
     }
@@ -587,7 +587,7 @@ pub fn ty_of_method<AC:AstConv,RS:region_scope + Clone + 'static>(
     };
     let (a, b) = ty_of_method_or_bare_fn(
         this, rscope, purity, AbiSet::Rust(), lifetimes, Some(&self_info), decl);
-    (a.get(), b)
+    (a.unwrap(), b)
 }
 
 pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Clone + 'static>(
@@ -735,7 +735,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Clone + 'static>(
 
     let expected_ret_ty = expected_sig.map(|e| e.output);
     let output_ty = match decl.output.node {
-        ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.get(),
+        ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.unwrap(),
         ast::ty_infer => this.ty_infer(decl.output.span),
         _ => ast_ty_to_ty(this, &rb, &decl.output)
     };
diff --git a/src/librustc/middle/typeck/check/_match.rs b/src/librustc/middle/typeck/check/_match.rs
index 842bbff41e065..7caed39060159 100644
--- a/src/librustc/middle/typeck/check/_match.rs
+++ b/src/librustc/middle/typeck/check/_match.rs
@@ -166,7 +166,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
                     fcx.write_error(pat.id);
                     kind_name = "[error]";
                     arg_types = (*subpats).clone()
-                                          .get_or_default(~[])
+                                          .unwrap_or_default(~[])
                                           .map(|_| ty::mk_err());
                 }
             }
@@ -209,7 +209,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
             fcx.write_error(pat.id);
             kind_name = "[error]";
             arg_types = (*subpats).clone()
-                                  .get_or_default(~[])
+                                  .unwrap_or_default(~[])
                                   .map(|_| ty::mk_err());
         }
     }
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 209f636ddc238..e1e7d10db0abd 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -854,7 +854,7 @@ impl<'self> LookupContext<'self> {
                         // like &'a Self.  We then perform a
                         // substitution which will replace Self with
                         // @Trait.
-                        let t = candidate.method_ty.transformed_self_ty.get();
+                        let t = candidate.method_ty.transformed_self_ty.unwrap();
                         ty::subst(tcx, &candidate.rcvr_substs, t)
                     }
                     _ => {
@@ -863,7 +863,7 @@ impl<'self> LookupContext<'self> {
                 }
             }
             _ => {
-                let t = candidate.method_ty.transformed_self_ty.get();
+                let t = candidate.method_ty.transformed_self_ty.unwrap();
                 ty::subst(tcx, &candidate.rcvr_substs, t)
             }
         };
@@ -922,7 +922,7 @@ impl<'self> LookupContext<'self> {
                 tcx, @Nil, Some(transformed_self_ty), &bare_fn_ty.sig,
                 |br| self.fcx.infcx().next_region_var(
                     infer::BoundRegionInFnCall(self.expr.span, br)));
-        let transformed_self_ty = opt_transformed_self_ty.get();
+        let transformed_self_ty = opt_transformed_self_ty.unwrap();
         let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {
             sig: fn_sig,
             purity: bare_fn_ty.purity,
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 7f486f77447cb..ea8a11fc7b382 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -365,7 +365,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
                                                  bound_region: br}));
         let opt_self_info =
             opt_self_info.map(
-                |si| SelfInfo {self_ty: opt_self_ty.get(), ..*si});
+                |si| SelfInfo {self_ty: opt_self_ty.unwrap(), ..*si});
         (isr, opt_self_info, fn_sig)
     };
 
@@ -2449,7 +2449,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                            expected,
                                            |x| Some((*x).clone()));
         let inner_ty = match expected_sty {
-            Some(ty::ty_closure(_)) => expected.get(),
+            Some(ty::ty_closure(_)) => expected.unwrap(),
             _ => match expected {
                 Some(expected_t) => {
                     fcx.type_error_message(expr.span, |actual| {
diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs
index b9a62acd0bd87..f05388344bc71 100644
--- a/src/librustc/middle/typeck/infer/glb.rs
+++ b/src/librustc/middle/typeck/infer/glb.rs
@@ -253,7 +253,7 @@ impl Combine for Glb {
 
             if a_r.is_some() && b_r.is_some() && only_new_vars {
                 // Related to exactly one bound variable from each fn:
-                return rev_lookup(this, a_isr, a_r.get());
+                return rev_lookup(this, a_isr, a_r.unwrap());
             } else if a_r.is_none() && b_r.is_none() {
                 // Not related to bound variables from either fn:
                 return r0;
diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs
index e6c27fc8f836d..b1356ffb2d5e9 100644
--- a/src/librustc/middle/typeck/mod.rs
+++ b/src/librustc/middle/typeck/mod.rs
@@ -295,7 +295,7 @@ trait get_and_find_region {
 
 impl get_and_find_region for isr_alist {
     pub fn get(&self, br: ty::bound_region) -> ty::Region {
-        self.find(br).get()
+        self.find(br).unwrap()
     }
 
     pub fn find(&self, br: ty::bound_region) -> Option<ty::Region> {
diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs
index e2b25a67c3dde..bbcf42b1c5d32 100644
--- a/src/librustc/middle/typeck/rscope.rs
+++ b/src/librustc/middle/typeck/rscope.rs
@@ -18,6 +18,7 @@ use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
 use syntax::parse::token::special_idents;
 
+#[deriving(ToStr)]
 pub struct RegionError {
     msg: ~str,
     replacement: ty::Region
diff --git a/src/librustc/util/enum_set.rs b/src/librustc/util/enum_set.rs
index 2466c373f23b4..ced29f18f7f11 100644
--- a/src/librustc/util/enum_set.rs
+++ b/src/librustc/util/enum_set.rs
@@ -10,7 +10,7 @@
 
 use std::iterator::Iterator;
 
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, IterBytes, ToStr)]
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set
     // for which no variant exists
diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs
index b189bd2bc2dcd..a1cb81f450357 100644
--- a/src/librustdoc/attr_pass.rs
+++ b/src/librustdoc/attr_pass.rs
@@ -68,7 +68,7 @@ fn fold_crate(
     doc::CrateDoc {
         topmod: doc::ModDoc {
             item: doc::ItemDoc {
-                name: attrs.name.clone().get_or_default(doc.topmod.name_()),
+                name: attrs.name.clone().unwrap_or_default(doc.topmod.name_()),
                 .. doc.topmod.item.clone()
             },
             .. doc.topmod.clone()
@@ -135,7 +135,7 @@ fn fold_enum(
                             let ast_variant =
                                 (*enum_definition.variants.iter().find_(|v| {
                                     to_str(v.node.name) == variant.name
-                                }).get()).clone();
+                                }).unwrap()).clone();
 
                             attr_parser::parse_desc(
                                 ast_variant.node.attrs.clone())
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index f287e17880bb3..d387bbea592d3 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -142,7 +142,7 @@ fn config_from_opts(
         let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
         let output_dir = output_dir.map(|s| Path(*s));
         result::Ok(Config {
-            output_dir: output_dir.get_or_default(config.output_dir.clone()),
+            output_dir: output_dir.unwrap_or_default(config.output_dir.clone()),
             .. config
         })
     };
@@ -273,20 +273,20 @@ mod test {
     #[test]
     fn should_error_with_no_crates() {
         let config = parse_config([~"rustdoc"]);
-        assert!(config.get_err() == ~"no crates specified");
+        assert!(config.unwrap_err() == ~"no crates specified");
     }
 
     #[test]
     fn should_error_with_multiple_crates() {
         let config =
             parse_config([~"rustdoc", ~"crate1.rc", ~"crate2.rc"]);
-        assert!(config.get_err() == ~"multiple crates specified");
+        assert!(config.unwrap_err() == ~"multiple crates specified");
     }
 
     #[test]
     fn should_set_output_dir_to_cwd_if_not_provided() {
         let config = parse_config([~"rustdoc", ~"crate.rc"]);
-        assert!(config.get().output_dir == Path("."));
+        assert!(config.unwrap().output_dir == Path("."));
     }
 
     #[test]
@@ -294,13 +294,13 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles"
         ]);
-        assert!(config.get().output_dir == Path("snuggles"));
+        assert!(config.unwrap().output_dir == Path("snuggles"));
     }
 
     #[test]
     fn should_set_output_format_to_pandoc_html_if_not_provided() {
         let config = parse_config([~"rustdoc", ~"crate.rc"]);
-        assert!(config.get().output_format == PandocHtml);
+        assert!(config.unwrap().output_format == PandocHtml);
     }
 
     #[test]
@@ -308,7 +308,7 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
         ]);
-        assert!(config.get().output_format == Markdown);
+        assert!(config.unwrap().output_format == Markdown);
     }
 
     #[test]
@@ -316,7 +316,7 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
         ]);
-        assert!(config.get().output_format == PandocHtml);
+        assert!(config.unwrap().output_format == PandocHtml);
     }
 
     #[test]
@@ -324,13 +324,13 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus"
         ]);
-        assert!(config.get_err() == ~"unknown output format 'bogus'");
+        assert!(config.unwrap_err() == ~"unknown output format 'bogus'");
     }
 
     #[test]
     fn should_set_output_style_to_doc_per_mod_by_default() {
         let config = parse_config([~"rustdoc", ~"crate.rc"]);
-        assert!(config.get().output_style == DocPerMod);
+        assert!(config.unwrap().output_style == DocPerMod);
     }
 
     #[test]
@@ -338,7 +338,7 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate"
         ]);
-        assert!(config.get().output_style == DocPerCrate);
+        assert!(config.unwrap().output_style == DocPerCrate);
     }
 
     #[test]
@@ -346,7 +346,7 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod"
         ]);
-        assert!(config.get().output_style == DocPerMod);
+        assert!(config.unwrap().output_style == DocPerMod);
     }
 
     #[test]
@@ -354,7 +354,7 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus"
         ]);
-        assert!(config.get_err() == ~"unknown output style 'bogus'");
+        assert!(config.unwrap_err() == ~"unknown output style 'bogus'");
     }
 
     #[test]
@@ -362,12 +362,12 @@ mod test {
         let config = parse_config([
             ~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc"
         ]);
-        assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc"));
+        assert!(config.unwrap().pandoc_cmd == Some(~"panda-bear-doc"));
     }
 
     #[test]
     fn should_set_pandoc_command_when_using_pandoc() {
         let config = parse_config([~"rustdoc", ~"crate.rc"]);
-        assert!(config.get().pandoc_cmd == Some(~"pandoc"));
+        assert!(config.unwrap().pandoc_cmd == Some(~"pandoc"));
     }
 }
diff --git a/src/librustdoc/desc_to_brief_pass.rs b/src/librustdoc/desc_to_brief_pass.rs
index 9e1dffb989b00..9f8041712eaec 100644
--- a/src/librustdoc/desc_to_brief_pass.rs
+++ b/src/librustdoc/desc_to_brief_pass.rs
@@ -83,7 +83,7 @@ pub fn extract(desc: Option<~str>) -> Option<~str> {
         return None
     }
 
-    parse_desc(desc.clone().get())
+    parse_desc(desc.clone().unwrap())
 }
 
 fn parse_desc(desc: ~str) -> Option<~str> {
diff --git a/src/librustdoc/doc.rs b/src/librustdoc/doc.rs
index cca898feba2b2..d24fd1f5bfe54 100644
--- a/src/librustdoc/doc.rs
+++ b/src/librustdoc/doc.rs
@@ -176,7 +176,7 @@ impl Doc {
               doc::CratePage(doc) => Some(doc),
               _ => None
             }
-        }).get()
+        }).unwrap()
     }
 
     pub fn cratemod(&self) -> ModDoc {
diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs
index 2c6312e01b205..90634770a501e 100644
--- a/src/librustdoc/markdown_index_pass.rs
+++ b/src/librustdoc/markdown_index_pass.rs
@@ -223,13 +223,13 @@ mod test {
             config::DocPerCrate,
             ~"mod a { } fn b() { }"
         );
-        assert!(doc.cratemod().index.get().entries[0] == doc::IndexEntry {
+        assert!(doc.cratemod().index.unwrap().entries[0] == doc::IndexEntry {
             kind: ~"Module",
             name: ~"a",
             brief: None,
             link: ~"#module-a"
         });
-        assert!(doc.cratemod().index.get().entries[1] == doc::IndexEntry {
+        assert!(doc.cratemod().index.unwrap().entries[1] == doc::IndexEntry {
             kind: ~"Function",
             name: ~"b",
             brief: None,
@@ -243,13 +243,13 @@ mod test {
             config::DocPerMod,
             ~"mod a { } fn b() { }"
         );
-        assert_eq!(doc.cratemod().index.get().entries[0], doc::IndexEntry {
+        assert_eq!(doc.cratemod().index.unwrap().entries[0], doc::IndexEntry {
             kind: ~"Module",
             name: ~"a",
             brief: None,
             link: ~"a.html"
         });
-        assert_eq!(doc.cratemod().index.get().entries[1], doc::IndexEntry {
+        assert_eq!(doc.cratemod().index.unwrap().entries[1], doc::IndexEntry {
             kind: ~"Function",
             name: ~"b",
             brief: None,
@@ -263,7 +263,7 @@ mod test {
             config::DocPerMod,
             ~"#[doc = \"test\"] mod a { }"
         );
-        assert_eq!(doc.cratemod().index.get().entries[0].brief, Some(~"test"));
+        assert_eq!(doc.cratemod().index.unwrap().entries[0].brief, Some(~"test"));
     }
 
     #[test]
@@ -273,7 +273,7 @@ mod test {
             ~"extern { fn b(); }"
         );
         // hidden __std_macros module at the start.
-        assert_eq!(doc.cratemod().nmods()[0].index.get().entries[0],
+        assert_eq!(doc.cratemod().nmods()[0].index.unwrap().entries[0],
                    doc::IndexEntry {
                        kind: ~"Function",
                        name: ~"b",
diff --git a/src/librustdoc/markdown_pass.rs b/src/librustdoc/markdown_pass.rs
index 0dbd29df48b63..85c360a9e0dfd 100644
--- a/src/librustdoc/markdown_pass.rs
+++ b/src/librustdoc/markdown_pass.rs
@@ -617,10 +617,10 @@ mod test {
               fn d() { }"
         );
 
-        let idx_a = markdown.find_str("# Module `a`").get();
-        let idx_b = markdown.find_str("## Function `b`").get();
-        let idx_c = markdown.find_str("# Module `c`").get();
-        let idx_d = markdown.find_str("## Function `d`").get();
+        let idx_a = markdown.find_str("# Module `a`").unwrap();
+        let idx_b = markdown.find_str("## Function `b`").unwrap();
+        let idx_c = markdown.find_str("# Module `c`").unwrap();
+        let idx_d = markdown.find_str("## Function `d`").unwrap();
 
         assert!(idx_b < idx_d);
         assert!(idx_d < idx_a);
diff --git a/src/librustdoc/sectionalize_pass.rs b/src/librustdoc/sectionalize_pass.rs
index 4cd442bb95147..20f3ff3e98d48 100644
--- a/src/librustdoc/sectionalize_pass.rs
+++ b/src/librustdoc/sectionalize_pass.rs
@@ -218,8 +218,8 @@ mod test {
               Body\"]\
               mod a {
 }");
-        assert!(!doc.cratemod().mods()[0].desc().get().contains("Header"));
-        assert!(!doc.cratemod().mods()[0].desc().get().contains("Body"));
+        assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Header"));
+        assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Body"));
     }
 
     #[test]
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index abfc3517d60eb..684b4e9d198d4 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -135,7 +135,7 @@ fn fold_enum(
                             let ast_variant =
                                 (*do enum_definition.variants.iter().find_ |v| {
                                 to_str(v.node.name) == variant.name
-                            }.get()).clone();
+                            }.unwrap()).clone();
 
                             pprust::variant_to_str(
                                 &ast_variant, extract::interner())
@@ -443,7 +443,7 @@ mod test {
     #[test]
     fn should_add_struct_defs() {
         let doc = mk_doc(~"struct S { field: () }");
-        assert!(doc.cratemod().structs()[0].sig.get().contains(
+        assert!(doc.cratemod().structs()[0].sig.unwrap().contains(
             "struct S {"));
     }
 
@@ -451,6 +451,6 @@ mod test {
     fn should_not_serialize_struct_attrs() {
         // All we care about are the fields
         let doc = mk_doc(~"#[wut] struct S { field: () }");
-        assert!(!doc.cratemod().structs()[0].sig.get().contains("wut"));
+        assert!(!doc.cratemod().structs()[0].sig.unwrap().contains("wut"));
     }
 }
diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs
index 568a691290c88..5d5518997f68f 100644
--- a/src/librusti/rusti.rs
+++ b/src/librusti/rusti.rs
@@ -322,14 +322,14 @@ fn compile_crate(src_filename: ~str, binary: ~str) -> Option<bool> {
             // instead we guess which file is the library by matching
             // the prefix and suffix of out_filename to files in the
             // directory.
-            let file_str = file.filename().get();
-            file_str.starts_with(outputs.out_filename.filestem().get())
-                && file_str.ends_with(outputs.out_filename.filetype().get())
+            let file_str = file.filename().unwrap();
+            file_str.starts_with(outputs.out_filename.filestem().unwrap())
+                && file_str.ends_with(outputs.out_filename.filetype().unwrap())
         };
         match maybe_lib_path {
             Some(lib_path) => {
-                let (src_mtime, _) = src_path.get_mtime().get();
-                let (lib_mtime, _) = lib_path.get_mtime().get();
+                let (src_mtime, _) = src_path.get_mtime().unwrap();
+                let (lib_mtime, _) = lib_path.get_mtime().unwrap();
                 if lib_mtime >= src_mtime {
                     should_compile = false;
                 }
diff --git a/src/librustpkg/rustpkg.rs b/src/librustpkg/rustpkg.rs
index 4d6033de54de4..fa03a5bbfc2fb 100644
--- a/src/librustpkg/rustpkg.rs
+++ b/src/librustpkg/rustpkg.rs
@@ -102,7 +102,7 @@ impl<'self> PkgScript<'self> {
     debug!("pkgscript parse: %?", os::self_exe_path());
         let options = @session::options {
             binary: binary,
-            maybe_sysroot: Some(@os::self_exe_path().get().pop()),
+            maybe_sysroot: Some(@os::self_exe_path().unwrap().pop()),
             crate_type: session::bin_crate,
             .. (*session::basic_options()).clone()
         };
@@ -535,7 +535,7 @@ pub fn main() {
  * in is the working directory.
  */
 pub fn work_dir() -> Path {
-    os::self_exe_path().get()
+    os::self_exe_path().unwrap()
 }
 
 /**
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
index 361981289d3ce..81b47d6a16c0a 100644
--- a/src/librustpkg/util.rs
+++ b/src/librustpkg/util.rs
@@ -195,7 +195,7 @@ pub fn compile_input(ctxt: &Ctx,
                           }
                           + flags
                           + cfgs.flat_map(|c| { ~[~"--cfg", (*c).clone()] }),
-                          driver::optgroups()).get();
+                          driver::optgroups()).unwrap();
     let options = @session::options {
         crate_type: crate_type,
         optimize: if opt { session::Aggressive } else { session::No },
diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 4ece53d0e7f52..a84f3137bbd5b 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -78,10 +78,8 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> @[A] {
  *             onto the vector being constructed.
  */
 #[inline]
-pub fn build_sized_opt<A>(size: Option<uint>,
-                          builder: &fn(push: &fn(v: A)))
-                       -> @[A] {
-    build_sized(size.get_or_default(4), builder)
+pub fn build_sized_opt<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> @[A] {
+    build_sized(size.unwrap_or_default(4), builder)
 }
 
 // Appending
diff --git a/src/libstd/either.rs b/src/libstd/either.rs
index 6bdc45d72042a..cfaef550c6fa7 100644
--- a/src/libstd/either.rs
+++ b/src/libstd/either.rs
@@ -23,29 +23,102 @@ use str::StrSlice;
 use vec;
 use vec::{OwnedVector, ImmutableVector};
 
-/// The either type
+/// `Either` is a type that represents one of two alternatives
 #[deriving(Clone, Eq)]
-pub enum Either<T, U> {
-    Left(T),
-    Right(U)
+pub enum Either<L, R> {
+    Left(L),
+    Right(R)
 }
 
-/// Applies a function based on the given either value
-///
-/// If `value` is left(T) then `f_left` is applied to its contents, if
-/// `value` is right(U) then `f_right` is applied to its contents, and the
-/// result is returned.
-#[inline]
-pub fn either<T, U, V>(f_left: &fn(&T) -> V,
-                       f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
-    match *value {
-        Left(ref l) => f_left(l),
-        Right(ref r) => f_right(r)
+impl<L, R> Either<L, R> {
+    /// Applies a function based on the given either value
+    ///
+    /// If `value` is `Left(L)` then `f_left` is applied to its contents, if
+    /// `value` is `Right(R)` then `f_right` is applied to its contents, and the
+    /// result is returned.
+    #[inline]
+    pub fn either<T>(&self, f_left: &fn(&L) -> T, f_right: &fn(&R) -> T) -> T {
+        match *self {
+            Left(ref l) => f_left(l),
+            Right(ref r) => f_right(r)
+        }
+    }
+
+    /// Flips between left and right of a given `Either`
+    #[inline]
+    pub fn flip(self) -> Either<R, L> {
+        match self {
+            Right(r) => Left(r),
+            Left(l) => Right(l)
+        }
+    }
+
+    /// Converts a `Either` to a `Result`
+    ///
+    /// Converts an `Either` type to a `Result` type, making the "right" choice
+    /// an `Ok` result, and the "left" choice a `Err`
+    #[inline]
+    pub fn to_result(self) -> Result<R, L> {
+        match self {
+            Right(r) => result::Ok(r),
+            Left(l) => result::Err(l)
+        }
+    }
+
+    /// Checks whether the given value is a `Left`
+    #[inline]
+    pub fn is_left(&self) -> bool {
+        match *self {
+            Left(_) => true,
+            _ => false
+        }
+    }
+
+    /// Checks whether the given value is a `Right`
+    #[inline]
+    pub fn is_right(&self) -> bool {
+        match *self {
+            Right(_) => true,
+            _ => false
+        }
+    }
+
+    /// Retrieves the value from a `Left`.
+    /// Fails with a specified reason if the `Either` is `Right`.
+    #[inline]
+    pub fn expect_left(self, reason: &str) -> L {
+        match self {
+            Left(x) => x,
+            Right(_) => fail!(reason.to_owned())
+        }
+    }
+
+    /// Retrieves the value from a `Left`. Fails if the `Either` is `Right`.
+    #[inline]
+    pub fn unwrap_left(self) -> L {
+        self.expect_left("called Either::unwrap_left()` on `Right` value")
+    }
+
+    /// Retrieves the value from a `Right`.
+    /// Fails with a specified reason if the `Either` is `Left`.
+    #[inline]
+    pub fn expect_right(self, reason: &str) -> R {
+        match self {
+            Right(x) => x,
+            Left(_) => fail!(reason.to_owned())
+        }
+    }
+
+    /// Retrieves the value from a `Right`. Fails if the `Either` is `Left`.
+    #[inline]
+    pub fn unwrap_right(self) -> R {
+        self.expect_right("called Either::unwrap_right()` on `Left` value")
     }
 }
 
+// FIXME: #8228 Replaceable by an external iterator?
 /// Extracts from a vector of either all the left values
-pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
+pub fn lefts<L: Clone, R>(eithers: &[Either<L, R>]) -> ~[L] {
     do vec::build_sized(eithers.len()) |push| {
         for elt in eithers.iter() {
             match *elt {
@@ -56,8 +129,9 @@ pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
     }
 }
 
+// FIXME: #8228 Replaceable by an external iterator?
 /// Extracts from a vector of either all the right values
-pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
+pub fn rights<L, R: Clone>(eithers: &[Either<L, R>]) -> ~[R] {
     do vec::build_sized(eithers.len()) |push| {
         for elt in eithers.iter() {
             match *elt {
@@ -68,13 +142,14 @@ pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
     }
 }
 
+// FIXME: #8228 Replaceable by an external iterator?
 /// Extracts from a vector of either all the left values and right values
 ///
 /// Returns a structure containing a vector of left values and a vector of
 /// right values.
-pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
-    let mut lefts: ~[T] = ~[];
-    let mut rights: ~[U] = ~[];
+pub fn partition<L, R>(eithers: ~[Either<L, R>]) -> (~[L], ~[R]) {
+    let mut lefts: ~[L] = ~[];
+    let mut rights: ~[R] = ~[];
     for elt in eithers.consume_iter() {
         match elt {
             Left(l) => lefts.push(l),
@@ -84,196 +159,101 @@ pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
     return (lefts, rights);
 }
 
-/// Flips between left and right of a given either
-#[inline]
-pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
-    match eith {
-        Right(r) => Left(r),
-        Left(l) => Right(l)
-    }
-}
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-/// Converts either::t to a result::t
-///
-/// Converts an `either` type to a `result` type, making the "right" choice
-/// an ok result, and the "left" choice a fail
-#[inline]
-pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> {
-    match eith {
-        Right(r) => result::Ok(r),
-        Left(l) => result::Err(l)
+    #[test]
+    fn test_either_left() {
+        let val = Left(10);
+        fn f_left(x: &int) -> bool { *x == 10 }
+        fn f_right(_x: &uint) -> bool { false }
+        assert!(val.either(f_left, f_right));
     }
-}
 
-/// Checks whether the given value is a left
-#[inline]
-pub fn is_left<T, U>(eith: &Either<T, U>) -> bool {
-    match *eith {
-        Left(_) => true,
-        _ => false
+    #[test]
+    fn test_either_right() {
+        let val = Right(10u);
+        fn f_left(_x: &int) -> bool { false }
+        fn f_right(x: &uint) -> bool { *x == 10u }
+        assert!(val.either(f_left, f_right));
     }
-}
 
-/// Checks whether the given value is a right
-#[inline]
-pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
-    match *eith {
-        Right(_) => true,
-        _ => false
+    #[test]
+    fn test_lefts() {
+        let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
+        let result = lefts(input);
+        assert_eq!(result, ~[10, 12, 14]);
     }
-}
 
-/// Retrieves the value in the left branch.
-/// Fails with a specified reason if the either is Right.
-#[inline]
-pub fn expect_left<T,U>(eith: Either<T,U>, reason: &str) -> T {
-    match eith {
-        Left(x) => x,
-        Right(_) => fail!(reason.to_owned())
+    #[test]
+    fn test_lefts_none() {
+        let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
+        let result = lefts(input);
+        assert_eq!(result.len(), 0u);
     }
-}
 
-/// Retrieves the value in the left branch. Fails if the either is Right.
-#[inline]
-pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
-    expect_left(eith, "either::unwrap_left Right")
-}
-
-/// Retrieves the value in the right branch.
-/// Fails with a specified reason if the either is Left.
-#[inline]
-pub fn expect_right<T,U>(eith: Either<T,U>, reason: &str) -> U {
-    match eith {
-        Right(x) => x,
-        Left(_) => fail!(reason.to_owned())
+    #[test]
+    fn test_lefts_empty() {
+        let input: ~[Either<int, int>] = ~[];
+        let result = lefts(input);
+        assert_eq!(result.len(), 0u);
     }
-}
 
-/// Retrieves the value in the right branch. Fails if the either is Left.
-pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
-    expect_right(eith, "either::unwrap_right Left")
-}
-
-impl<T, U> Either<T, U> {
-    #[inline]
-    pub fn either<V>(&self, f_left: &fn(&T) -> V, f_right: &fn(&U) -> V) -> V {
-        either(f_left, f_right, self)
+    #[test]
+    fn test_rights() {
+        let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
+        let result = rights(input);
+        assert_eq!(result, ~[11, 13]);
     }
 
-    #[inline]
-    pub fn flip(self) -> Either<U, T> { flip(self) }
-
-    #[inline]
-    pub fn to_result(self) -> Result<U, T> { to_result(self) }
-
-    #[inline]
-    pub fn is_left(&self) -> bool { is_left(self) }
-
-    #[inline]
-    pub fn is_right(&self) -> bool { is_right(self) }
-
-    #[inline]
-    pub fn expect_left(self, reason: &str) -> T { expect_left(self, reason) }
-
-    #[inline]
-    pub fn unwrap_left(self) -> T { unwrap_left(self) }
-
-    #[inline]
-    pub fn expect_right(self, reason: &str) -> U { expect_right(self, reason) }
-
-    #[inline]
-    pub fn unwrap_right(self) -> U { unwrap_right(self) }
-}
-
-#[test]
-fn test_either_left() {
-    let val = Left(10);
-    fn f_left(x: &int) -> bool { *x == 10 }
-    fn f_right(_x: &uint) -> bool { false }
-    assert!((either(f_left, f_right, &val)));
-}
-
-#[test]
-fn test_either_right() {
-    let val = Right(10u);
-    fn f_left(_x: &int) -> bool { false }
-    fn f_right(x: &uint) -> bool { *x == 10u }
-    assert!((either(f_left, f_right, &val)));
-}
-
-#[test]
-fn test_lefts() {
-    let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
-    let result = lefts(input);
-    assert_eq!(result, ~[10, 12, 14]);
-}
-
-#[test]
-fn test_lefts_none() {
-    let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
-    let result = lefts(input);
-    assert_eq!(result.len(), 0u);
-}
-
-#[test]
-fn test_lefts_empty() {
-    let input: ~[Either<int, int>] = ~[];
-    let result = lefts(input);
-    assert_eq!(result.len(), 0u);
-}
-
-#[test]
-fn test_rights() {
-    let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
-    let result = rights(input);
-    assert_eq!(result, ~[11, 13]);
-}
+    #[test]
+    fn test_rights_none() {
+        let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
+        let result = rights(input);
+        assert_eq!(result.len(), 0u);
+    }
 
-#[test]
-fn test_rights_none() {
-    let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
-    let result = rights(input);
-    assert_eq!(result.len(), 0u);
-}
+    #[test]
+    fn test_rights_empty() {
+        let input: ~[Either<int, int>] = ~[];
+        let result = rights(input);
+        assert_eq!(result.len(), 0u);
+    }
 
-#[test]
-fn test_rights_empty() {
-    let input: ~[Either<int, int>] = ~[];
-    let result = rights(input);
-    assert_eq!(result.len(), 0u);
-}
+    #[test]
+    fn test_partition() {
+        let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
+        let (lefts, rights) = partition(input);
+        assert_eq!(lefts[0], 10);
+        assert_eq!(lefts[1], 12);
+        assert_eq!(lefts[2], 14);
+        assert_eq!(rights[0], 11);
+        assert_eq!(rights[1], 13);
+    }
 
-#[test]
-fn test_partition() {
-    let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
-    let (lefts, rights) = partition(input);
-    assert_eq!(lefts[0], 10);
-    assert_eq!(lefts[1], 12);
-    assert_eq!(lefts[2], 14);
-    assert_eq!(rights[0], 11);
-    assert_eq!(rights[1], 13);
-}
+    #[test]
+    fn test_partition_no_lefts() {
+        let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
+        let (lefts, rights) = partition(input);
+        assert_eq!(lefts.len(), 0u);
+        assert_eq!(rights.len(), 2u);
+    }
 
-#[test]
-fn test_partition_no_lefts() {
-    let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
-    let (lefts, rights) = partition(input);
-    assert_eq!(lefts.len(), 0u);
-    assert_eq!(rights.len(), 2u);
-}
+    #[test]
+    fn test_partition_no_rights() {
+        let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
+        let (lefts, rights) = partition(input);
+        assert_eq!(lefts.len(), 2u);
+        assert_eq!(rights.len(), 0u);
+    }
 
-#[test]
-fn test_partition_no_rights() {
-    let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
-    let (lefts, rights) = partition(input);
-    assert_eq!(lefts.len(), 2u);
-    assert_eq!(rights.len(), 0u);
-}
+    #[test]
+    fn test_partition_empty() {
+        let input: ~[Either<int, int>] = ~[];
+        let (lefts, rights) = partition(input);
+        assert_eq!(lefts.len(), 0u);
+        assert_eq!(rights.len(), 0u);
+    }
 
-#[test]
-fn test_partition_empty() {
-    let input: ~[Either<int, int>] = ~[];
-    let (lefts, rights) = partition(input);
-    assert_eq!(lefts.len(), 0u);
-    assert_eq!(rights.len(), 0u);
 }
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 537289c8dd6c2..c2a60e1c0e9c0 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -112,14 +112,14 @@ fn test_tls_multitask() {
         // TLS shouldn't carry over.
         assert!(get(my_key, |k| k.map(|&k| *k)).is_none());
         set(my_key, @~"child data");
-        assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) ==
+        assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) ==
                 ~"child data");
         // should be cleaned up for us
     }
     // Must work multiple times
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
+    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
 }
 
 #[test]
@@ -127,14 +127,14 @@ fn test_tls_overwrite() {
     static my_key: Key<@~str> = &Key;
     set(my_key, @~"first data");
     set(my_key, @~"next data"); // Shouldn't leak.
-    assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"next data");
+    assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"next data");
 }
 
 #[test]
 fn test_tls_pop() {
     static my_key: Key<@~str> = &Key;
     set(my_key, @~"weasel");
-    assert!(*(pop(my_key).get()) == ~"weasel");
+    assert!(*(pop(my_key).unwrap()) == ~"weasel");
     // Pop must remove the data from the map.
     assert!(pop(my_key).is_none());
 }
@@ -155,7 +155,7 @@ fn test_tls_modify() {
             None                 => fail!("missing value")
         }
     });
-    assert!(*(pop(my_key).get()) == ~"next data");
+    assert!(*(pop(my_key).unwrap()) == ~"next data");
 }
 
 #[test]
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 722af828d5c11..7ab3c81b61f7a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -726,4 +726,4 @@ mod bench {
             float::to_str(rng.gen());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 417251d3740e6..3a4a9220ee16c 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -47,7 +47,8 @@ use ops::Add;
 use util;
 use num::Zero;
 use iterator::Iterator;
-use str::StrSlice;
+use str::{StrSlice, OwnedStr};
+use to_str::ToStr;
 use clone::DeepClone;
 
 /// The option type
@@ -85,18 +86,33 @@ impl<T:Ord> Ord for Option<T> {
     }
 }
 
-impl<T:Clone+Add<T,T>> Add<Option<T>, Option<T>> for Option<T> {
+impl<T: Add<T, T>> Add<Option<T>, Option<T>> for Option<T> {
     #[inline]
     fn add(&self, other: &Option<T>) -> Option<T> {
         match (&*self, &*other) {
             (&None, &None) => None,
-            (_, &None) => (*self).clone(),
-            (&None, _) => (*other).clone(),
+            (_, &None) => None,
+            (&None, _) => None,
             (&Some(ref lhs), &Some(ref rhs)) => Some(*lhs + *rhs)
         }
     }
 }
 
+// FIXME: #8242 implementing manually because deriving doesn't work for some reason
+impl<T: ToStr> ToStr for Option<T> {
+    fn to_str(&self) -> ~str {
+        match *self {
+            Some(ref x) => {
+                let mut s = ~"Some(";
+                s.push_str(x.to_str());
+                s.push_str(")");
+                s
+            }
+            None => ~"None"
+        }
+    }
+}
+
 impl<T> Option<T> {
     /// Return an iterator over the possibly contained value
     #[inline]
@@ -148,8 +164,7 @@ impl<T> Option<T> {
     /// Update an optional value by optionally running its content by reference
     /// through a function that returns an option.
     #[inline]
-    pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>)
-                            -> Option<U> {
+    pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>) -> Option<U> {
         match *self {
             Some(ref x) => f(x),
             None => None
@@ -159,8 +174,7 @@ impl<T> Option<T> {
     /// Update an optional value by optionally running its content by mut reference
     /// through a function that returns an option.
     #[inline]
-    pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option<U>)
-                                -> Option<U> {
+    pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option<U>) -> Option<U> {
         match *self {
             Some(ref mut x) => f(x),
             None => None
@@ -256,132 +270,105 @@ impl<T> Option<T> {
         }
     }
 
-    /**
-    Gets an immutable reference to the value inside an option.
-
-    # Failure
-
-    Fails if the value equals `None`
-
-    # Safety note
-
-    In general, because this function may fail, its use is discouraged
-    (calling `get` on `None` is akin to dereferencing a null pointer).
-    Instead, prefer to use pattern matching and handle the `None`
-    case explicitly.
-     */
+    /// Gets an immutable reference to the value inside an option.
+    ///
+    /// # Failure
+    ///
+    /// Fails if the value equals `None`
+    ///
+    /// # Safety note
+    ///
+    /// In general, because this function may fail, its use is discouraged
+    /// (calling `get` on `None` is akin to dereferencing a null pointer).
+    /// Instead, prefer to use pattern matching and handle the `None`
+    /// case explicitly.
     #[inline]
     pub fn get_ref<'a>(&'a self) -> &'a T {
         match *self {
-          Some(ref x) => x,
-          None => fail!("option::get_ref `None`"),
+            Some(ref x) => x,
+            None => fail!("called `Option::get_ref()` on a `None` value"),
         }
     }
 
-    /**
-    Gets a mutable reference to the value inside an option.
-
-    # Failure
-
-    Fails if the value equals `None`
-
-    # Safety note
-
-    In general, because this function may fail, its use is discouraged
-    (calling `get` on `None` is akin to dereferencing a null pointer).
-    Instead, prefer to use pattern matching and handle the `None`
-    case explicitly.
-     */
+    /// Gets a mutable reference to the value inside an option.
+    ///
+    /// # Failure
+    ///
+    /// Fails if the value equals `None`
+    ///
+    /// # Safety note
+    ///
+    /// In general, because this function may fail, its use is discouraged
+    /// (calling `get` on `None` is akin to dereferencing a null pointer).
+    /// Instead, prefer to use pattern matching and handle the `None`
+    /// case explicitly.
     #[inline]
     pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
         match *self {
-          Some(ref mut x) => x,
-          None => fail!("option::get_mut_ref `None`"),
+            Some(ref mut x) => x,
+            None => fail!("called `Option::get_mut_ref()` on a `None` value"),
         }
     }
 
+    /// Moves a value out of an option type and returns it.
+    ///
+    /// Useful primarily for getting strings, vectors and unique pointers out
+    /// of option types without copying them.
+    ///
+    /// # Failure
+    ///
+    /// Fails if the value equals `None`.
+    ///
+    /// # Safety note
+    ///
+    /// In general, because this function may fail, its use is discouraged.
+    /// Instead, prefer to use pattern matching and handle the `None`
+    /// case explicitly.
     #[inline]
     pub fn unwrap(self) -> T {
-        /*!
-        Moves a value out of an option type and returns it.
-
-        Useful primarily for getting strings, vectors and unique pointers out
-        of option types without copying them.
-
-        # Failure
-
-        Fails if the value equals `None`.
-
-        # Safety note
-
-        In general, because this function may fail, its use is discouraged.
-        Instead, prefer to use pattern matching and handle the `None`
-        case explicitly.
-         */
         match self {
-          Some(x) => x,
-          None => fail!("option::unwrap `None`"),
+            Some(x) => x,
+            None => fail!("called `Option::unwrap()` on a `None` value"),
         }
     }
 
-    /**
-     * The option dance. Moves a value out of an option type and returns it,
-     * replacing the original with `None`.
-     *
-     * # Failure
-     *
-     * Fails if the value equals `None`.
-     */
+    /// The option dance. Moves a value out of an option type and returns it,
+    /// replacing the original with `None`.
+    ///
+    /// # Failure
+    ///
+    /// Fails if the value equals `None`.
     #[inline]
     pub fn take_unwrap(&mut self) -> T {
-        if self.is_none() { fail!("option::take_unwrap `None`") }
+        if self.is_none() {
+            fail!("called `Option::take_unwrap()` on a `None` value")
+        }
         self.take().unwrap()
     }
 
-    /**
-     * Gets the value out of an option, printing a specified message on
-     * failure
-     *
-     * # Failure
-     *
-     * Fails if the value equals `None`
-     */
+    ///  Gets the value out of an option, printing a specified message on
+    ///  failure
+    ///
+    ///  # Failure
+    ///
+    ///  Fails if the value equals `None`
     #[inline]
     pub fn expect(self, reason: &str) -> T {
         match self {
-          Some(val) => val,
-          None => fail!(reason.to_owned()),
+            Some(val) => val,
+            None => fail!(reason.to_owned()),
         }
     }
 
-    /**
-    Gets the value out of an option
-
-    # Failure
-
-    Fails if the value equals `None`
-
-    # Safety note
-
-    In general, because this function may fail, its use is discouraged
-    (calling `get` on `None` is akin to dereferencing a null pointer).
-    Instead, prefer to use pattern matching and handle the `None`
-    case explicitly.
-    */
+    /// Returns the contained value or a default
     #[inline]
-    pub fn get(self) -> T {
+    pub fn unwrap_or_default(self, def: T) -> T {
         match self {
-          Some(x) => return x,
-          None => fail!("option::get `None`")
+            Some(x) => x,
+            None => def
         }
     }
 
-    /// Returns the contained value or a default
-    #[inline]
-    pub fn get_or_default(self, def: T) -> T {
-        match self { Some(x) => x, None => def }
-    }
-
     /// Applies a function zero or more times until the result is `None`.
     #[inline]
     pub fn while_some(self, blk: &fn(v: T) -> Option<T>) {
@@ -395,12 +382,21 @@ impl<T> Option<T> {
 impl<T:Zero> Option<T> {
     /// Returns the contained value or zero (for this type)
     #[inline]
-    pub fn get_or_zero(self) -> T {
+    pub fn unwrap_or_zero(self) -> T {
         match self {
             Some(x) => x,
             None => Zero::zero()
         }
     }
+
+    /// Returns self or `Some(zero)` (for this type)
+    #[inline]
+    pub fn or_zero(self) -> Option<T> {
+        match self {
+            None => Some(Zero::zero()),
+            x => x
+        }
+    }
 }
 
 impl<T> Zero for Option<T> {
@@ -450,7 +446,7 @@ mod tests {
     use util;
 
     #[test]
-    fn test_unwrap_ptr() {
+    fn test_get_ptr() {
         unsafe {
             let x = ~0;
             let addr_x: *int = ::cast::transmute(&*x);
@@ -462,7 +458,7 @@ mod tests {
     }
 
     #[test]
-    fn test_unwrap_str() {
+    fn test_get_str() {
         let x = ~"test";
         let addr_x = x.as_imm_buf(|buf, _len| buf);
         let opt = Some(x);
@@ -472,7 +468,7 @@ mod tests {
     }
 
     #[test]
-    fn test_unwrap_resource() {
+    fn test_get_resource() {
         struct R {
            i: @mut int,
         }
@@ -530,18 +526,18 @@ mod tests {
     }
 
     #[test]
-    fn test_get_or_zero() {
+    fn test_unwrap_or_zero() {
         let some_stuff = Some(42);
-        assert_eq!(some_stuff.get_or_zero(), 42);
+        assert_eq!(some_stuff.unwrap_or_zero(), 42);
         let no_stuff: Option<int> = None;
-        assert_eq!(no_stuff.get_or_zero(), 0);
+        assert_eq!(no_stuff.unwrap_or_zero(), 0);
     }
 
     #[test]
     fn test_filtered() {
         let some_stuff = Some(42);
         let modified_stuff = some_stuff.filtered(|&x| {x < 10});
-        assert_eq!(some_stuff.get(), 42);
+        assert_eq!(some_stuff.unwrap(), 42);
         assert!(modified_stuff.is_none());
     }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 2d0b7d4f849d7..b0e1f35b4a018 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -571,7 +571,7 @@ pub fn tmpdir() -> Path {
 
     #[cfg(unix)]
     fn lookup() -> Path {
-        getenv_nonempty("TMPDIR").get_or_default(Path("/tmp"))
+        getenv_nonempty("TMPDIR").unwrap_or_default(Path("/tmp"))
     }
 
     #[cfg(windows)]
@@ -579,7 +579,7 @@ pub fn tmpdir() -> Path {
         getenv_nonempty("TMP").or(
             getenv_nonempty("TEMP").or(
                 getenv_nonempty("USERPROFILE").or(
-                   getenv_nonempty("WINDIR")))).get_or_default(Path("C:\\Windows"))
+                   getenv_nonempty("WINDIR")))).unwrap_or_default(Path("C:\\Windows"))
     }
 }
 
@@ -1782,7 +1782,7 @@ mod tests {
     fn test_self_exe_path() {
         let path = os::self_exe_path();
         assert!(path.is_some());
-        let path = path.get();
+        let path = path.unwrap();
         debug!(path.clone());
 
         // Hard to test this function
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index b7d72c11ff7a8..4ef524d77152b 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -533,7 +533,7 @@ impl<R: Rng> RngUtil for R {
 
     /// Choose an item randomly, failing if values is empty
     fn choose<T:Clone>(&mut self, values: &[T]) -> T {
-        self.choose_option(values).get()
+        self.choose_option(values).unwrap()
     }
 
     /// Choose Some(item) randomly, returning None if values is empty
@@ -549,7 +549,7 @@ impl<R: Rng> RngUtil for R {
      * the weights is 0
      */
     fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
-        self.choose_weighted_option(v).get()
+        self.choose_weighted_option(v).unwrap()
     }
 
     /**
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 7a578465841bb..181590e3929c5 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -20,23 +20,27 @@ use option::{None, Option, Some};
 use vec;
 use vec::{OwnedVector, ImmutableVector};
 use container::Container;
-
-/// The result type
+use to_str::ToStr;
+use str::StrSlice;
+
+/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
+///
+/// In order to provide informative error messages, `E` is reqired to implement `ToStr`.
+/// It is further recommended for `E` to be a descriptive error type, eg a `enum` for
+/// all possible errors cases.
 #[deriving(Clone, Eq)]
-pub enum Result<T, U> {
+pub enum Result<T, E> {
     /// Contains the successful result value
     Ok(T),
     /// Contains the error value
-    Err(U)
+    Err(E)
 }
 
-impl<T, E> Result<T, E> {
-    /**
-     * Convert to the `either` type
-     *
-     * `Ok` result variants are converted to `either::Right` variants, `Err`
-     * result variants are converted to `either::Left`.
-     */
+impl<T, E: ToStr> Result<T, E> {
+    /// Convert to the `either` type
+    ///
+    /// `Ok` result variants are converted to `either::Right` variants, `Err`
+    /// result variants are converted to `either::Left`.
     #[inline]
     pub fn to_either(self)-> either::Either<E, T>{
         match self {
@@ -45,18 +49,16 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /**
-     * Get a reference to the value out of a successful result
-     *
-     * # Failure
-     *
-     * If the result is an error
-     */
+    /// Get a reference to the value out of a successful result
+    ///
+    /// # Failure
+    ///
+    /// If the result is an error
     #[inline]
     pub fn get_ref<'a>(&'a self) -> &'a T {
         match *self {
             Ok(ref t) => t,
-            Err(ref e) => fail!("get_ref called on `Err` result: %?", *e),
+            Err(ref e) => fail!("called `Result::get_ref()` on `Err` value: %s", e.to_str()),
         }
     }
 
@@ -75,20 +77,18 @@ impl<T, E> Result<T, E> {
         !self.is_ok()
     }
 
-    /**
-     * Call a method based on a previous result
-     *
-     * If `self` is `Ok` then the value is extracted and passed to `op`
-     * whereupon `op`s result is returned. if `self` is `Err` then it is
-     * immediately returned. This function can be used to compose the results
-     * of two functions.
-     *
-     * Example:
-     *
-     *     do read_file(file).iter |buf| {
-     *         print_buf(buf)
-     *     }
-     */
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Ok` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is returned. if `self` is `Err` then it is
+    /// immediately returned. This function can be used to compose the results
+    /// of two functions.
+    ///
+    /// Example:
+    ///
+    ///     do read_file(file).iter |buf| {
+    ///         print_buf(buf)
+    ///     }
     #[inline]
     pub fn iter(&self, f: &fn(&T)) {
         match *self {
@@ -97,14 +97,12 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /**
-     * Call a method based on a previous result
-     *
-     * If `self` is `Err` then the value is extracted and passed to `op`
-     * whereupon `op`s result is returned. if `self` is `Ok` then it is
-     * immediately returned.  This function can be used to pass through a
-     * successful result while handling an error.
-     */
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Err` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is returned. if `self` is `Ok` then it is
+    /// immediately returned.  This function can be used to pass through a
+    /// successful result while handling an error.
     #[inline]
     pub fn iter_err(&self, f: &fn(&E)) {
         match *self {
@@ -113,38 +111,56 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /// Unwraps a result, assuming it is an `Ok(T)`
+    /// Unwraps a result, yielding the content of an `Ok`.
+    /// Fails if the value is a `Err` with an error message derived
+    /// from `E`'s `ToStr` implementation.
     #[inline]
     pub fn unwrap(self) -> T {
         match self {
             Ok(t) => t,
-            Err(_) => fail!("unwrap called on an `Err` result"),
+            Err(e) => fail!("called `Result::unwrap()` on `Err` value: %s", e.to_str()),
         }
     }
 
-    /// Unwraps a result, assuming it is an `Err(U)`
+    /// Unwraps a result, yielding the content of an `Err`.
+    /// Fails if the value is a `Ok`.
     #[inline]
     pub fn unwrap_err(self) -> E {
+        self.expect_err("called `Result::unwrap_err()` on `Ok` value")
+    }
+
+    /// Unwraps a result, yielding the content of an `Ok`.
+    /// Fails if the value is a `Err` with a custom failure message.
+    #[inline]
+    pub fn expect(self, reason: &str) -> T {
+        match self {
+            Ok(t) => t,
+            Err(_) => fail!(reason.to_owned()),
+        }
+    }
+
+    /// Unwraps a result, yielding the content of an `Err`
+    /// Fails if the value is a `Ok` with a custom failure message.
+    #[inline]
+    pub fn expect_err(self, reason: &str) -> E {
         match self {
             Err(e) => e,
-            Ok(_) => fail!("unwrap called on an `Ok` result"),
+            Ok(_) => fail!(reason.to_owned()),
         }
     }
 
-    /**
-     * Call a method based on a previous result
-     *
-     * If `self` is `Ok` then the value is extracted and passed to `op`
-     * whereupon `op`s result is returned. if `self` is `Err` then it is
-     * immediately returned. This function can be used to compose the results
-     * of two functions.
-     *
-     * Example:
-     *
-     *     let res = do read_file(file) |buf| {
-     *         Ok(parse_bytes(buf))
-     *     };
-     */
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Ok` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is returned. if `self` is `Err` then it is
+    /// immediately returned. This function can be used to compose the results
+    /// of two functions.
+    ///
+    /// Example:
+    ///
+    ///     let res = do read_file(file) |buf| {
+    ///         Ok(parse_bytes(buf))
+    ///     };
     #[inline]
     pub fn chain<U>(self, op: &fn(T) -> Result<U, E>) -> Result<U, E> {
         match self {
@@ -153,14 +169,12 @@ impl<T, E> Result<T, E> {
         }
     }
 
-    /**
-     * Call a function based on a previous result
-     *
-     * If `self` is `Err` then the value is extracted and passed to `op`
-     * whereupon `op`s result is returned. if `self` is `Ok` then it is
-     * immediately returned.  This function can be used to pass through a
-     * successful result while handling an error.
-     */
+    /// Call a function based on a previous result
+    ///
+    /// If `self` is `Err` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is returned. if `self` is `Ok` then it is
+    /// immediately returned.  This function can be used to pass through a
+    /// successful result while handling an error.
     #[inline]
     pub fn chain_err<F>(self, op: &fn(E) -> Result<T, F>) -> Result<T, F> {
         match self {
@@ -170,32 +184,15 @@ impl<T, E> Result<T, E> {
     }
 }
 
-impl<T: Clone, E> Result<T, E> {
-    /**
-     * Get the value out of a successful result
-     *
-     * # Failure
-     *
-     * If the result is an error
-     */
+impl<T: Clone, E: ToStr> Result<T, E> {
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Err` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
+    /// `Ok` then it is immediately returned.  This function can be used to pass
+    /// through a successful result while handling an error.
     #[inline]
-    pub fn get(&self) -> T {
-        match *self {
-            Ok(ref t) => t.clone(),
-            Err(ref e) => fail!("get called on `Err` result: %?", *e),
-        }
-    }
-
-    /**
-     * Call a method based on a previous result
-     *
-     * If `self` is `Err` then the value is extracted and passed to `op`
-     * whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
-     * `Ok` then it is immediately returned.  This function can be used to pass
-     * through a successful result while handling an error.
-     */
-    #[inline]
-    pub fn map_err<F:Clone>(&self, op: &fn(&E) -> F) -> Result<T,F> {
+    pub fn map_err<F: Clone>(&self, op: &fn(&E) -> F) -> Result<T,F> {
         match *self {
             Ok(ref t) => Ok(t.clone()),
             Err(ref e) => Err(op(e))
@@ -203,62 +200,57 @@ impl<T: Clone, E> Result<T, E> {
     }
 }
 
-impl<T, E: Clone> Result<T, E> {
-    /**
-     * Get the value out of an error result
-     *
-     * # Failure
-     *
-     * If the result is not an error
-     */
+impl<T, E: Clone + ToStr> Result<T, E> {
+    /// Call a method based on a previous result
+    ///
+    /// If `self` is `Ok` then the value is extracted and passed to `op`
+    /// whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
+    /// `Err` then it is immediately returned.  This function can be used to
+    /// compose the results of two functions.
+    ///
+    /// Example:
+    ///
+    ///     let res = do read_file(file).map |buf| {
+    ///         parse_bytes(buf)
+    ///     };
     #[inline]
-    pub fn get_err(&self) -> E {
+    pub fn map<U: Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
         match *self {
-            Err(ref e) => e.clone(),
-            Ok(_) => fail!("get_err called on `Ok` result")
+            Ok(ref t) => Ok(op(t)),
+            Err(ref e) => Err(e.clone())
         }
     }
+}
 
-    /**
-     * Call a method based on a previous result
-     *
-     * If `self` is `Ok` then the value is extracted and passed to `op`
-     * whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
-     * `Err` then it is immediately returned.  This function can be used to
-     * compose the results of two functions.
-     *
-     * Example:
-     *
-     *     let res = do read_file(file).map |buf| {
-     *         parse_bytes(buf)
-     *     };
-     */
-    #[inline]
-    pub fn map<U:Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
-        match *self {
-            Ok(ref t) => Ok(op(t)),
-            Err(ref e) => Err(e.clone())
+#[inline]
+#[allow(missing_doc)]
+pub fn map_opt<T, U: ToStr, V>(o_t: &Option<T>,
+                               op: &fn(&T) -> Result<V,U>) -> Result<Option<V>,U> {
+    match *o_t {
+        None => Ok(None),
+        Some(ref t) => match op(t) {
+            Ok(v) => Ok(Some(v)),
+            Err(e) => Err(e)
         }
     }
 }
 
-/**
- * Maps each element in the vector `ts` using the operation `op`.  Should an
- * error occur, no further mappings are performed and the error is returned.
- * Should no error occur, a vector containing the result of each map is
- * returned.
- *
- * Here is an example which increments every integer in a vector,
- * checking for overflow:
- *
- *     fn inc_conditionally(x: uint) -> result<uint,str> {
- *         if x == uint::max_value { return Err("overflow"); }
- *         else { return Ok(x+1u); }
- *     }
- *     map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
- *         assert!(incd == ~[2u, 3u, 4u]);
- *     }
- */
+// FIXME: #8228 Replaceable by an external iterator?
+/// Maps each element in the vector `ts` using the operation `op`.  Should an
+/// error occur, no further mappings are performed and the error is returned.
+/// Should no error occur, a vector containing the result of each map is
+/// returned.
+///
+/// Here is an example which increments every integer in a vector,
+/// checking for overflow:
+///
+///     fn inc_conditionally(x: uint) -> result<uint,str> {
+///         if x == uint::max_value { return Err("overflow"); }
+///         else { return Ok(x+1u); }
+///     }
+///     map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
+///         assert!(incd == ~[2u, 3u, 4u]);
+///     }
 #[inline]
 pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
                       -> Result<~[V],U> {
@@ -272,36 +264,17 @@ pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
     return Ok(vs);
 }
 
+// FIXME: #8228 Replaceable by an external iterator?
+/// Same as map, but it operates over two parallel vectors.
+///
+/// A precondition is used here to ensure that the vectors are the same
+/// length.  While we do not often use preconditions in the standard
+/// library, a precondition is used here because result::t is generally
+/// used in 'careful' code contexts where it is both appropriate and easy
+/// to accommodate an error like the vectors being of different lengths.
 #[inline]
-#[allow(missing_doc)]
-pub fn map_opt<T,
-               U,
-               V>(
-               o_t: &Option<T>,
-               op: &fn(&T) -> Result<V,U>)
-               -> Result<Option<V>,U> {
-    match *o_t {
-        None => Ok(None),
-        Some(ref t) => match op(t) {
-            Ok(v) => Ok(Some(v)),
-            Err(e) => Err(e)
-        }
-    }
-}
-
-/**
- * Same as map, but it operates over two parallel vectors.
- *
- * A precondition is used here to ensure that the vectors are the same
- * length.  While we do not often use preconditions in the standard
- * library, a precondition is used here because result::t is generally
- * used in 'careful' code contexts where it is both appropriate and easy
- * to accommodate an error like the vectors being of different lengths.
- */
-#[inline]
-pub fn map_vec2<S,T,U,V>(ss: &[S], ts: &[T],
-                op: &fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
-
+pub fn map_vec2<S, T, U: ToStr, V>(ss: &[S], ts: &[T],
+                                   op: &fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
     assert!(vec::same_length(ss, ts));
     let n = ts.len();
     let mut vs = vec::with_capacity(n);
@@ -316,15 +289,13 @@ pub fn map_vec2<S,T,U,V>(ss: &[S], ts: &[T],
     return Ok(vs);
 }
 
-/**
- * Applies op to the pairwise elements from `ss` and `ts`, aborting on
- * error.  This could be implemented using `map_zip()` but it is more efficient
- * on its own as no result vector is built.
- */
+// FIXME: #8228 Replaceable by an external iterator?
+/// Applies op to the pairwise elements from `ss` and `ts`, aborting on
+/// error.  This could be implemented using `map_zip()` but it is more efficient
+/// on its own as no result vector is built.
 #[inline]
-pub fn iter_vec2<S,T,U>(ss: &[S], ts: &[T],
-                         op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
-
+pub fn iter_vec2<S, T, U: ToStr>(ss: &[S], ts: &[T],
+                                 op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
     assert!(vec::same_length(ss, ts));
     let n = ts.len();
     let mut i = 0u;
@@ -353,12 +324,12 @@ mod tests {
 
     #[test]
     pub fn chain_success() {
-        assert_eq!(op1().chain(op2).get(), 667u);
+        assert_eq!(op1().chain(op2).unwrap(), 667u);
     }
 
     #[test]
     pub fn chain_failure() {
-        assert_eq!(op3().chain( op2).get_err(), ~"sadface");
+        assert_eq!(op3().chain( op2).unwrap_err(), ~"sadface");
     }
 
     #[test]
diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs
index e57b80658eef2..bea62f7e28c19 100644
--- a/src/libstd/rt/io/flate.rs
+++ b/src/libstd/rt/io/flate.rs
@@ -115,7 +115,7 @@ mod test {
         let mem_reader = MemReader::new(buf);
         let mut inflate_reader = InflateReader::new(mem_reader);
         let mut out_bytes = [0, .. 100];
-        let bytes_read = inflate_reader.read(out_bytes).get();
+        let bytes_read = inflate_reader.read(out_bytes).unwrap();
         assert_eq!(bytes_read, in_bytes.len());
         let out_msg = str::from_bytes(out_bytes);
         assert!(in_msg == out_msg);
diff --git a/src/libstd/rt/io/mod.rs b/src/libstd/rt/io/mod.rs
index 838c2d86c9fa2..c980dc9d73efd 100644
--- a/src/libstd/rt/io/mod.rs
+++ b/src/libstd/rt/io/mod.rs
@@ -243,6 +243,8 @@ Out of scope
 */
 
 use prelude::*;
+use to_str::ToStr;
+use str::{StrSlice, OwnedStr};
 
 // Reexports
 pub use self::stdio::stdin;
@@ -334,6 +336,20 @@ pub struct IoError {
     detail: Option<~str>
 }
 
+// FIXME: #8242 implementing manually because deriving doesn't work for some reason
+impl ToStr for IoError {
+    fn to_str(&self) -> ~str {
+        let mut s = ~"IoError { kind: ";
+        s.push_str(self.kind.to_str());
+        s.push_str(", desc: ");
+        s.push_str(self.desc);
+        s.push_str(", detail: ");
+        s.push_str(self.detail.to_str());
+        s.push_str(" }");
+        s
+    }
+}
+
 #[deriving(Eq)]
 pub enum IoErrorKind {
     PreviousIoError,
@@ -348,6 +364,24 @@ pub enum IoErrorKind {
     BrokenPipe
 }
 
+// FIXME: #8242 implementing manually because deriving doesn't work for some reason
+impl ToStr for IoErrorKind {
+    fn to_str(&self) -> ~str {
+        match *self {
+            PreviousIoError => ~"PreviousIoError",
+            OtherIoError => ~"OtherIoError",
+            EndOfFile => ~"EndOfFile",
+            FileNotFound => ~"FileNotFound",
+            PermissionDenied => ~"PermissionDenied",
+            ConnectionFailed => ~"ConnectionFailed",
+            Closed => ~"Closed",
+            ConnectionRefused => ~"ConnectionRefused",
+            ConnectionReset => ~"ConnectionReset",
+            BrokenPipe => ~"BrokenPipe"
+        }
+    }
+}
+
 // XXX: Can't put doc comments on macros
 // Raised by `I/O` operations on error.
 condition! {
@@ -505,4 +539,4 @@ pub fn placeholder_error() -> IoError {
         desc: "Placeholder error. You shouldn't be seeing this",
         detail: None
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index 33e83fd904041..760ca8a9adadc 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -365,7 +365,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
 
         rtdebug!("about to create the main scheduler task");
 
-        let mut main_sched = main_sched.get();
+        let mut main_sched = main_sched.unwrap();
 
         let home = Sched(main_sched.make_handle());
         let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool,
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index cb949edd7bb4a..4c5e4bdc3c1d9 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -465,10 +465,10 @@ mod test {
         do run_in_newsched_task() {
             static key: local_data::Key<@~str> = &local_data::Key;
             local_data::set(key, @~"data");
-            assert!(*local_data::get(key, |k| k.map(|&k| *k)).get() == ~"data");
+            assert!(*local_data::get(key, |k| k.map(|&k| *k)).unwrap() == ~"data");
             static key2: local_data::Key<@~str> = &local_data::Key;
             local_data::set(key2, @~"data");
-            assert!(*local_data::get(key2, |k| k.map(|&k| *k)).get() == ~"data");
+            assert!(*local_data::get(key2, |k| k.map(|&k| *k)).unwrap() == ~"data");
         }
     }
 
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 2427da01a0c1c..8b5215ae9694a 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -154,7 +154,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
 
     do run_in_bare_thread {
         let nthreads = match os::getenv("RUST_RT_TEST_THREADS") {
-            Some(nstr) => FromStr::from_str(nstr).get(),
+            Some(nstr) => FromStr::from_str(nstr).unwrap(),
             None => {
                 // Using more threads than cores in test code
                 // to force the OS to preempt them frequently.
@@ -362,7 +362,7 @@ pub fn stress_factor() -> uint {
     use os::getenv;
 
     match getenv("RUST_RT_STRESS") {
-        Some(val) => uint::from_str(val).get(),
+        Some(val) => uint::from_str(val).unwrap(),
         None => 1
     }
 }
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index a1169954688b0..40e5c8d4bf1a0 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -31,7 +31,7 @@ pub fn num_cpus() -> uint {
 /// either `RUST_THREADS` or `num_cpus`.
 pub fn default_sched_threads() -> uint {
     match os::getenv("RUST_THREADS") {
-        Some(nstr) => FromStr::from_str(nstr).get(),
+        Some(nstr) => FromStr::from_str(nstr).unwrap(),
         None => num_cpus()
     }
 }
@@ -118,4 +118,4 @@ pub fn get_exit_status() -> int {
     extern {
         fn rust_get_exit_status_newrt() -> libc::uintptr_t;
     }
-}
\ No newline at end of file
+}
diff --git a/src/libstd/rt/uv/net.rs b/src/libstd/rt/uv/net.rs
index 67d3bbef8a9c6..fd3042899f6bc 100644
--- a/src/libstd/rt/uv/net.rs
+++ b/src/libstd/rt/uv/net.rs
@@ -108,7 +108,7 @@ fn uv_socket_addr_as_socket_addr<T>(addr: UvSocketAddr, f: &fn(SocketAddr) -> T)
                             "" => ~[],
                             // IPv4-Mapped/Compatible IPv6 Address?
                             s if s.find('.').is_some() => {
-                                let i = s.rfind(':').get_or_default(-1);
+                                let i = s.rfind(':').unwrap_or_default(-1);
 
                                 let b = s.slice(i + 1, s.len()); // the ipv4 part
 
@@ -614,7 +614,7 @@ mod test {
             do tcp_watcher.connect(addr) |stream_watcher, status| {
                 rtdebug!("tcp_watcher.connect!");
                 assert!(status.is_some());
-                assert_eq!(status.get().name(), ~"ECONNREFUSED");
+                assert_eq!(status.unwrap().name(), ~"ECONNREFUSED");
                 stream_watcher.close(||());
             }
             loop_.run();
@@ -632,7 +632,7 @@ mod test {
             do tcp_watcher.connect(addr) |stream_watcher, status| {
                 rtdebug!("tcp_watcher.connect!");
                 assert!(status.is_some());
-                assert_eq!(status.get().name(), ~"ECONNREFUSED");
+                assert_eq!(status.unwrap().name(), ~"ECONNREFUSED");
                 stream_watcher.close(||());
             }
             loop_.run();
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index 85cf660a5f1aa..70a397199ab7c 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -278,7 +278,7 @@ impl IoFactory for UvIoFactory {
                     rtdebug!("status is some");
                     let task_cell = Cell::new(task_cell.take());
                     do stream_watcher.close {
-                        let res = Err(uv_error_to_io_error(status.get()));
+                        let res = Err(uv_error_to_io_error(status.unwrap()));
                         unsafe { (*result_cell_ptr).put_back(res); }
                         let scheduler = Local::take::<Scheduler>();
                         scheduler.resume_blocked_task_immediately(task_cell.take());
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 1a913fb4e996a..95a411a3f9673 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -58,7 +58,7 @@ pub fn from_bytes(vv: &[u8]) -> ~str {
     use str::not_utf8::cond;
 
     if !is_utf8(vv) {
-        let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get();
+        let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap();
         cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
                         first_bad_byte as uint))
     } else {
@@ -75,7 +75,7 @@ pub fn from_bytes_owned(vv: ~[u8]) -> ~str {
     use str::not_utf8::cond;
 
     if !is_utf8(vv) {
-        let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get();
+        let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap();
         cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
                         first_bad_byte as uint))
     } else {
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index f7a943f8d2fdf..225a4b8cfd294 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -926,7 +926,7 @@ fn test_named_task() {
         t.name(~"ada lovelace");
         do t.spawn {
             do with_task_name |name| {
-                assert!(name.get() == "ada lovelace");
+                assert!(name.unwrap() == "ada lovelace");
             }
         }
     }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index f037aa2b7e789..4d4437cc963ea 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -195,10 +195,8 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> ~[A] {
  *             onto the vector being constructed.
  */
 #[inline]
-pub fn build_sized_opt<A>(size: Option<uint>,
-                          builder: &fn(push: &fn(v: A)))
-                       -> ~[A] {
-    build_sized(size.get_or_default(4), builder)
+pub fn build_sized_opt<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> ~[A] {
+    build_sized(size.unwrap_or_default(4), builder)
 }
 
 /// An iterator over the slices of a vector separated by elements that
diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
index e6bbd45dae770..883020e637a1b 100644
--- a/src/libsyntax/abi.rs
+++ b/src/libsyntax/abi.rs
@@ -280,13 +280,13 @@ impl ToStr for AbiSet {
 #[test]
 fn lookup_Rust() {
     let abi = lookup("Rust");
-    assert!(abi.is_some() && abi.get().data().name == "Rust");
+    assert!(abi.is_some() && abi.unwrap().data().name == "Rust");
 }
 
 #[test]
 fn lookup_cdecl() {
     let abi = lookup("cdecl");
-    assert!(abi.is_some() && abi.get().data().name == "cdecl");
+    assert!(abi.is_some() && abi.unwrap().data().name == "cdecl");
 }
 
 #[test]
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index cf7a1e51798ac..435be3c71af6f 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -24,7 +24,7 @@ use extra::serialize::{Encodable, Decodable, Encoder, Decoder};
 // table) and a SyntaxContext to track renaming and
 // macro expansion per Flatt et al., "Macros
 // That Work Together"
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, IterBytes, ToStr)]
 pub struct ident { name: Name, ctxt: SyntaxContext }
 
 /// Construct an identifier with the given name and an empty context:
@@ -121,7 +121,7 @@ pub type CrateNum = int;
 
 pub type NodeId = int;
 
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
 pub struct def_id {
     crate: CrateNum,
     node: NodeId,
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index d1ddebfc347af..d39cb2f507ca9 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -114,7 +114,7 @@ impl AttributeMethods for Attribute {
     /// non-sugared doc attributes.)
     pub fn desugar_doc(&self) -> Attribute {
         if self.node.is_sugared_doc {
-            let comment = self.value_str().get();
+            let comment = self.value_str().unwrap();
             let meta = mk_name_value_item_str(@"doc",
                                               strip_doc_comment_decoration(comment).to_managed());
             mk_attr(meta)
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 1dda2493da20a..6ed5ca3e402a8 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -538,20 +538,20 @@ mod test {
         m.insert (@"def",@16);
         // FIXME: #4492 (ICE)  assert_eq!(m.find(&@"abc"),Some(@15));
         //  ....               assert_eq!(m.find(&@"def"),Some(@16));
-        assert_eq!(*(m.find(&@"abc").get()),15);
-        assert_eq!(*(m.find(&@"def").get()),16);
+        assert_eq!(*(m.find(&@"abc").unwrap()),15);
+        assert_eq!(*(m.find(&@"def").unwrap()),16);
         let n = m.push_frame();
         // old bindings are still present:
-        assert_eq!(*(n.find(&@"abc").get()),15);
-        assert_eq!(*(n.find(&@"def").get()),16);
+        assert_eq!(*(n.find(&@"abc").unwrap()),15);
+        assert_eq!(*(n.find(&@"def").unwrap()),16);
         n.insert (@"def",@17);
         // n shows the new binding
-        assert_eq!(*(n.find(&@"abc").get()),15);
-        assert_eq!(*(n.find(&@"def").get()),17);
+        assert_eq!(*(n.find(&@"abc").unwrap()),15);
+        assert_eq!(*(n.find(&@"def").unwrap()),17);
         // ... but m still has the old ones
         // FIXME: #4492: assert_eq!(m.find(&@"abc"),Some(@15));
         // FIXME: #4492: assert_eq!(m.find(&@"def"),Some(@16));
-        assert_eq!(*(m.find(&@"abc").get()),15);
-        assert_eq!(*(m.find(&@"def").get()),16);
+        assert_eq!(*(m.find(&@"abc").unwrap()),15);
+        assert_eq!(*(m.find(&@"def").unwrap()),16);
     }
 }
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index f5eb57c94b76f..fb1e6bf191384 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -961,7 +961,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
         let field_pats = do vec::build |push| {
             for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
                 // id is guaranteed to be Some
-                push(ast::field_pat { ident: id.get(), pat: pat })
+                push(ast::field_pat { ident: id.unwrap(), pat: pat })
             }
         };
         cx.pat_struct(span, matching_path, field_pats)
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index a6c5526b5a9b4..c7020b990bf00 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -1182,9 +1182,9 @@ mod test {
         let a2_name = intern("a2");
         let renamer = new_ident_renamer(ast::ident{name:a_name,ctxt:empty_ctxt},
                                         a2_name);
-        let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).get();
+        let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).unwrap();
         let resolver = new_ident_resolver();
-        let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).get();
+        let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).unwrap();
         let resolved_as_str = pprust::item_to_str(resolved_ast,
                                                   get_ident_interner());
         assert_eq!(resolved_as_str,~"fn a2() -> int { let b = 13; b }");
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 626a562b92c03..71903b9aa0204 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -31,7 +31,7 @@ pub fn expand_line(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "line!");
 
-    let topmost = topmost_expn_info(cx.backtrace().get());
+    let topmost = topmost_expn_info(cx.backtrace().unwrap());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
 
     base::MRExpr(cx.expr_uint(topmost.call_site, loc.line))
@@ -42,7 +42,7 @@ pub fn expand_col(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "col!");
 
-    let topmost = topmost_expn_info(cx.backtrace().get());
+    let topmost = topmost_expn_info(cx.backtrace().unwrap());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
     base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint()))
 }
@@ -54,7 +54,7 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "file!");
 
-    let topmost = topmost_expn_info(cx.backtrace().get());
+    let topmost = topmost_expn_info(cx.backtrace().unwrap());
     let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
     let filename = loc.file.name;
     base::MRExpr(cx.expr_str(topmost.call_site, filename))
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index afa2e7a5e42f5..a0932729930e3 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -691,7 +691,7 @@ impl Parser {
         */
 
         let opt_abis = self.parse_opt_abis();
-        let abis = opt_abis.get_or_default(AbiSet::Rust());
+        let abis = opt_abis.unwrap_or_default(AbiSet::Rust());
         let purity = self.parse_unsafety();
         self.expect_keyword(keywords::Fn);
         let (decl, lifetimes) = self.parse_ty_fn_decl();
@@ -3326,7 +3326,7 @@ impl Parser {
         let ident = self.parse_ident();
         let opt_bounds = self.parse_optional_ty_param_bounds();
         // For typarams we don't care about the difference b/w "<T>" and "<T:>".
-        let bounds = opt_bounds.get_or_default(opt_vec::Empty);
+        let bounds = opt_bounds.unwrap_or_default(opt_vec::Empty);
         ast::TyParam { ident: ident, id: self.get_id(), bounds: bounds }
     }
 
@@ -4196,7 +4196,7 @@ impl Parser {
                 self.obsolete(*self.last_span, ObsoleteExternVisibility);
             }
 
-            let abis = opt_abis.get_or_default(AbiSet::C());
+            let abis = opt_abis.unwrap_or_default(AbiSet::C());
 
             let (inner, next) = self.parse_inner_attrs_and_next();
             let m = self.parse_foreign_mod_items(sort, abis, next);
@@ -4463,7 +4463,7 @@ impl Parser {
 
             if self.eat_keyword(keywords::Fn) {
                 // EXTERN FUNCTION ITEM
-                let abis = opt_abis.get_or_default(AbiSet::C());
+                let abis = opt_abis.unwrap_or_default(AbiSet::C());
                 let (ident, item_, extra_attrs) =
                     self.parse_item_fn(extern_fn, abis);
                 return iovi_item(self.mk_item(lo, self.last_span.hi, ident,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 174b0f8e4517c..f517179f60366 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -874,7 +874,7 @@ pub fn print_attribute(s: @ps, attr: &ast::Attribute) {
     hardbreak_if_not_bol(s);
     maybe_print_comment(s, attr.span.lo);
     if attr.node.is_sugared_doc {
-        let comment = attr.value_str().get();
+        let comment = attr.value_str().unwrap();
         word(s.s, comment);
     } else {
         word(s.s, "#[");
@@ -1085,7 +1085,7 @@ pub fn print_call_post(s: @ps,
     }
     if sugar != ast::NoSugar {
         nbsp(s);
-        match blk.get().node {
+        match blk.unwrap().node {
           // need to handle closures specifically
           ast::expr_do_body(e) => {
             end(s); // we close our head box; closure
@@ -1095,7 +1095,7 @@ pub fn print_call_post(s: @ps,
           }
           _ => {
             // not sure if this can happen.
-            print_expr(s, blk.get());
+            print_expr(s, blk.unwrap());
           }
         }
     }
@@ -1323,13 +1323,13 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         assert!(body.stmts.is_empty());
         assert!(body.expr.is_some());
         // we extract the block, so as not to create another set of boxes
-        match body.expr.get().node {
+        match body.expr.unwrap().node {
             ast::expr_block(ref blk) => {
                 print_block_unclosed(s, blk);
             }
             _ => {
                 // this is a bare expression
-                print_expr(s, body.expr.get());
+                print_expr(s, body.expr.unwrap());
                 end(s); // need to close a box
             }
         }
diff --git a/src/test/bench/core-map.rs b/src/test/bench/core-map.rs
index da1c3596ff6c9..cf160ca31c6f1 100644
--- a/src/test/bench/core-map.rs
+++ b/src/test/bench/core-map.rs
@@ -100,7 +100,7 @@ fn main() {
     let args = os::args();
     let n_keys = {
         if args.len() == 2 {
-            uint::from_str(args[1]).get()
+            uint::from_str(args[1]).unwrap()
         } else {
             1000000
         }
diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs
index 2c412e2eecd80..4fbe00622aa26 100644
--- a/src/test/bench/core-set.rs
+++ b/src/test/bench/core-set.rs
@@ -159,7 +159,7 @@ fn main() {
     let args = os::args();
     let num_keys = {
         if args.len() == 2 {
-            uint::from_str(args[1]).get()
+            uint::from_str(args[1]).unwrap()
         } else {
             100 // woefully inadequate for any real measurement
         }
diff --git a/src/test/bench/core-uint-to-str.rs b/src/test/bench/core-uint-to-str.rs
index 8924a9beb6e5e..4a32fda59d81a 100644
--- a/src/test/bench/core-uint-to-str.rs
+++ b/src/test/bench/core-uint-to-str.rs
@@ -21,7 +21,7 @@ fn main() {
         args
     };
 
-    let n = uint::from_str(args[1]).get();
+    let n = uint::from_str(args[1]).unwrap();
 
     for i in range(0u, n) {
         let x = uint::to_str(i);
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 2557680f7b507..2f4d763b84d77 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -418,8 +418,8 @@ fn main() {
         args
     };
 
-    let scale = uint::from_str(args[1]).get();
-    let num_keys = uint::from_str(args[2]).get();
+    let scale = uint::from_str(args[1]).unwrap();
+    let num_keys = uint::from_str(args[2]).unwrap();
     let do_validate = false;
     let do_sequential = true;
 
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 186923da43b8c..4e9656afb813d 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -59,8 +59,8 @@ fn run(args: &[~str]) {
 
     let to_child = SharedChan::new(to_child);
 
-    let size = uint::from_str(args[1]).get();
-    let workers = uint::from_str(args[2]).get();
+    let size = uint::from_str(args[1]).unwrap();
+    let workers = uint::from_str(args[2]).unwrap();
     let num_bytes = 100;
     let start = extra::time::precise_time_s();
     let mut worker_results = ~[];
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index 05ace5fd8e6c7..470e23d63a514 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -53,8 +53,8 @@ fn run(args: &[~str]) {
     let (from_parent, to_child) = stream();
     let to_child = SharedChan::new(to_child);
 
-    let size = uint::from_str(args[1]).get();
-    let workers = uint::from_str(args[2]).get();
+    let size = uint::from_str(args[1]).unwrap();
+    let workers = uint::from_str(args[2]).unwrap();
     let num_bytes = 100;
     let start = extra::time::precise_time_s();
     let mut worker_results = ~[];
diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs
index 649d029e60e8b..7de95f4d822c5 100644
--- a/src/test/bench/msgsend-ring-mutex-arcs.rs
+++ b/src/test/bench/msgsend-ring-mutex-arcs.rs
@@ -79,8 +79,8 @@ fn main() {
         args.clone()
     };
 
-    let num_tasks = uint::from_str(args[1]).get();
-    let msg_per_task = uint::from_str(args[2]).get();
+    let num_tasks = uint::from_str(args[1]).unwrap();
+    let msg_per_task = uint::from_str(args[2]).unwrap();
 
     let (num_chan, num_port) = init();
     let num_chan = Cell::new(num_chan);
diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs
index 7f9d7aa588906..1299e863db6b3 100644
--- a/src/test/bench/msgsend-ring-rw-arcs.rs
+++ b/src/test/bench/msgsend-ring-rw-arcs.rs
@@ -75,8 +75,8 @@ fn main() {
         args.clone()
     };
 
-    let num_tasks = uint::from_str(args[1]).get();
-    let msg_per_task = uint::from_str(args[2]).get();
+    let num_tasks = uint::from_str(args[1]).unwrap();
+    let msg_per_task = uint::from_str(args[2]).unwrap();
 
     let (num_chan, num_port) = init();
     let num_chan = Cell::new(num_chan);
diff --git a/src/test/bench/shootout-ackermann.rs b/src/test/bench/shootout-ackermann.rs
index e06ff02a0b38f..e8659ba26d4bc 100644
--- a/src/test/bench/shootout-ackermann.rs
+++ b/src/test/bench/shootout-ackermann.rs
@@ -35,6 +35,6 @@ fn main() {
     } else {
         args
     };
-    let n = int::from_str(args[1]).get();
+    let n = int::from_str(args[1]).unwrap();
     printfln!("Ack(3,%d): %d\n", n, ack(3, n));
 }
diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs
index 57bf33fb2fdac..8a2ae3e899520 100644
--- a/src/test/bench/shootout-binarytrees.rs
+++ b/src/test/bench/shootout-binarytrees.rs
@@ -48,7 +48,7 @@ fn main() {
         args
     };
 
-    let n = int::from_str(args[1]).get();
+    let n = int::from_str(args[1]).unwrap();
     let min_depth = 4;
     let mut max_depth;
     if min_depth + 2 > n {
diff --git a/src/test/bench/shootout-chameneos-redux.rs b/src/test/bench/shootout-chameneos-redux.rs
index f48c15329463e..190ad62d6e17f 100644
--- a/src/test/bench/shootout-chameneos-redux.rs
+++ b/src/test/bench/shootout-chameneos-redux.rs
@@ -212,7 +212,7 @@ fn main() {
         args
     };
 
-    let nn = uint::from_str(args[1]).get();
+    let nn = uint::from_str(args[1]).unwrap();
 
     print_complements();
     io::println("");
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index bf942cf61a38c..9d4d31b896920 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -91,6 +91,6 @@ fn fannkuch_redux(n: i32) -> i32 {
 
 #[fixed_stack_segment]
 fn main() {
-    let n: i32 = FromStr::from_str(os::args()[1]).get();
+    let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
     printfln!("Pfannkuchen(%d) = %d", n as int, fannkuch_redux(n) as int);
 }
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index af96170c79c87..579b88a7e0e72 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -184,7 +184,7 @@ impl RandomFasta {
 
 #[fixed_stack_segment]
 fn main() {
-    let n: uint = FromStr::from_str(os::args()[1]).get();
+    let n: uint = FromStr::from_str(os::args()[1]).unwrap();
 
     unsafe {
         let mode = "w";
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 3a90c6647e08e..4e2ab8b0a498d 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -130,7 +130,7 @@ fn main() {
         io::stdout()
     };
 
-    let n = int::from_str(args[1]).get();
+    let n = int::from_str(args[1]).unwrap();
 
     let iub: ~[AminoAcids] =
         make_cumulative(~[acid('a', 27u32), acid('c', 12u32), acid('g', 12u32),
diff --git a/src/test/bench/shootout-fibo.rs b/src/test/bench/shootout-fibo.rs
index 7b8bc31bf1c83..9c07df36eb3c1 100644
--- a/src/test/bench/shootout-fibo.rs
+++ b/src/test/bench/shootout-fibo.rs
@@ -31,6 +31,6 @@ fn main() {
     } else {
         args
     };
-    let n = int::from_str(args[1]).get();
+    let n = int::from_str(args[1]).unwrap();
     printfln!("%d\n", fib(n));
 }
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index 16936f6ed722d..cf43f470e7177 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -9,7 +9,7 @@ static LIMIT: f64 = 2.0;
 #[fixed_stack_segment]
 fn main() {
     unsafe {
-        let w: i32 = FromStr::from_str(os::args()[1]).get();
+        let w: i32 = FromStr::from_str(os::args()[1]).unwrap();
         let h = w;
         let mut byte_acc: i8 = 0;
         let mut bit_num: i32 = 0;
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 99bd7c0f78672..115607d0a992c 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -137,7 +137,7 @@ fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) {
 }
 
 fn main() {
-    let n: i32 = FromStr::from_str(os::args()[1]).get();
+    let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
     let mut bodies = BODIES;
 
     offset_momentum(&mut bodies);
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 663ebcac3340a..611b11560e4ae 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -110,7 +110,7 @@ fn main() {
     if opts.stress {
         stress(2);
     } else {
-        let max = uint::parse_bytes(args[1].as_bytes(), 10u).get() as int;
+        let max = uint::parse_bytes(args[1].as_bytes(), 10u).unwrap() as int;
 
         let num_trials = 10;
 
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index e3c3c19c33bb3..aef22bc2b8426 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -52,7 +52,7 @@ fn mult_AtAv(v: &mut [f64], out: &mut [f64], tmp: &mut [f64]) {
 
 #[fixed_stack_segment]
 fn main() {
-    let n: uint = FromStr::from_str(os::args()[1]).get();
+    let n: uint = FromStr::from_str(os::args()[1]).unwrap();
     let mut u = vec::from_elem(n, 1f64);
     let mut v = u.clone();
     let mut tmp = u.clone();
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 203b9c297fa6b..ace008c1f95d2 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -62,13 +62,13 @@ fn main() {
         os::args()
     };
     let token = if args.len() > 1u {
-        FromStr::from_str(args[1]).get()
+        FromStr::from_str(args[1]).unwrap()
     }
     else {
         1000
     };
     let n_tasks = if args.len() > 2u {
-        FromStr::from_str(args[2]).get()
+        FromStr::from_str(args[2]).unwrap()
     }
     else {
         503
diff --git a/src/test/bench/std-smallintmap.rs b/src/test/bench/std-smallintmap.rs
index 2c2073eafea62..a035041a662dc 100644
--- a/src/test/bench/std-smallintmap.rs
+++ b/src/test/bench/std-smallintmap.rs
@@ -39,8 +39,8 @@ fn main() {
     } else {
         args
     };
-    let max = uint::from_str(args[1]).get();
-    let rep = uint::from_str(args[2]).get();
+    let max = uint::from_str(args[1]).unwrap();
+    let rep = uint::from_str(args[2]).unwrap();
 
     let mut checkf = 0.0;
     let mut appendf = 0.0;
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 49b2c32ed6867..6757354089534 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -75,9 +75,9 @@ impl Sudoku {
             let comps: ~[&str] = line.trim().split_iter(',').collect();
 
             if comps.len() == 3u {
-                let row     = uint::from_str(comps[0]).get() as u8;
-                let col     = uint::from_str(comps[1]).get() as u8;
-                g[row][col] = uint::from_str(comps[2]).get() as u8;
+                let row     = uint::from_str(comps[0]).unwrap() as u8;
+                let col     = uint::from_str(comps[1]).unwrap() as u8;
+                g[row][col] = uint::from_str(comps[2]).unwrap() as u8;
             }
             else {
                 fail!("Invalid sudoku file");
diff --git a/src/test/bench/task-perf-jargon-metal-smoke.rs b/src/test/bench/task-perf-jargon-metal-smoke.rs
index 4e27841a74850..be7f9b5f43adf 100644
--- a/src/test/bench/task-perf-jargon-metal-smoke.rs
+++ b/src/test/bench/task-perf-jargon-metal-smoke.rs
@@ -52,7 +52,7 @@ fn main() {
     };
 
     let (p,c) = comm::stream();
-    child_generation(uint::from_str(args[1]).get(), c);
+    child_generation(uint::from_str(args[1]).unwrap(), c);
     if p.try_recv().is_none() {
         fail!("it happened when we slumbered");
     }
diff --git a/src/test/bench/task-perf-linked-failure.rs b/src/test/bench/task-perf-linked-failure.rs
index 6ab83e5b3830b..95dd803af8183 100644
--- a/src/test/bench/task-perf-linked-failure.rs
+++ b/src/test/bench/task-perf-linked-failure.rs
@@ -71,7 +71,7 @@ fn main() {
         args.clone()
     };
 
-    let num_tasks = uint::from_str(args[1]).get();
+    let num_tasks = uint::from_str(args[1]).unwrap();
 
     // Main group #0 waits for unsupervised group #1.
     // Grandparent group #1 waits for middle group #2, then fails, killing #3.
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index a152c30213318..83116ae3c87de 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -31,7 +31,7 @@ fn main() {
     } else {
         args
     };
-    let n = uint::from_str(args[1]).get();
+    let n = uint::from_str(args[1]).unwrap();
     let mut i = 0u;
     while i < n { task::spawn(|| f(n) ); i += 1u; }
 }
diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
index 451616a074f11..cb6290686816d 100644
--- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs
@@ -17,7 +17,7 @@ fn main() {
         y = Some(x.downgrade(write_mode));
         //~^ ERROR cannot infer an appropriate lifetime
     }
-    y.get();
+    y.unwrap();
     // Adding this line causes a method unification failure instead
     // do (&option::unwrap(y)).read |state| { assert!(*state == 1); }
 }
diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
index b6535b6189a04..75e1989aff01a 100644
--- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
+++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs
@@ -17,7 +17,7 @@ fn main() {
     do x.write_downgrade |write_mode| {
         y = Some(write_mode);
     }
-    y.get();
+    y.unwrap();
     // Adding this line causes a method unification failure instead
     // do (&option::unwrap(y)).write |state| { assert!(*state == 1); }
 }
diff --git a/src/test/run-fail/result-get-fail.rs b/src/test/run-fail/result-get-fail.rs
index 782ce61cab253..4f552bc8f4216 100644
--- a/src/test/run-fail/result-get-fail.rs
+++ b/src/test/run-fail/result-get-fail.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// error-pattern:get called on `Err` result: ~"kitty"
+// error-pattern:called `Result::unwrap()` on `Err` value: kitty
 
 use std::result;
 
 fn main() {
-  error!(result::Err::<int,~str>(~"kitty").get());
+    error!(result::Err::<int,~str>(~"kitty").unwrap());
 }
diff --git a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs
index 3b18a8649eeea..668f602b3d35c 100644
--- a/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs
+++ b/src/test/run-pass/borrowck-wg-borrow-mut-to-imm.rs
@@ -1,5 +1,5 @@
 fn g(x: &Option<int>) {
-    println(x.get().to_str());
+    println(x.unwrap().to_str());
 }
 
 fn f(x: &mut Option<int>) {
diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs
index 4775e5fe0a80e..9f17b9d7f95b5 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-option.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs
@@ -19,5 +19,5 @@ fn select<'r>(x: &'r Option<int>, y: &'r Option<int>) -> &'r Option<int> {
 pub fn main() {
     let x = None;
     let y = Some(3);
-    assert_eq!(select(&x, &y).get(), 3);
+    assert_eq!(select(&x, &y).unwrap(), 3);
 }
diff --git a/src/test/run-pass/option_addition.rs b/src/test/run-pass/option_addition.rs
index fe39d1b11d3b8..8af173150a06d 100644
--- a/src/test/run-pass/option_addition.rs
+++ b/src/test/run-pass/option_addition.rs
@@ -9,29 +9,17 @@
 // except according to those terms.
 
 pub fn main() {
-    let foo = 1;
-    let bar = 2;
+    let foo: int = 1;
+    let bar: int = 2;
     let foobar = foo + bar;
 
-    let nope = optint(0) + optint(0);
-    let somefoo = optint(foo) + optint(0);
-    let somebar = optint(bar) + optint(0);
-    let somefoobar = optint(foo) + optint(bar);
+    let nope = None::<int> + None::<int>;
+    let somefoo = Some(foo) + None::<int>;
+    let somebar = None::<int> + Some(bar);
+    let somefoobar = Some(foo) + Some(bar);
 
-    match nope {
-        None => (),
-        Some(foo) => fail!("expected None, but found %?", foo)
-    }
-    assert_eq!(foo, somefoo.get());
-    assert_eq!(bar, somebar.get());
-    assert_eq!(foobar, somefoobar.get());
-}
-
-fn optint(input: int) -> Option<int> {
-    if input == 0 {
-        return None;
-    }
-    else {
-        return Some(input);
-    }
+    assert_eq!(nope, None::<int>);
+    assert_eq!(somefoo, None::<int>);
+    assert_eq!(somebar, None::<int>);
+    assert_eq!(foobar, somefoobar.unwrap());
 }
diff --git a/src/test/run-pass/region-dependent-addr-of.rs b/src/test/run-pass/region-dependent-addr-of.rs
index ac2fc2eda23cf..f5eb04dd83bfe 100644
--- a/src/test/run-pass/region-dependent-addr-of.rs
+++ b/src/test/run-pass/region-dependent-addr-of.rs
@@ -105,13 +105,13 @@ pub fn main() {
     assert_eq!(*p, a.value.v5.f);
 
     let p = get_v6_a(&a, 1);
-    assert_eq!(*p, a.value.v6.get().f);
+    assert_eq!(*p, a.value.v6.unwrap().f);
 
     let p = get_v6_b(&a, 1);
-    assert_eq!(*p, a.value.v6.get().f);
+    assert_eq!(*p, a.value.v6.unwrap().f);
 
     let p = get_v6_c(&a, 1);
-    assert_eq!(*p, a.value.v6.get().f);
+    assert_eq!(*p, a.value.v6.unwrap().f);
 
     let p = get_v5_ref(&a, 1);
     assert_eq!(*p, a.value.v5.f);

From 47e82c85555895c21206c84b62cac19eb351d1b8 Mon Sep 17 00:00:00 2001
From: Ben Blum <bblum@andrew.cmu.edu>
Date: Fri, 2 Aug 2013 19:35:13 -0400
Subject: [PATCH 14/29] (cleanup) Uncomment an assertion that now holds.

---
 src/libstd/rt/kill.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index deec8dd37a600..ef2d0de5312ca 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -205,11 +205,10 @@ impl BlockedTask {
                 let flag_arc = match task.death.spare_kill_flag.take() {
                     Some(spare_flag) => spare_flag,
                     None => {
-                        // FIXME(#7544): Uncomment this when terminate_current_task
-                        // stops being *terrible*. That's the only place that violates
-                        // the assumption of "becoming unkillable will fail if the
-                        // task was killed".
-                        // rtassert!(task.unwinder.unwinding);
+                        // A task that kills us won't have a spare kill flag to
+                        // give back to us, so we restore it ourselves here. This
+                        // situation should only arise when we're already failing.
+                        rtassert!(task.unwinder.unwinding);
                         (*task.death.kill_handle.get_ref().get()).killed.clone()
                     }
                 };

From 1f95bd768444a4a0318951c2e76f3d28bbf3763a Mon Sep 17 00:00:00 2001
From: Ben Blum <bblum@andrew.cmu.edu>
Date: Mon, 5 Aug 2013 16:55:08 -0400
Subject: [PATCH 15/29] Lazily initialize 'leaf node' taskgroups for unlinked
 spawns, for an apparent 11% speedup.

---
 src/libstd/rt/kill.rs    |   4 ++
 src/libstd/task/spawn.rs | 104 ++++++++++++++++++++++-----------------
 2 files changed, 63 insertions(+), 45 deletions(-)

diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index ef2d0de5312ca..3372c13b87703 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -193,6 +193,10 @@ impl BlockedTask {
 
     /// Create a blocked task, unless the task was already killed.
     pub fn try_block(mut task: ~Task) -> Either<~Task, BlockedTask> {
+        // NB: As an optimization, we could give a free pass to being unkillable
+        // to tasks whose taskgroups haven't been initialized yet, but that
+        // introduces complications with select() and with the test cases below,
+        // and it's not clear the uncommon performance boost is worth it.
         if task.death.unkillable > 0 {
             Right(Unkillable(task))
         } else {
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 3bf2f255f5751..527b20b0e9027 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -568,7 +568,8 @@ impl RuntimeGlue {
                 let me = Local::unsafe_borrow::<Task>();
                 blk(match (*me).taskgroup {
                     None => {
-                        // Main task, doing first spawn ever. Lazily initialize.
+                        // First task in its (unlinked/unsupervised) taskgroup.
+                        // Lazily initialize.
                         let mut members = TaskSet::new();
                         let my_handle = (*me).death.kill_handle.get_ref().clone();
                         members.insert(NewTask(my_handle));
@@ -591,37 +592,46 @@ impl RuntimeGlue {
     }
 }
 
+// Returns 'None' in the case where the child's TG should be lazily initialized.
 fn gen_child_taskgroup(linked: bool, supervised: bool)
-    -> (TaskGroupArc, AncestorList, bool) {
-    do RuntimeGlue::with_my_taskgroup |spawner_group| {
-        let ancestors = AncestorList(spawner_group.ancestors.map(|x| x.clone()));
-        if linked {
-            // Child is in the same group as spawner.
-            // Child's ancestors are spawner's ancestors.
-            // Propagate main-ness.
-            (spawner_group.tasks.clone(), ancestors, spawner_group.is_main)
-        } else {
-            // Child is in a separate group from spawner.
-            let g = Exclusive::new(Some(TaskGroupData {
-                members:     TaskSet::new(),
-                descendants: TaskSet::new(),
-            }));
-            let a = if supervised {
-                let new_generation = incr_generation(&ancestors);
-                assert!(new_generation < uint::max_value);
-                // Child's ancestors start with the spawner.
-                // Build a new node in the ancestor list.
-                AncestorList(Some(Exclusive::new(AncestorNode {
-                    generation: new_generation,
-                    parent_group: spawner_group.tasks.clone(),
-                    ancestors: ancestors,
-                })))
+    -> Option<(TaskGroupArc, AncestorList, bool)> {
+    // FIXME(#7544): Not safe to lazily initialize in the old runtime. Remove
+    // this context check once 'spawn_raw_oldsched' is gone.
+    if context() == OldTaskContext || linked || supervised {
+        // with_my_taskgroup will lazily initialize the parent's taskgroup if
+        // it doesn't yet exist. We don't want to call it in the unlinked case.
+        do RuntimeGlue::with_my_taskgroup |spawner_group| {
+            let ancestors = AncestorList(spawner_group.ancestors.map(|x| x.clone()));
+            if linked {
+                // Child is in the same group as spawner.
+                // Child's ancestors are spawner's ancestors.
+                // Propagate main-ness.
+                Some((spawner_group.tasks.clone(), ancestors, spawner_group.is_main))
             } else {
-                // Child has no ancestors.
-                AncestorList(None)
-            };
-            (g, a, false)
+                // Child is in a separate group from spawner.
+                let g = Exclusive::new(Some(TaskGroupData {
+                    members:     TaskSet::new(),
+                    descendants: TaskSet::new(),
+                }));
+                let a = if supervised {
+                    let new_generation = incr_generation(&ancestors);
+                    assert!(new_generation < uint::max_value);
+                    // Child's ancestors start with the spawner.
+                    // Build a new node in the ancestor list.
+                    AncestorList(Some(Exclusive::new(AncestorNode {
+                        generation: new_generation,
+                        parent_group: spawner_group.tasks.clone(),
+                        ancestors: ancestors,
+                    })))
+                } else {
+                    // Child has no ancestors.
+                    AncestorList(None)
+                };
+                Some((g, a, false))
+            }
         }
+    } else {
+        None
     }
 }
 
@@ -670,20 +680,24 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
 
     let child_wrapper: ~fn() = || {
         // Child task runs this code.
-        let child_data = Cell::new(child_data.take()); // :(
-        let enlist_success = do Local::borrow::<Task, bool> |me| {
-            let (child_tg, ancestors, is_main) = child_data.take();
-            let mut ancestors = ancestors;
-            // FIXME(#7544): Optimize out the xadd in this clone, somehow.
-            let handle = me.death.kill_handle.get_ref().clone();
-            // Atomically try to get into all of our taskgroups.
-            if enlist_many(NewTask(handle), &child_tg, &mut ancestors) {
-                // Got in. We can run the provided child body, and can also run
-                // the taskgroup's exit-time-destructor afterward.
-                me.taskgroup = Some(Taskgroup(child_tg, ancestors, is_main, None));
-                true
-            } else {
-                false
+
+        // If child data is 'None', the enlist is vacuously successful.
+        let enlist_success = do child_data.take().map_consume_default(true) |child_data| {
+            let child_data = Cell::new(child_data); // :(
+            do Local::borrow::<Task, bool> |me| {
+                let (child_tg, ancestors, is_main) = child_data.take();
+                let mut ancestors = ancestors;
+                // FIXME(#7544): Optimize out the xadd in this clone, somehow.
+                let handle = me.death.kill_handle.get_ref().clone();
+                // Atomically try to get into all of our taskgroups.
+                if enlist_many(NewTask(handle), &child_tg, &mut ancestors) {
+                    // Got in. We can run the provided child body, and can also run
+                    // the taskgroup's exit-time-destructor afterward.
+                    me.taskgroup = Some(Taskgroup(child_tg, ancestors, is_main, None));
+                    true
+                } else {
+                    false
+                }
             }
         };
         // Should be run after the local-borrowed task is returned.
@@ -749,7 +763,7 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
                 let join_task = join_task_cell.take();
 
                 let bootstrap_task = ~do Task::new_root(&mut new_sched.stack_pool) || {
-                    rtdebug!("boostraping a 1:1 scheduler");
+                    rtdebug!("bootstrapping a 1:1 scheduler");
                 };
                 new_sched.bootstrap(bootstrap_task);
 
@@ -793,7 +807,7 @@ fn spawn_raw_newsched(mut opts: TaskOpts, f: ~fn()) {
 fn spawn_raw_oldsched(mut opts: TaskOpts, f: ~fn()) {
 
     let (child_tg, ancestors, is_main) =
-        gen_child_taskgroup(opts.linked, opts.supervised);
+        gen_child_taskgroup(opts.linked, opts.supervised).expect("old runtime needs TG");
 
     unsafe {
         let child_data = Cell::new((child_tg, ancestors, f));

From d5de801cc1b4a3147dfd5a29a3d0e129ee0fe783 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 5 Aug 2013 09:25:20 -0700
Subject: [PATCH 16/29] Re-enable rusti tests

---
 src/librusti/rusti.rs | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/librusti/rusti.rs b/src/librusti/rusti.rs
index 568a691290c88..50a1eb5afdb3c 100644
--- a/src/librusti/rusti.rs
+++ b/src/librusti/rusti.rs
@@ -565,10 +565,7 @@ mod tests {
         }
     }
 
-    // FIXME: #7220 rusti on 32bit mac doesn't work.
-    // FIXME: #7641 rusti on 32bit linux cross compile doesn't work
-    // FIXME: #7115 re-enable once LLVM has been upgraded
-    #[cfg(thiswillneverbeacfgflag)]
+    #[cfg(not(target_word_size = "32"))]
     fn run_program(prog: &str) {
         let mut r = repl();
         for cmd in prog.split_iter('\n') {
@@ -577,6 +574,9 @@ mod tests {
                     "the command '%s' failed", cmd);
         }
     }
+    // FIXME: #7220 rusti on 32bit mac doesn't work
+    // FIXME: #7641 rusti on 32bit linux cross compile doesn't work
+    #[cfg(target_word_size = "32")]
     fn run_program(_: &str) {}
 
     #[test]
@@ -594,13 +594,12 @@ mod tests {
         run_program("let a = 3;");
     }
 
-    #[test] #[ignore]
+    #[test]
     fn new_tasks() {
-        // XXX: can't spawn new tasks because the JIT code is cleaned up
-        //      after the main function is done.
         run_program("
-            spawn( || println(\"Please don't segfault\") );
-            do spawn { println(\"Please?\"); }
+            use std::task::try;
+            try( || println(\"Please don't segfault\") );
+            do try { println(\"Please?\"); }
         ");
     }
 

From ce682cb45ff6f899d478358d7517fa83b215ac3c Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 19:40:20 +0200
Subject: [PATCH 17/29] std: Add .consume_iter() for Option, to make it
 reusable

Let Option be a base for a widely useful one- or zero- item iterator.
Refactor OptionIterator to support any generic element type, so the same
iterator impl can be used for both &T, &mut T and T iterators.
---
 src/libstd/option.rs | 42 +++++++++++++++---------------------------
 1 file changed, 15 insertions(+), 27 deletions(-)

diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 3a4a9220ee16c..40a3944b7e0a4 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -116,7 +116,7 @@ impl<T: ToStr> ToStr for Option<T> {
 impl<T> Option<T> {
     /// Return an iterator over the possibly contained value
     #[inline]
-    pub fn iter<'r>(&'r self) -> OptionIterator<'r, T> {
+    pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
         match *self {
             Some(ref x) => OptionIterator{opt: Some(x)},
             None => OptionIterator{opt: None}
@@ -125,13 +125,19 @@ impl<T> Option<T> {
 
     /// Return a mutable iterator over the possibly contained value
     #[inline]
-    pub fn mut_iter<'r>(&'r mut self) -> OptionMutIterator<'r, T> {
+    pub fn mut_iter<'r>(&'r mut self) -> OptionIterator<&'r mut T> {
         match *self {
-            Some(ref mut x) => OptionMutIterator{opt: Some(x)},
-            None => OptionMutIterator{opt: None}
+            Some(ref mut x) => OptionIterator{opt: Some(x)},
+            None => OptionIterator{opt: None}
         }
     }
 
+    /// Return a consuming iterator over the possibly contained value
+    #[inline]
+    pub fn consume_iter(self) -> OptionIterator<T> {
+        OptionIterator{opt: self}
+    }
+
     /// Returns true if the option equals `None`
     #[inline]
     pub fn is_none(&self) -> bool {
@@ -404,31 +410,13 @@ impl<T> Zero for Option<T> {
     fn is_zero(&self) -> bool { self.is_none() }
 }
 
-/// Immutable iterator over an `Option<A>`
-pub struct OptionIterator<'self, A> {
-    priv opt: Option<&'self A>
-}
-
-impl<'self, A> Iterator<&'self A> for OptionIterator<'self, A> {
-    fn next(&mut self) -> Option<&'self A> {
-        util::replace(&mut self.opt, None)
-    }
-
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        match self.opt {
-            Some(_) => (1, Some(1)),
-            None => (0, Some(0)),
-        }
-    }
-}
-
-/// Mutable iterator over an `Option<A>`
-pub struct OptionMutIterator<'self, A> {
-    priv opt: Option<&'self mut A>
+/// Immutable iterator over an Option
+pub struct OptionIterator<A> {
+    priv opt: Option<A>
 }
 
-impl<'self, A> Iterator<&'self mut A> for OptionMutIterator<'self, A> {
-    fn next(&mut self) -> Option<&'self mut A> {
+impl<A> Iterator<A> for OptionIterator<A> {
+    fn next(&mut self) -> Option<A> {
         util::replace(&mut self.opt, None)
     }
 

From 109e0d85a14f62e08b324feb89d6baa740e25319 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 19:40:20 +0200
Subject: [PATCH 18/29] std: Convert Result to use external iterators

convert iter() and iter_err() for Result. Use OptionIterator.
---
 src/libstd/result.rs | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 181590e3929c5..e06e58acbc8e8 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -16,7 +16,7 @@ use clone::Clone;
 use cmp::Eq;
 use either;
 use iterator::Iterator;
-use option::{None, Option, Some};
+use option::{None, Option, Some, OptionIterator};
 use vec;
 use vec::{OwnedVector, ImmutableVector};
 use container::Container;
@@ -86,15 +86,15 @@ impl<T, E: ToStr> Result<T, E> {
     ///
     /// Example:
     ///
-    ///     do read_file(file).iter |buf| {
+    ///     for buf in read_file(file) {
     ///         print_buf(buf)
     ///     }
     #[inline]
-    pub fn iter(&self, f: &fn(&T)) {
+    pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
         match *self {
-            Ok(ref t) => f(t),
-            Err(_) => (),
-        }
+            Ok(ref t) => Some(t),
+            Err(*) => None,
+        }.consume_iter()
     }
 
     /// Call a method based on a previous result
@@ -104,11 +104,11 @@ impl<T, E: ToStr> Result<T, E> {
     /// immediately returned.  This function can be used to pass through a
     /// successful result while handling an error.
     #[inline]
-    pub fn iter_err(&self, f: &fn(&E)) {
+    pub fn iter_err<'r>(&'r self) -> OptionIterator<&'r E> {
         match *self {
-            Ok(_) => (),
-            Err(ref e) => f(e),
-        }
+            Ok(*) => None,
+            Err(ref t) => Some(t),
+        }.consume_iter()
     }
 
     /// Unwraps a result, yielding the content of an `Ok`.
@@ -335,21 +335,25 @@ mod tests {
     #[test]
     pub fn test_impl_iter() {
         let mut valid = false;
-        Ok::<~str, ~str>(~"a").iter(|_x| valid = true);
+        let okval = Ok::<~str, ~str>(~"a");
+        do okval.iter().next().map |_| { valid = true; };
         assert!(valid);
 
-        Err::<~str, ~str>(~"b").iter(|_x| valid = false);
+        let errval = Err::<~str, ~str>(~"b");
+        do errval.iter().next().map |_| { valid = false; };
         assert!(valid);
     }
 
     #[test]
     pub fn test_impl_iter_err() {
         let mut valid = true;
-        Ok::<~str, ~str>(~"a").iter_err(|_x| valid = false);
+        let okval = Ok::<~str, ~str>(~"a");
+        do okval.iter_err().next().map |_| { valid = false };
         assert!(valid);
 
         valid = false;
-        Err::<~str, ~str>(~"b").iter_err(|_x| valid = true);
+        let errval = Err::<~str, ~str>(~"b");
+        do errval.iter_err().next().map |_| { valid = true };
         assert!(valid);
     }
 

From c5e4c55989f4e405e6c0d14347391172413d53d3 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 19:40:20 +0200
Subject: [PATCH 19/29] std: Remove unused trait bound in Result::map

---
 src/libstd/result.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index e06e58acbc8e8..5a6021d32a5e3 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -214,7 +214,7 @@ impl<T, E: Clone + ToStr> Result<T, E> {
     ///         parse_bytes(buf)
     ///     };
     #[inline]
-    pub fn map<U: Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
+    pub fn map<U>(&self, op: &fn(&T) -> U) -> Result<U,E> {
         match *self {
             Ok(ref t) => Ok(op(t)),
             Err(ref e) => Err(e.clone())

From 872d15d46440aa12014873dac0f19e325e169860 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 19:40:20 +0200
Subject: [PATCH 20/29] std: Implement RandomAccessIterator for Invert

---
 src/libstd/iterator.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index 0769aa6a76464..372afd7402d45 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -106,6 +106,16 @@ impl<A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Invert<T> {
     fn next_back(&mut self) -> Option<A> { self.iter.next() }
 }
 
+impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterator<A>
+    for Invert<T> {
+    #[inline]
+    fn indexable(&self) -> uint { self.iter.indexable() }
+    #[inline]
+    fn idx(&self, index: uint) -> Option<A> {
+        self.iter.idx(self.indexable() - index - 1)
+    }
+}
+
 /// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
 /// implementations of the `Iterator` trait.
 ///
@@ -2017,6 +2027,17 @@ mod tests {
         check_randacc_iter(xs.iter().enumerate(), xs.len());
     }
 
+    #[test]
+    fn test_random_access_invert() {
+        let xs = [1, 2, 3, 4, 5];
+        check_randacc_iter(xs.iter().invert(), xs.len());
+        let mut it = xs.iter().invert();
+        it.next();
+        it.next_back();
+        it.next();
+        check_randacc_iter(it, xs.len() - 3);
+    }
+
     #[test]
     fn test_random_access_zip() {
         let xs = [1, 2, 3, 4, 5];

From a05a9a1c02f50ffe8bfbddfeec093784f454c199 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 19:40:20 +0200
Subject: [PATCH 21/29] std: Improve vec::ChunkIter

Implement clone, bidirectionality and random access for this iterator
---
 src/libstd/vec.rs | 59 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 51 insertions(+), 8 deletions(-)

diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 4d4437cc963ea..fa1291c61e1be 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -479,6 +479,7 @@ pub fn each_permutation<T:Clone>(values: &[T], fun: &fn(perm : &[T]) -> bool) ->
 
 /// An iterator over the (overlapping) slices of length `size` within
 /// a vector.
+#[deriving(Clone)]
 pub struct WindowIter<'self, T> {
     priv v: &'self [T],
     priv size: uint
@@ -498,6 +499,10 @@ impl<'self, T> Iterator<&'self [T]> for WindowIter<'self, T> {
 
 /// An iterator over a vector in (non-overlapping) chunks (`size`
 /// elements at a time).
+///
+/// When the vector len is not evenly divided by the chunk size,
+/// the last slice of the iteration will be the remainer.
+#[deriving(Clone)]
 pub struct ChunkIter<'self, T> {
     priv v: &'self [T],
     priv size: uint
@@ -505,16 +510,46 @@ pub struct ChunkIter<'self, T> {
 
 impl<'self, T> Iterator<&'self [T]> for ChunkIter<'self, T> {
     fn next(&mut self) -> Option<&'self [T]> {
-        if self.size == 0 {
+        if self.v.len() == 0 {
             None
-        } else if self.size >= self.v.len() {
-            // finished
-            self.size = 0;
-            Some(self.v)
         } else {
-            let ret = Some(self.v.slice(0, self.size));
-            self.v = self.v.slice(self.size, self.v.len());
-            ret
+            let chunksz = cmp::min(self.v.len(), self.size);
+            let (fst, snd) = (self.v.slice_to(chunksz),
+                              self.v.slice_from(chunksz));
+            self.v = snd;
+            Some(fst)
+        }
+    }
+}
+
+impl<'self, T> DoubleEndedIterator<&'self [T]> for ChunkIter<'self, T> {
+    fn next_back(&mut self) -> Option<&'self [T]> {
+        if self.v.len() == 0 {
+            None
+        } else {
+            let remainder = self.v.len() % self.size;
+            let chunksz = if remainder != 0 { remainder } else { self.size };
+            let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
+                              self.v.slice_from(self.v.len() - chunksz));
+            self.v = fst;
+            Some(snd)
+        }
+    }
+}
+
+impl<'self, T> RandomAccessIterator<&'self [T]> for ChunkIter<'self, T> {
+    #[inline]
+    fn indexable(&self) -> uint {
+        self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
+    }
+
+    #[inline]
+    fn idx(&self, index: uint) -> Option<&'self [T]> {
+        if index < self.indexable() {
+            let lo = index * self.size;
+            Some(self.v.slice(lo, cmp::min(lo, self.v.len() - self.size) + self.size))
+        } else {
+            None
         }
     }
 }
@@ -3378,6 +3413,14 @@ mod tests {
         assert_eq!(v.chunk_iter(2).collect::<~[&[int]]>(), ~[&[1i,2], &[3,4], &[5]]);
         assert_eq!(v.chunk_iter(3).collect::<~[&[int]]>(), ~[&[1i,2,3], &[4,5]]);
         assert_eq!(v.chunk_iter(6).collect::<~[&[int]]>(), ~[&[1i,2,3,4,5]]);
+
+        assert_eq!(v.chunk_iter(2).invert().collect::<~[&[int]]>(), ~[&[5i], &[3,4], &[1,2]]);
+        let it = v.chunk_iter(2);
+        assert_eq!(it.indexable(), 3);
+        assert_eq!(it.idx(0).unwrap(), &[1,2]);
+        assert_eq!(it.idx(1).unwrap(), &[3,4]);
+        assert_eq!(it.idx(2).unwrap(), &[5]);
+        assert_eq!(it.idx(3), None);
     }
 
     #[test]

From 8046218f0f18b853df571d85ac4ace003c3905b9 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 21:34:00 +0200
Subject: [PATCH 22/29] std: Add iterator::Repeat to repeat an element
 endlessly

---
 src/libstd/iterator.rs | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index 372afd7402d45..bf55b4f7ce2e3 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -1565,6 +1565,39 @@ impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
     }
 }
 
+/// An iterator that repeats an element endlessly
+#[deriving(Clone, DeepClone)]
+pub struct Repeat<A> {
+    priv element: A
+}
+
+impl<A: Clone> Repeat<A> {
+    /// Create a new `Repeat` that enlessly repeats the element `elt`.
+    #[inline]
+    pub fn new(elt: A) -> Repeat<A> {
+        Repeat{element: elt}
+    }
+}
+
+impl<A: Clone> Iterator<A> for Repeat<A> {
+    #[inline]
+    fn next(&mut self) -> Option<A> { self.idx(0) }
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) { (uint::max_value, None) }
+}
+
+impl<A: Clone> DoubleEndedIterator<A> for Repeat<A> {
+    #[inline]
+    fn next_back(&mut self) -> Option<A> { self.idx(0) }
+}
+
+impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
+    #[inline]
+    fn indexable(&self) -> uint { uint::max_value }
+    #[inline]
+    fn idx(&self, _: uint) -> Option<A> { Some(self.element.clone()) }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From 78effe762666f64de28c890ea1a15672c712f390 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 21:34:00 +0200
Subject: [PATCH 23/29] std: Rewrite the HashSet set operation iterators

Use the Repeat iterator to carry the "explicit closure capture" that was
previously done with the custom EnvFilterIterator.
---
 src/libstd/hashmap.rs | 54 ++++++++++++++-----------------------------
 1 file changed, 17 insertions(+), 37 deletions(-)

diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index 658f854c50d81..fbc471c0ae05d 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -19,7 +19,8 @@ use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
 use clone::Clone;
 use cmp::{Eq, Equiv};
 use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, Chain, range};
+use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, range};
+use iterator::{FilterMap, Chain, Repeat, Zip};
 use num;
 use option::{None, Option, Some};
 use rand::RngUtil;
@@ -712,10 +713,12 @@ impl<T:Hash + Eq> HashSet<T> {
     }
 
     /// Visit the values representing the difference
-    pub fn difference_iter<'a>(&'a self, other: &'a HashSet<T>)
-        -> SetAlgebraIter<'a, T> {
-        EnvFilterIterator{iter: self.iter(), env: other,
-                          filter: |elt, other| !other.contains(elt) }
+    pub fn difference_iter<'a>(&'a self, other: &'a HashSet<T>) -> SetAlgebraIter<'a, T> {
+        Repeat::new(other)
+            .zip(self.iter())
+            .filter_map(|(other, elt)| {
+                if !other.contains(elt) { Some(elt) } else { None }
+            })
     }
 
     /// Visit the values representing the symmetric difference
@@ -727,8 +730,11 @@ impl<T:Hash + Eq> HashSet<T> {
     /// Visit the values representing the intersection
     pub fn intersection_iter<'a>(&'a self, other: &'a HashSet<T>)
         -> SetAlgebraIter<'a, T> {
-        EnvFilterIterator{iter: self.iter(), env: other,
-                          filter: |elt, other| other.contains(elt) }
+        Repeat::new(other)
+            .zip(self.iter())
+            .filter_map(|(other, elt)| {
+                if other.contains(elt) { Some(elt) } else { None }
+            })
     }
 
     /// Visit the values representing the union
@@ -756,38 +762,12 @@ impl<K: Eq + Hash, T: Iterator<K>> Extendable<K, T> for HashSet<K> {
     }
 }
 
-// FIXME #7814: use std::iterator::FilterIterator
-/// Building block for Set operation iterators
-pub struct EnvFilterIterator<A, Env, I> {
-    priv env: Env,
-    priv filter: &'static fn(&A, Env) -> bool,
-    priv iter: I,
-}
-
-impl<'self, A, Env: Clone, I: Iterator<&'self A>> Iterator<&'self A>
-        for EnvFilterIterator<A, Env, I> {
-    #[inline]
-    fn next(&mut self) -> Option<&'self A> {
-        loop {
-            match self.iter.next() {
-                Some(elt) => if (self.filter)(elt, self.env.clone()) {
-                    return Some(elt)
-                },
-                None => return None,
-            }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (_, upper) = self.iter.size_hint();
-        (0, upper)
-    }
-}
-
+// `Repeat` is used to feed the filter closure an explicit capture
+// of a reference to the other set
 /// Set operations iterator
 pub type SetAlgebraIter<'self, T> =
-    EnvFilterIterator<T, &'self HashSet<T>, HashSetIterator<'self, T>>;
+    FilterMap<'static,(&'self HashSet<T>, &'self T), &'self T,
+              Zip<Repeat<&'self HashSet<T>>,HashSetIterator<'self,T>>>;
 
 
 #[cfg(test)]

From 520f292e48a61538e681ce61d46a58f965c800a1 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 21:34:00 +0200
Subject: [PATCH 24/29] std: Use method name Option::consume

With Option as the simplest container, `consume` is the way to turn it
into a by-value iterator.
---
 src/libstd/option.rs | 8 +++++---
 src/libstd/result.rs | 4 ++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 40a3944b7e0a4..ea1bddcdb4b9d 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -134,7 +134,7 @@ impl<T> Option<T> {
 
     /// Return a consuming iterator over the possibly contained value
     #[inline]
-    pub fn consume_iter(self) -> OptionIterator<T> {
+    pub fn consume(self) -> OptionIterator<T> {
         OptionIterator{opt: self}
     }
 
@@ -410,16 +410,18 @@ impl<T> Zero for Option<T> {
     fn is_zero(&self) -> bool { self.is_none() }
 }
 
-/// Immutable iterator over an Option
+/// An iterator that yields either one or zero elements
 pub struct OptionIterator<A> {
     priv opt: Option<A>
 }
 
 impl<A> Iterator<A> for OptionIterator<A> {
+    #[inline]
     fn next(&mut self) -> Option<A> {
-        util::replace(&mut self.opt, None)
+        self.opt.take()
     }
 
+    #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
         match self.opt {
             Some(_) => (1, Some(1)),
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 5a6021d32a5e3..91f42edf0aecd 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -94,7 +94,7 @@ impl<T, E: ToStr> Result<T, E> {
         match *self {
             Ok(ref t) => Some(t),
             Err(*) => None,
-        }.consume_iter()
+        }.consume()
     }
 
     /// Call a method based on a previous result
@@ -108,7 +108,7 @@ impl<T, E: ToStr> Result<T, E> {
         match *self {
             Ok(*) => None,
             Err(ref t) => Some(t),
-        }.consume_iter()
+        }.consume()
     }
 
     /// Unwraps a result, yielding the content of an `Ok`.

From b5cd81d0e54fb2310ce0de6f746957501130ce5f Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sat, 3 Aug 2013 21:34:00 +0200
Subject: [PATCH 25/29] std: Improve the documentation for iterator::Invert

---
 src/libstd/iterator.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/libstd/iterator.rs b/src/libstd/iterator.rs
index bf55b4f7ce2e3..56a0dca56679c 100644
--- a/src/libstd/iterator.rs
+++ b/src/libstd/iterator.rs
@@ -82,6 +82,17 @@ pub trait DoubleEndedIteratorUtil {
 /// In the future these will be default methods instead of a utility trait.
 impl<A, T: DoubleEndedIterator<A>> DoubleEndedIteratorUtil for T {
     /// Flip the direction of the iterator
+    ///
+    /// The inverted iterator flips the ends on an iterator that can already
+    /// be iterated from the front and from the back.
+    ///
+    ///
+    /// If the iterator also implements RandomAccessIterator, the inverted
+    /// iterator is also random access, with the indices starting at the back
+    /// of the original iterator.
+    ///
+    /// Note: Random access with inverted indices still only applies to the first
+    /// `uint::max_value` elements of the original iterator.
     #[inline]
     fn invert(self) -> Invert<T> {
         Invert{iter: self}

From 08d0b70213df7e112409eeea85bcfcc630f5dda4 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sun, 4 Aug 2013 04:49:44 +0200
Subject: [PATCH 26/29] extra: Simplify the bitv iterators using Repeat

---
 src/libextra/bitv.rs | 63 +++++++++++++-------------------------------
 1 file changed, 19 insertions(+), 44 deletions(-)

diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
index bf618d7bd3a6f..f32170a3a6de6 100644
--- a/src/libextra/bitv.rs
+++ b/src/libextra/bitv.rs
@@ -13,7 +13,7 @@
 
 use std::cmp;
 use std::iterator::RandomAccessIterator;
-use std::iterator::{Invert, Enumerate};
+use std::iterator::{Invert, Enumerate, Repeat, Map, Zip};
 use std::num;
 use std::ops;
 use std::uint;
@@ -864,13 +864,12 @@ impl BitvSet {
     /// w1, w2) where the bit location is the number of bits offset so far,
     /// and w1/w2 are the words coming from the two vectors self, other.
     fn common_iter<'a>(&'a self, other: &'a BitvSet)
-        -> MapE<(uint,&uint),(uint,uint,uint), &'a ~[uint],Enumerate<vec::VecIterator<'a,uint>>> {
-        let min = num::min(self.bitv.storage.len(),
-                            other.bitv.storage.len());
-        MapE{iter: self.bitv.storage.slice(0, min).iter().enumerate(),
-             env: &other.bitv.storage,
-             f: |(i, &w): (uint, &uint), o_store| (i * uint::bits, w, o_store[i])
-        }
+        -> Map<'static, ((uint, &'a uint), &'a ~[uint]), (uint, uint, uint),
+               Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<&'a ~[uint]>>> {
+        let min = num::min(self.bitv.storage.len(), other.bitv.storage.len());
+        self.bitv.storage.slice(0, min).iter().enumerate()
+            .zip(Repeat::new(&other.bitv.storage))
+            .transform(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
     }
 
     /// Visits each word in self or other that extends beyond the other. This
@@ -881,45 +880,21 @@ impl BitvSet {
     /// is true if the word comes from 'self', and false if it comes from
     /// 'other'.
     fn outlier_iter<'a>(&'a self, other: &'a BitvSet)
-        -> MapE<(uint, &uint),(bool, uint, uint), uint, Enumerate<vec::VecIterator<'a, uint>>> {
-        let len1 = self.bitv.storage.len();
-        let len2 = other.bitv.storage.len();
-        let min = num::min(len1, len2);
-
-        if min < len1 {
-            MapE{iter: self.bitv.storage.slice(min, len1).iter().enumerate(),
-                 env: min,
-                 f: |(i, &w): (uint, &uint), min| (true, (i + min) * uint::bits, w)
-            }
+        -> Map<'static, ((uint, &'a uint), uint), (bool, uint, uint),
+               Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<uint>>> {
+        let slen = self.bitv.storage.len();
+        let olen = other.bitv.storage.len();
+
+        if olen < slen {
+            self.bitv.storage.slice_from(olen).iter().enumerate()
+                .zip(Repeat::new(olen))
+                .transform(|((i, &w), min)| (true, (i + min) * uint::bits, w))
         } else {
-            MapE{iter: other.bitv.storage.slice(min, len2).iter().enumerate(),
-                 env: min,
-                 f: |(i, &w): (uint, &uint), min| (false, (i + min) * uint::bits, w)
-            }
-        }
-    }
-}
-
-/// Like iterator::Map with explicit env capture
-struct MapE<A, B, Env, I> {
-    priv env: Env,
-    priv f: &'static fn(A, Env) -> B,
-    priv iter: I,
-}
-
-impl<'self, A, B, Env: Clone, I: Iterator<A>> Iterator<B> for MapE<A, B, Env, I> {
-    #[inline]
-    fn next(&mut self) -> Option<B> {
-        match self.iter.next() {
-            Some(elt) => Some((self.f)(elt, self.env.clone())),
-            None => None
+            other.bitv.storage.slice_from(slen).iter().enumerate()
+                .zip(Repeat::new(slen))
+                .transform(|((i, &w), min)| (false, (i + min) * uint::bits, w))
         }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        self.iter.size_hint()
-    }
 }
 
 pub struct BitvSetIterator<'self> {

From ea9c5c405ecea256721c6d65b7de21bffe21056b Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sun, 4 Aug 2013 17:10:09 +0200
Subject: [PATCH 27/29] std: Remove uint::iterate, replaced by `range`

---
 src/libextra/bitv.rs   |  7 +++----
 src/libstd/num/uint.rs | 24 ------------------------
 src/libstd/ptr.rs      |  7 +++----
 3 files changed, 6 insertions(+), 32 deletions(-)

diff --git a/src/libextra/bitv.rs b/src/libextra/bitv.rs
index f32170a3a6de6..6dedd9ee4dd26 100644
--- a/src/libextra/bitv.rs
+++ b/src/libextra/bitv.rs
@@ -206,14 +206,13 @@ impl BigBitv {
     #[inline]
     pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
         let len = b.storage.len();
-        do uint::iterate(0, len) |i| {
+        for i in range(0, len) {
             let mask = big_mask(nbits, i);
             if mask & self.storage[i] != mask & b.storage[i] {
-                false
-            } else {
-                true
+                return false;
             }
         }
+        true
     }
 }
 
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 275a72d6ecc05..86bc98e53fcb6 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -70,30 +70,6 @@ pub fn div_round(x: uint, y: uint) -> uint {
 ///
 pub fn div_floor(x: uint, y: uint) -> uint { return x / y; }
 
-///
-/// Iterate over the range [`lo`..`hi`), or stop when requested
-///
-/// # Arguments
-///
-/// * lo - The integer at which to start the loop (included)
-/// * hi - The integer at which to stop the loop (excluded)
-/// * it - A block to execute with each consecutive integer of the range.
-///        Return `true` to continue, `false` to stop.
-///
-/// # Return value
-///
-/// `true` If execution proceeded correctly, `false` if it was interrupted,
-/// that is if `it` returned `false` at any point.
-///
-pub fn iterate(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
-    let mut i = lo;
-    while i < hi {
-        if (!it(i)) { return false; }
-        i += 1u;
-    }
-    return true;
-}
-
 impl iter::Times for uint {
     #[inline]
     ///
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 55c18faf83dee..dfd11f9227d41 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -12,6 +12,7 @@
 
 use cast;
 use clone::Clone;
+use iterator::{range, Iterator};
 use option::{Option, Some, None};
 use unstable::intrinsics;
 use util::swap;
@@ -20,7 +21,6 @@ use util::swap;
 #[cfg(not(test))] use num::Int;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
-use uint;
 
 /// Calculate the offset from a pointer
 #[inline]
@@ -240,11 +240,10 @@ pub unsafe fn array_each_with_len<T>(arr: **T, len: uint, cb: &fn(*T)) {
         fail!("ptr::array_each_with_len failure: arr input is null pointer");
     }
     //let start_ptr = *arr;
-    uint::iterate(0, len, |e| {
+    for e in range(0, len) {
         let n = offset(arr, e as int);
         cb(*n);
-        true
-    });
+    }
     debug!("array_each_with_len: after iterate");
 }
 

From 45085b9f8dc70f3b24eb9317b2d6bb2911ffb0a6 Mon Sep 17 00:00:00 2001
From: blake2-ppc <blake2-ppc>
Date: Sun, 4 Aug 2013 22:46:26 +0200
Subject: [PATCH 28/29] std: Fix bug in ChunkIter::idx

ChunkIter .idx() didn't handle overflow correctly, even though it tried.
---
 src/libstd/vec.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index fa1291c61e1be..0259b547ab3f0 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -547,7 +547,10 @@ impl<'self, T> RandomAccessIterator<&'self [T]> for ChunkIter<'self, T> {
     fn idx(&self, index: uint) -> Option<&'self [T]> {
         if index < self.indexable() {
             let lo = index * self.size;
-            Some(self.v.slice(lo, cmp::min(lo, self.v.len() - self.size) + self.size))
+            let mut hi = lo + self.size;
+            if hi < lo || hi > self.v.len() { hi = self.v.len(); }
+
+            Some(self.v.slice(lo, hi))
         } else {
             None
         }

From a76943be47cfa3931c09a79cd741c383d8b76a5b Mon Sep 17 00:00:00 2001
From: Sangeun Kim <sammy.kim@samsung.com>
Date: Fri, 26 Jul 2013 13:53:29 +0900
Subject: [PATCH 29/29] Move EnumSet into libextra

---
 src/{librustc/util => libextra}/enum_set.rs | 62 ++++++---------------
 src/libextra/extra.rs                       |  1 +
 src/librustc/metadata/tyencode.rs           |  5 +-
 src/librustc/middle/kind.rs                 |  5 +-
 src/librustc/middle/ty.rs                   | 12 ++--
 src/librustc/rustc.rs                       |  1 -
 src/librustc/util/ppaux.rs                  | 10 ++--
 7 files changed, 30 insertions(+), 66 deletions(-)
 rename src/{librustc/util => libextra}/enum_set.rs (86%)

diff --git a/src/librustc/util/enum_set.rs b/src/libextra/enum_set.rs
similarity index 86%
rename from src/librustc/util/enum_set.rs
rename to src/libextra/enum_set.rs
index ced29f18f7f11..25501faa02e12 100644
--- a/src/librustc/util/enum_set.rs
+++ b/src/libextra/enum_set.rs
@@ -11,14 +11,18 @@
 use std::iterator::Iterator;
 
 #[deriving(Clone, Eq, IterBytes, ToStr)]
+/// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set
     // for which no variant exists
     priv bits: uint
 }
 
+/// An iterface for casting C-like enum to uint and back.
 pub trait CLike {
+    /// Converts C-like enum to uint.
     pub fn to_uint(&self) -> uint;
+    /// Converts uint to C-like enum.
     pub fn from_uint(uint) -> Self;
 }
 
@@ -27,54 +31,47 @@ fn bit<E:CLike>(e: E) -> uint {
 }
 
 impl<E:CLike> EnumSet<E> {
+    /// Returns an empty EnumSet.
     pub fn empty() -> EnumSet<E> {
         EnumSet {bits: 0}
     }
 
+    /// Returns true if an EnumSet is empty.
     pub fn is_empty(&self) -> bool {
         self.bits == 0
     }
 
+    /// Returns true if an EnumSet contains any enum of a given EnumSet
     pub fn intersects(&self, e: EnumSet<E>) -> bool {
         (self.bits & e.bits) != 0
     }
 
+    /// Returns an intersection of both EnumSets.
     pub fn intersection(&self, e: EnumSet<E>) -> EnumSet<E> {
         EnumSet {bits: self.bits & e.bits}
     }
 
+    /// Returns true if a given EnumSet is included in an EnumSet.
     pub fn contains(&self, e: EnumSet<E>) -> bool {
         (self.bits & e.bits) == e.bits
     }
 
+    /// Returns a union of both EnumSets.
     pub fn union(&self, e: EnumSet<E>) -> EnumSet<E> {
         EnumSet {bits: self.bits | e.bits}
     }
 
+    /// Add an enum to an EnumSet
     pub fn add(&mut self, e: E) {
         self.bits |= bit(e);
     }
 
+    /// Returns true if an EnumSet contains a given enum
     pub fn contains_elem(&self, e: E) -> bool {
         (self.bits & bit(e)) != 0
     }
 
-    pub fn each(&self, f: &fn(E) -> bool) -> bool {
-        let mut bits = self.bits;
-        let mut index = 0;
-        while bits != 0 {
-            if (bits & 1) != 0 {
-                let e = CLike::from_uint(index);
-                if !f(e) {
-                    return false;
-                }
-            }
-            index += 1;
-            bits >>= 1;
-        }
-        return true;
-    }
-
+    /// Returns an iterator over an EnumSet
     pub fn iter(&self) -> EnumSetIterator<E> {
         EnumSetIterator::new(self.bits)
     }
@@ -98,6 +95,7 @@ impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
     }
 }
 
+/// An iterator over an EnumSet
 pub struct EnumSetIterator<E> {
     priv index: uint,
     priv bits: uint,
@@ -136,7 +134,7 @@ mod test {
 
     use std::cast;
 
-    use util::enum_set::*;
+    use enum_set::*;
 
     #[deriving(Eq)]
     enum Foo {
@@ -236,7 +234,7 @@ mod test {
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    // iter / each
+    // iter
 
     #[test]
     fn test_iterator() {
@@ -262,34 +260,6 @@ mod test {
         assert_eq!(~[A,B,C], elems)
     }
 
-    #[test]
-    fn test_each() {
-        let mut e1: EnumSet<Foo> = EnumSet::empty();
-
-        assert_eq!(~[], collect(e1))
-
-        e1.add(A);
-        assert_eq!(~[A], collect(e1))
-
-        e1.add(C);
-        assert_eq!(~[A,C], collect(e1))
-
-        e1.add(C);
-        assert_eq!(~[A,C], collect(e1))
-
-        e1.add(B);
-        assert_eq!(~[A,B,C], collect(e1))
-    }
-
-    fn collect(e: EnumSet<Foo>) -> ~[Foo] {
-        let mut elems = ~[];
-        e.each(|elem| {
-           elems.push(elem);
-           true
-        });
-        elems
-    }
-
     ///////////////////////////////////////////////////////////////////////////
     // operators
 
diff --git a/src/libextra/extra.rs b/src/libextra/extra.rs
index e6134bb340cd8..58929778a59e2 100644
--- a/src/libextra/extra.rs
+++ b/src/libextra/extra.rs
@@ -91,6 +91,7 @@ pub mod par;
 pub mod base64;
 pub mod rl;
 pub mod workcache;
+pub mod enum_set;
 #[path="num/bigint.rs"]
 pub mod bigint;
 #[path="num/rational.rs"]
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
index ec50f564385c3..ffd79433b7693 100644
--- a/src/librustc/metadata/tyencode.rs
+++ b/src/librustc/metadata/tyencode.rs
@@ -413,15 +413,14 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
 }
 
 fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
-    do bs.builtin_bounds.each |bound| {
+    for bound in bs.builtin_bounds.iter() {
         match bound {
             ty::BoundSend => w.write_char('S'),
             ty::BoundFreeze => w.write_char('K'),
             ty::BoundStatic => w.write_char('O'),
             ty::BoundSized => w.write_char('Z'),
         }
-        true
-    };
+    }
 
     for &tp in bs.trait_bounds.iter() {
         w.write_char('I');
diff --git a/src/librustc/middle/kind.rs b/src/librustc/middle/kind.rs
index 3bdf0c0f6dcb8..84eb371d7b34a 100644
--- a/src/librustc/middle/kind.rs
+++ b/src/librustc/middle/kind.rs
@@ -338,12 +338,11 @@ pub fn check_builtin_bounds(cx: Context, ty: ty::t, bounds: ty::BuiltinBounds,
 {
     let kind = ty::type_contents(cx.tcx, ty);
     let mut missing = ty::EmptyBuiltinBounds();
-    do bounds.each |bound| {
+    for bound in bounds.iter() {
         if !kind.meets_bound(cx.tcx, bound) {
             missing.add(bound);
         }
-        true
-    };
+    }
     if !missing.is_empty() {
         any_missing(missing);
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 48a003ddaf157..a53bdff85f9dc 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -25,7 +25,6 @@ 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};
-use util::enum_set::{EnumSet, CLike};
 
 use std::cast;
 use std::cmp;
@@ -48,6 +47,7 @@ use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
 use syntax::abi::AbiSet;
 use syntax;
+use extra::enum_set::{EnumSet, CLike};
 
 pub static INITIAL_DISCRIMINANT_VALUE: uint = 0;
 
@@ -2287,7 +2287,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
         // This is like with typarams below, but less "pessimistic" and also
         // dependent on the trait store.
         let mut bt = TC_NONE;
-        do (AllBuiltinBounds() - bounds).each |bound| {
+        for bound in (AllBuiltinBounds() - bounds).iter() {
             bt = bt + match bound {
                 BoundStatic if bounds.contains_elem(BoundSend)
                             => TC_NONE, // Send bound implies static bound.
@@ -2296,8 +2296,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
                 BoundFreeze => TC_MUTABLE,
                 BoundSized  => TC_NONE, // don't care if interior is sized
             };
-            true
-        };
+        }
         st + mt + bt
     }
 
@@ -2308,7 +2307,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
         let _i = indenter();
 
         let mut tc = TC_ALL;
-        do type_param_def.bounds.builtin_bounds.each |bound| {
+        for bound in type_param_def.bounds.builtin_bounds.iter() {
             debug!("tc = %s, bound = %?", tc.to_str(), bound);
             tc = tc - match bound {
                 BoundStatic => TypeContents::nonstatic(cx),
@@ -2317,8 +2316,7 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
                 // The dynamic-size bit can be removed at pointer-level, etc.
                 BoundSized => TypeContents::dynamically_sized(cx),
             };
-            true
-        };
+        }
 
         debug!("result = %s", tc.to_str());
         return tc;
diff --git a/src/librustc/rustc.rs b/src/librustc/rustc.rs
index c48b30e814164..46414a7a5e23e 100644
--- a/src/librustc/rustc.rs
+++ b/src/librustc/rustc.rs
@@ -96,7 +96,6 @@ pub mod driver;
 pub mod util {
     pub mod common;
     pub mod ppaux;
-    pub mod enum_set;
 }
 
 pub mod lib {
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 8f0dd51457074..8329ad2cdf1de 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -589,15 +589,14 @@ impl Repr for ty::RegionSubsts {
 impl Repr for ty::ParamBounds {
     fn repr(&self, tcx: ctxt) -> ~str {
         let mut res = ~[];
-        do self.builtin_bounds.each |b| {
+        for b in self.builtin_bounds.iter() {
             res.push(match b {
                 ty::BoundStatic => ~"'static",
                 ty::BoundSend => ~"Send",
                 ty::BoundFreeze => ~"Freeze",
                 ty::BoundSized => ~"Sized",
             });
-            true
-        };
+        }
         for t in self.trait_bounds.iter() {
             res.push(t.repr(tcx));
         }
@@ -833,10 +832,9 @@ impl UserString for ty::BuiltinBounds {
     fn user_string(&self, tcx: ctxt) -> ~str {
         if self.is_empty() { ~"<no-bounds>" } else {
             let mut result = ~[];
-            do self.each |bb| {
+            for bb in self.iter() {
                 result.push(bb.user_string(tcx));
-                true
-            };
+            }
             result.connect("+")
         }
     }