diff --git a/doc/tutorial.md b/doc/tutorial.md
index 98ec9d1f58037..f940876187788 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -1126,7 +1126,7 @@ points to.
 
 ~~~
 let managed = @mut 10;
-let owned = ~mut 20;
+let mut owned = ~20;
 
 let mut value = 30;
 let borrowed = &mut value;
diff --git a/src/libcore/at_vec.rs b/src/libcore/at_vec.rs
index 57bd8a97b5db9..ab604d1f0b6fe 100644
--- a/src/libcore/at_vec.rs
+++ b/src/libcore/at_vec.rs
@@ -168,7 +168,7 @@ pub mod traits {
     use kinds::Copy;
     use ops::Add;
 
-    pub impl<T:Copy> Add<&[const T],@[T]> for @[T] {
+    impl<T:Copy> Add<&[const T],@[T]> for @[T] {
         #[inline(always)]
         pure fn add(&self, rhs: & &self/[const T]) -> @[T] {
             append(*self, (*rhs))
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index 7651b737bf34e..9f2036c5f41a6 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -133,18 +133,6 @@ impl<A> DVec<A> {
         self.check_out(|v| self.give_back(f(v)))
     }
 
-    /**
-     * Swaps out the current vector and hands it off to a user-provided
-     * function `f`.  The function should transform it however is desired
-     * and return a new vector to replace it with.
-     */
-    #[inline(always)]
-    fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
-        do self.swap |v| {
-            vec::cast_from_mut(f(vec::cast_to_mut(v)))
-        }
-    }
-
     /// Returns the number of elements currently in the dvec
     #[inline(always)]
     pure fn len() -> uint {
@@ -217,7 +205,7 @@ impl<A> DVec<A> {
     }
 
     /// Gives access to the vector as a slice with mutable contents
-    fn borrow_mut<R>(op: fn(x: &[mut A]) -> R) -> R {
+    fn borrow_mut<R>(op: &fn(x: &mut [A]) -> R) -> R {
         do self.check_out |v| {
             let mut v = v;
             let result = op(v);
diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index d5407daca80d0..c4f2704ab9f6e 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -284,7 +284,7 @@ impl num::One for f32 {
     static pure fn one() -> f32 { 1.0 }
 }
 
-pub impl NumCast for f32 {
+impl NumCast for f32 {
     /**
      * Cast `n` to an `f32`
      */
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index 4e4e7c68646f2..8f3771312e4d6 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -299,7 +299,7 @@ impl cmp::Ord for f64 {
     pure fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
 }
 
-pub impl NumCast for f64 {
+impl NumCast for f64 {
     /**
      * Cast `n` to an `f64`
      */
diff --git a/src/libcore/num/float.rs b/src/libcore/num/float.rs
index b857f76570ff5..1b79ec614d49b 100644
--- a/src/libcore/num/float.rs
+++ b/src/libcore/num/float.rs
@@ -420,7 +420,7 @@ impl num::One for float {
     static pure fn one() -> float { 1.0 }
 }
 
-pub impl NumCast for float {
+impl NumCast for float {
     /**
      * Cast `n` to a `float`
      */
diff --git a/src/libcore/num/int-template/i16.rs b/src/libcore/num/int-template/i16.rs
index 1352959306a03..a3def10bda8a5 100644
--- a/src/libcore/num/int-template/i16.rs
+++ b/src/libcore/num/int-template/i16.rs
@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u16::bits;
 }
 
-pub impl NumCast for i16 {
+impl NumCast for i16 {
     /**
      * Cast `n` to a `i16`
      */
diff --git a/src/libcore/num/int-template/i32.rs b/src/libcore/num/int-template/i32.rs
index e8dd603d50753..eccd1f6ce3c8a 100644
--- a/src/libcore/num/int-template/i32.rs
+++ b/src/libcore/num/int-template/i32.rs
@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u32::bits;
 }
 
-pub impl NumCast for i32 {
+impl NumCast for i32 {
     /**
      * Cast `n` to a `i32`
      */
diff --git a/src/libcore/num/int-template/i64.rs b/src/libcore/num/int-template/i64.rs
index 6f1371f8ee221..05d529cbcf46a 100644
--- a/src/libcore/num/int-template/i64.rs
+++ b/src/libcore/num/int-template/i64.rs
@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u64::bits;
 }
 
-pub impl NumCast for i64 {
+impl NumCast for i64 {
     /**
      * Cast `n` to a `i64`
      */
diff --git a/src/libcore/num/int-template/i8.rs b/src/libcore/num/int-template/i8.rs
index 46c734b95483e..d8819d4fed0f9 100644
--- a/src/libcore/num/int-template/i8.rs
+++ b/src/libcore/num/int-template/i8.rs
@@ -17,7 +17,7 @@ mod inst {
     pub const bits: uint = ::u8::bits;
 }
 
-pub impl NumCast for i8 {
+impl NumCast for i8 {
     /**
      * Cast `n` to a `i8`
      */
diff --git a/src/libcore/num/int-template/int.rs b/src/libcore/num/int-template/int.rs
index 83ef421b70578..7e376a47b8966 100644
--- a/src/libcore/num/int-template/int.rs
+++ b/src/libcore/num/int-template/int.rs
@@ -58,7 +58,7 @@ mod inst {
     }
 }
 
-pub impl NumCast for int {
+impl NumCast for int {
     /**
      * Cast `n` to a `int`
      */
diff --git a/src/libcore/num/uint-template/u16.rs b/src/libcore/num/uint-template/u16.rs
index 315ff84cc234c..01ec0cc77bf91 100644
--- a/src/libcore/num/uint-template/u16.rs
+++ b/src/libcore/num/uint-template/u16.rs
@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 16;
 }
 
-pub impl NumCast for u16 {
+impl NumCast for u16 {
     /**
      * Cast `n` to a `u16`
      */
diff --git a/src/libcore/num/uint-template/u32.rs b/src/libcore/num/uint-template/u32.rs
index 834feff292c59..772ef51d30d4a 100644
--- a/src/libcore/num/uint-template/u32.rs
+++ b/src/libcore/num/uint-template/u32.rs
@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 32;
 }
 
-pub impl NumCast for u32 {
+impl NumCast for u32 {
     /**
      * Cast `n` to a `u32`
      */
diff --git a/src/libcore/num/uint-template/u64.rs b/src/libcore/num/uint-template/u64.rs
index b661b3b20b1cd..ec7301a01e486 100644
--- a/src/libcore/num/uint-template/u64.rs
+++ b/src/libcore/num/uint-template/u64.rs
@@ -19,7 +19,7 @@ mod inst {
     pub const bits: uint = 64;
 }
 
-pub impl NumCast for u64 {
+impl NumCast for u64 {
     /**
      * Cast `n` to a `u64`
      */
diff --git a/src/libcore/num/uint-template/u8.rs b/src/libcore/num/uint-template/u8.rs
index c2be9e252d9a1..53e4be70727bf 100644
--- a/src/libcore/num/uint-template/u8.rs
+++ b/src/libcore/num/uint-template/u8.rs
@@ -26,7 +26,7 @@ mod inst {
     pub pure fn is_ascii(x: T) -> bool { return 0 as T == x & 128 as T; }
 }
 
-pub impl NumCast for u8 {
+impl NumCast for u8 {
     /**
      * Cast `n` to a `u8`
      */
diff --git a/src/libcore/num/uint-template/uint.rs b/src/libcore/num/uint-template/uint.rs
index 475ae243915d9..e2a75b25eaeb6 100644
--- a/src/libcore/num/uint-template/uint.rs
+++ b/src/libcore/num/uint-template/uint.rs
@@ -110,7 +110,7 @@ pub mod inst {
         return true;
     }
 
-    pub impl iter::Times for uint {
+    impl iter::Times for uint {
         #[inline(always)]
         /**
         * A convenience form for basic iteration. Given a uint `x`,
@@ -209,7 +209,7 @@ pub mod inst {
     }
 }
 
-pub impl NumCast for uint {
+impl NumCast for uint {
     /**
      * Cast `n` to a `uint`
      */
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index e27b7086bc45b..1c2df949a2e9c 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -56,7 +56,7 @@ pub enum Option<T> {
     Some(T),
 }
 
-pub impl<T:Ord> Ord for Option<T> {
+impl<T:Ord> Ord for Option<T> {
     pure fn lt(&self, other: &Option<T>) -> bool {
         match (self, other) {
             (&None, &None) => false,
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 9cd5e8f4965d2..2522e9c2cda5a 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -109,7 +109,7 @@ pub mod win32 {
             let mut done = false;
             while !done {
                 let mut k: DWORD = 0;
-                let buf = vec::cast_to_mut(vec::from_elem(n as uint, 0u16));
+                let mut buf = vec::from_elem(n as uint, 0u16);
                 do vec::as_mut_buf(buf) |b, _sz| {
                     k = f(b, TMPBUF_SZ as DWORD);
                     if k == (0 as DWORD) {
diff --git a/src/libcore/owned.rs b/src/libcore/owned.rs
index 230386655e08e..3b839e5a9e008 100644
--- a/src/libcore/owned.rs
+++ b/src/libcore/owned.rs
@@ -13,22 +13,22 @@
 use cmp::{Eq, Ord};
 
 #[cfg(notest)]
-impl<T:Eq> Eq for ~const T {
+impl<T:Eq> Eq for ~T {
     #[inline(always)]
-    pure fn eq(&self, other: &~const T) -> bool { *(*self) == *(*other) }
+    pure fn eq(&self, other: &~T) -> bool { *(*self) == *(*other) }
     #[inline(always)]
-    pure fn ne(&self, other: &~const T) -> bool { *(*self) != *(*other) }
+    pure fn ne(&self, other: &~T) -> bool { *(*self) != *(*other) }
 }
 
 #[cfg(notest)]
-impl<T:Ord> Ord for ~const T {
+impl<T:Ord> Ord for ~T {
     #[inline(always)]
-    pure fn lt(&self, other: &~const T) -> bool { *(*self) < *(*other) }
+    pure fn lt(&self, other: &~T) -> bool { *(*self) < *(*other) }
     #[inline(always)]
-    pure fn le(&self, other: &~const T) -> bool { *(*self) <= *(*other) }
+    pure fn le(&self, other: &~T) -> bool { *(*self) <= *(*other) }
     #[inline(always)]
-    pure fn ge(&self, other: &~const T) -> bool { *(*self) >= *(*other) }
+    pure fn ge(&self, other: &~T) -> bool { *(*self) >= *(*other) }
     #[inline(always)]
-    pure fn gt(&self, other: &~const T) -> bool { *(*self) > *(*other) }
+    pure fn gt(&self, other: &~T) -> bool { *(*self) > *(*other) }
 }
 
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 92e980e34d08f..66be548181956 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -2362,7 +2362,7 @@ pub trait OwnedStr {
     fn push_char(&mut self, c: char);
 }
 
-pub impl OwnedStr for ~str {
+impl OwnedStr for ~str {
     fn push_str(&mut self, v: &str) {
         push_str(self, v);
     }
diff --git a/src/libcore/to_bytes.rs b/src/libcore/to_bytes.rs
index 4b2cd3c2fab5b..1f0f3b0779cbe 100644
--- a/src/libcore/to_bytes.rs
+++ b/src/libcore/to_bytes.rs
@@ -170,7 +170,7 @@ impl IterBytes for char {
 pub mod x32 {
     use to_bytes::{Cb, IterBytes};
 
-    pub impl IterBytes for uint {
+    impl IterBytes for uint {
         #[inline(always)]
         pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
             (*self as u32).iter_bytes(lsb0, f)
@@ -182,7 +182,7 @@ pub mod x32 {
 pub mod x64 {
     use to_bytes::{Cb, IterBytes};
 
-    pub impl IterBytes for uint {
+    impl IterBytes for uint {
         #[inline(always)]
         pure fn iter_bytes(&self, lsb0: bool, f: Cb) {
             (*self as u64).iter_bytes(lsb0, f)
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 31c837e7e8a3a..687ad2f79387d 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -209,16 +209,6 @@ pub pure fn build_sized_opt<A>(size: Option<uint>,
     build_sized(size.get_or_default(4), builder)
 }
 
-/// Produces a mut vector from an immutable vector.
-pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[mut T] {
-    unsafe { ::cast::transmute(v) }
-}
-
-/// Produces an immutable vector from a mut vector.
-pub pure fn cast_from_mut<T>(v: ~[mut T]) -> ~[T] {
-    unsafe { ::cast::transmute(v) }
-}
-
 // Accessors
 
 /// Returns the first element of a vector
@@ -274,9 +264,10 @@ pub pure fn slice<T>(v: &r/[T], start: uint, end: uint) -> &r/[T] {
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub pure fn mut_slice<T>(v: &r/[mut T], start: uint,
-                         end: uint) -> &r/[mut T] {
-
+pub pure fn mut_slice<T>(v: &r/mut [T],
+                         start: uint,
+                         end: uint)
+                      -> &r/mut [T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_mut_buf(v) |p, _len| {
@@ -290,8 +281,10 @@ pub pure fn mut_slice<T>(v: &r/[mut T], start: uint,
 
 /// Return a slice that points into another slice.
 #[inline(always)]
-pub pure fn const_slice<T>(v: &r/[const T], start: uint,
-                      end: uint) -> &r/[const T] {
+pub pure fn const_slice<T>(v: &r/[const T],
+                           start: uint,
+                           end: uint)
+                        -> &r/[const T] {
     assert (start <= end);
     assert (end <= len(v));
     do as_const_buf(v) |p, _len| {
@@ -3337,28 +3330,6 @@ mod tests {
         let _x = windowed (0u, ~[1u,2u,3u,4u,5u,6u]);
     }
 
-    #[test]
-    fn cast_to_mut_no_copy() {
-        unsafe {
-            let x = ~[1, 2, 3];
-            let addr = raw::to_ptr(x);
-            let x_mut = cast_to_mut(x);
-            let addr_mut = raw::to_ptr(x_mut);
-            assert addr == addr_mut;
-        }
-    }
-
-    #[test]
-    fn cast_from_mut_no_copy() {
-        unsafe {
-            let x = ~[mut 1, 2, 3];
-            let addr = raw::to_ptr(x);
-            let x_imm = cast_from_mut(x);
-            let addr_imm = raw::to_ptr(x_imm);
-            assert addr == addr_imm;
-        }
-    }
-
     #[test]
     fn test_unshift() {
         let mut x = ~[1, 2, 3];
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index 568bc5b5e70f6..eb2a93d86f9a4 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -451,7 +451,7 @@ impl LoanKind {
 
 /// Creates and returns a new root_map
 
-pub impl to_bytes::IterBytes for root_map_key {
+impl to_bytes::IterBytes for root_map_key {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);
     }
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index f027ca99d514f..3f8ee61e8412d 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -281,12 +281,12 @@ pub trait ast_node {
     fn span(&self) -> span;
 }
 
-pub impl ast_node for @ast::expr {
+impl ast_node for @ast::expr {
     fn id(&self) -> ast::node_id { self.id }
     fn span(&self) -> span { self.span }
 }
 
-pub impl ast_node for @ast::pat {
+impl ast_node for @ast::pat {
     fn id(&self) -> ast::node_id { self.id }
     fn span(&self) -> span { self.span }
 }
@@ -295,7 +295,7 @@ pub trait get_type_for_node {
     fn ty<N:ast_node>(&self, node: N) -> ty::t;
 }
 
-pub impl get_type_for_node for ty::ctxt {
+impl get_type_for_node for ty::ctxt {
     fn ty<N:ast_node>(&self, node: N) -> ty::t {
         ty::node_id_to_type(*self, node.id())
     }
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 53555dc9ff855..740a7e043d4dd 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -107,7 +107,7 @@ pub trait get_insn_ctxt {
     fn insn_ctxt(&self, s: &str) -> icx_popper;
 }
 
-pub impl get_insn_ctxt for @CrateContext {
+impl get_insn_ctxt for @CrateContext {
     fn insn_ctxt(&self, s: &str) -> icx_popper {
         debug!("new insn_ctxt: %s", s);
         if self.sess.count_llvm_insns() {
@@ -117,13 +117,13 @@ pub impl get_insn_ctxt for @CrateContext {
     }
 }
 
-pub impl get_insn_ctxt for block {
+impl get_insn_ctxt for block {
     fn insn_ctxt(&self, s: &str) -> icx_popper {
         self.ccx().insn_ctxt(s)
     }
 }
 
-pub impl get_insn_ctxt for fn_ctxt {
+impl get_insn_ctxt for fn_ctxt {
     fn insn_ctxt(&self, s: &str) -> icx_popper {
         self.ccx.insn_ctxt(s)
     }
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 48a3d2c82c873..f8a7f4779764c 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -538,13 +538,13 @@ pub trait get_node_info {
     fn info(&self) -> Option<NodeInfo>;
 }
 
-pub impl get_node_info for @ast::expr {
+impl get_node_info for @ast::expr {
     fn info(&self) -> Option<NodeInfo> {
         Some(NodeInfo { id: self.id, span: self.span })
     }
 }
 
-pub impl get_node_info for ast::blk {
+impl get_node_info for ast::blk {
     fn info(&self) -> Option<NodeInfo> {
         Some(NodeInfo { id: self.node.id, span: self.span })
     }
@@ -553,7 +553,7 @@ pub impl get_node_info for ast::blk {
 // XXX: Work around a trait parsing bug. remove after snapshot
 pub type optional_boxed_ast_expr = Option<@ast::expr>;
 
-pub impl get_node_info for optional_boxed_ast_expr {
+impl get_node_info for optional_boxed_ast_expr {
     fn info(&self) -> Option<NodeInfo> {
         self.chain_ref(|s| s.info())
     }
@@ -1275,7 +1275,7 @@ pub struct mono_id_ {
 
 pub type mono_id = @mono_id_;
 
-pub impl to_bytes::IterBytes for mono_param_id {
+impl to_bytes::IterBytes for mono_param_id {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match /*bad*/copy *self {
           mono_precise(t, mids) =>
@@ -1289,7 +1289,7 @@ pub impl to_bytes::IterBytes for mono_param_id {
     }
 }
 
-pub impl to_bytes::IterBytes for mono_id_ {
+impl to_bytes::IterBytes for mono_id_ {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.def, &self.params, lsb0, f);
     }
diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs
index ba56eb56c0a9d..07499dac62e14 100644
--- a/src/librustc/middle/trans/datum.rs
+++ b/src/librustc/middle/trans/datum.rs
@@ -151,14 +151,14 @@ pub impl DatumMode {
     }
 }
 
-pub impl cmp::Eq for DatumMode {
+impl cmp::Eq for DatumMode {
     pure fn eq(&self, other: &DatumMode) -> bool {
         (*self) as uint == (*other as uint)
     }
     pure fn ne(&self, other: &DatumMode) -> bool { !(*self).eq(other) }
 }
 
-pub impl to_bytes::IterBytes for DatumMode {
+impl to_bytes::IterBytes for DatumMode {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f)
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 182ab11b91721..efbbfc46cb944 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -660,46 +660,46 @@ pub trait Vid {
     pure fn to_uint(&self) -> uint;
 }
 
-pub impl Vid for TyVid {
+impl Vid for TyVid {
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl ToStr for TyVid {
+impl ToStr for TyVid {
     pure fn to_str(&self) -> ~str { fmt!("<V%u>", self.to_uint()) }
 }
 
-pub impl Vid for IntVid {
+impl Vid for IntVid {
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl ToStr for IntVid {
+impl ToStr for IntVid {
     pure fn to_str(&self) -> ~str { fmt!("<VI%u>", self.to_uint()) }
 }
 
-pub impl Vid for FloatVid {
+impl Vid for FloatVid {
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl ToStr for FloatVid {
+impl ToStr for FloatVid {
     pure fn to_str(&self) -> ~str { fmt!("<VF%u>", self.to_uint()) }
 }
 
-pub impl Vid for RegionVid {
+impl Vid for RegionVid {
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl ToStr for RegionVid {
+impl ToStr for RegionVid {
     pure fn to_str(&self) -> ~str { fmt!("%?", self) }
 }
 
-pub impl ToStr for FnSig {
+impl ToStr for FnSig {
     pure fn to_str(&self) -> ~str {
         // grr, without tcx not much we can do.
         return ~"(...)";
     }
 }
 
-pub impl ToStr for InferTy {
+impl ToStr for InferTy {
     pure fn to_str(&self) -> ~str {
         match *self {
             TyVar(ref v) => v.to_str(),
@@ -709,7 +709,7 @@ pub impl ToStr for InferTy {
     }
 }
 
-pub impl ToStr for IntVarValue {
+impl ToStr for IntVarValue {
     pure fn to_str(&self) -> ~str {
         match *self {
             IntType(ref v) => v.to_str(),
@@ -718,25 +718,25 @@ pub impl ToStr for IntVarValue {
     }
 }
 
-pub impl to_bytes::IterBytes for TyVid {
+impl to_bytes::IterBytes for TyVid {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.to_uint().iter_bytes(lsb0, f)
     }
 }
 
-pub impl to_bytes::IterBytes for IntVid {
+impl to_bytes::IterBytes for IntVid {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.to_uint().iter_bytes(lsb0, f)
     }
 }
 
-pub impl to_bytes::IterBytes for FloatVid {
+impl to_bytes::IterBytes for FloatVid {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.to_uint().iter_bytes(lsb0, f)
     }
 }
 
-pub impl to_bytes::IterBytes for RegionVid {
+impl to_bytes::IterBytes for RegionVid {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.to_uint().iter_bytes(lsb0, f)
     }
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index e63e46ace3d05..998c007c86d7d 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -625,7 +625,7 @@ pub fn check_item(ccx: @mut CrateCtxt, it: @ast::item) {
     }
 }
 
-pub impl AstConv for FnCtxt {
+impl AstConv for FnCtxt {
     fn tcx(@mut self) -> ty::ctxt { self.ccx.tcx }
     fn ccx(@mut self) -> @mut CrateCtxt { self.ccx }
 
@@ -659,7 +659,7 @@ pub impl FnCtxt {
     }
 }
 
-pub impl region_scope for @mut FnCtxt {
+impl region_scope for @mut FnCtxt {
     pure fn anon_region(&self, span: span) -> Result<ty::Region, ~str> {
         // XXX: Unsafe to work around purity
         unsafe {
diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs
index 96c76b52181c1..1bbee20e2e261 100644
--- a/src/librustc/middle/typeck/collect.rs
+++ b/src/librustc/middle/typeck/collect.rs
@@ -121,7 +121,7 @@ pub impl @mut CrateCtxt {
     }
 }
 
-pub impl AstConv for CrateCtxt {
+impl AstConv for CrateCtxt {
     fn tcx(@mut self) -> ty::ctxt { self.tcx }
     fn ccx(@mut self) -> @mut CrateCtxt { self }
 
diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs
index 5008791723eee..936ca1e829775 100644
--- a/src/librustc/middle/typeck/infer/glb.rs
+++ b/src/librustc/middle/typeck/infer/glb.rs
@@ -27,7 +27,7 @@ use std::list;
 
 pub enum Glb = CombineFields;  // "greatest lower bound" (common subtype)
 
-pub impl Combine for Glb {
+impl Combine for Glb {
     fn infcx(&self) -> @mut InferCtxt { self.infcx }
     fn tag(&self) -> ~str { ~"glb" }
     fn a_is_expected(&self) -> bool { self.a_is_expected }
diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs
index 1a919ac0f3b0b..8fa887fca0bad 100644
--- a/src/librustc/middle/typeck/infer/lattice.rs
+++ b/src/librustc/middle/typeck/infer/lattice.rs
@@ -59,7 +59,7 @@ pub trait LatticeValue {
 
 pub type LatticeOp<T> = &fn(cf: &CombineFields, a: &T, b: &T) -> cres<T>;
 
-pub impl LatticeValue for ty::t {
+impl LatticeValue for ty::t {
     static fn sub(&self, cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures {
         Sub(*cf).tys(*a, *b).to_ures()
     }
@@ -305,7 +305,7 @@ pub trait TyLatticeDir {
     fn ty_bot(&self, t: ty::t) -> cres<ty::t>;
 }
 
-pub impl LatticeDir for Lub {
+impl LatticeDir for Lub {
     fn combine_fields(&self) -> CombineFields { **self }
     fn bnd<T:Copy>(&self, b: &Bounds<T>) -> Option<T> { b.ub }
     fn with_bnd<T:Copy>(&self, b: &Bounds<T>, +t: T) -> Bounds<T> {
@@ -313,13 +313,13 @@ pub impl LatticeDir for Lub {
     }
 }
 
-pub impl TyLatticeDir for Lub {
+impl TyLatticeDir for Lub {
     fn ty_bot(&self, t: ty::t) -> cres<ty::t> {
         Ok(t)
     }
 }
 
-pub impl LatticeDir for Glb {
+impl LatticeDir for Glb {
     fn combine_fields(&self) -> CombineFields { **self }
     fn bnd<T:Copy>(&self, b: &Bounds<T>) -> Option<T> { b.lb }
     fn with_bnd<T:Copy>(&self, b: &Bounds<T>, +t: T) -> Bounds<T> {
@@ -327,7 +327,7 @@ pub impl LatticeDir for Glb {
     }
 }
 
-pub impl TyLatticeDir for Glb {
+impl TyLatticeDir for Glb {
     fn ty_bot(&self, _t: ty::t) -> cres<ty::t> {
         Ok(ty::mk_bot(self.infcx.tcx))
     }
diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs
index 4fee6f061b1ca..2c4fd9f01eea5 100644
--- a/src/librustc/middle/typeck/infer/lub.rs
+++ b/src/librustc/middle/typeck/infer/lub.rs
@@ -32,7 +32,7 @@ pub impl Lub {
              -> cres<ty::t> { self.bot_ty(b) } // commutative
 }
 
-pub impl Combine for Lub {
+impl Combine for Lub {
     fn infcx(&self) -> @mut InferCtxt { self.infcx }
     fn tag(&self) -> ~str { ~"lub" }
     fn a_is_expected(&self) -> bool { self.a_is_expected }
diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs
index 12a9a6c4076e7..5552b71d0d771 100644
--- a/src/librustc/middle/typeck/infer/sub.rs
+++ b/src/librustc/middle/typeck/infer/sub.rs
@@ -28,7 +28,7 @@ use syntax::ast::{m_const, purity, ret_style};
 
 pub enum Sub = CombineFields;  // "subtype", "subregion" etc
 
-pub impl Combine for Sub {
+impl Combine for Sub {
     fn infcx(&self) -> @mut InferCtxt { self.infcx }
     fn tag(&self) -> ~str { ~"sub" }
     fn a_is_expected(&self) -> bool { self.a_is_expected }
diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs
index 0013b417f7a31..9b74ac8535148 100644
--- a/src/librustc/middle/typeck/infer/to_str.rs
+++ b/src/librustc/middle/typeck/infer/to_str.rs
@@ -28,13 +28,13 @@ pub trait InferStr {
     fn inf_str(&self, cx: &InferCtxt) -> ~str;
 }
 
-pub impl InferStr for ty::t {
+impl InferStr for ty::t {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         ty_to_str(cx.tcx, *self)
     }
 }
 
-pub impl InferStr for FnSig {
+impl InferStr for FnSig {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         fmt!("(%s) -> %s",
              str::connect(self.inputs.map(|a| a.ty.inf_str(cx)), ", "),
@@ -42,19 +42,19 @@ pub impl InferStr for FnSig {
     }
 }
 
-pub impl InferStr for ty::mt {
+impl InferStr for ty::mt {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         mt_to_str(cx.tcx, *self)
     }
 }
 
-pub impl InferStr for ty::Region {
+impl InferStr for ty::Region {
     fn inf_str(&self, _cx: &InferCtxt) -> ~str {
         fmt!("%?", *self)
     }
 }
 
-pub impl<V:InferStr> InferStr for Bound<V> {
+impl<V:InferStr> InferStr for Bound<V> {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         match *self {
           Some(ref v) => v.inf_str(cx),
@@ -63,7 +63,7 @@ pub impl<V:InferStr> InferStr for Bound<V> {
     }
 }
 
-pub impl<T:InferStr> InferStr for Bounds<T> {
+impl<T:InferStr> InferStr for Bounds<T> {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         fmt!("{%s <: %s}",
              self.lb.inf_str(cx),
@@ -71,7 +71,7 @@ pub impl<T:InferStr> InferStr for Bounds<T> {
     }
 }
 
-pub impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
+impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
     fn inf_str(&self, cx: &InferCtxt) -> ~str {
         match *self {
           Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()),
@@ -81,13 +81,13 @@ pub impl<V:Vid + ToStr,T:InferStr> InferStr for VarValue<V, T> {
     }
 }
 
-pub impl InferStr for IntVarValue {
+impl InferStr for IntVarValue {
     fn inf_str(&self, _cx: &InferCtxt) -> ~str {
         self.to_str()
     }
 }
 
-pub impl InferStr for ast::float_ty {
+impl InferStr for ast::float_ty {
     fn inf_str(&self, _cx: &InferCtxt) -> ~str {
         self.to_str()
     }
diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs
index 93c6131d3406a..fec3f3d977962 100644
--- a/src/librustc/middle/typeck/infer/unify.rs
+++ b/src/librustc/middle/typeck/infer/unify.rs
@@ -237,35 +237,35 @@ pub impl InferCtxt {
 
 // ______________________________________________________________________
 
-pub impl UnifyVid<Bounds<ty::t>> for ty::TyVid {
+impl UnifyVid<Bounds<ty::t>> for ty::TyVid {
     static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
         -> &v/mut ValsAndBindings<ty::TyVid, Bounds<ty::t>> {
         return &mut infcx.ty_var_bindings;
     }
 }
 
-pub impl UnifyVid<Option<IntVarValue>> for ty::IntVid {
+impl UnifyVid<Option<IntVarValue>> for ty::IntVid {
     static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
         -> &v/mut ValsAndBindings<ty::IntVid, Option<IntVarValue>> {
         return &mut infcx.int_var_bindings;
     }
 }
 
-pub impl SimplyUnifiable for IntVarValue {
+impl SimplyUnifiable for IntVarValue {
     static fn to_type_err(&self, err: expected_found<IntVarValue>)
         -> ty::type_err {
         return ty::terr_int_mismatch(err);
     }
 }
 
-pub impl UnifyVid<Option<ast::float_ty>> for ty::FloatVid {
+impl UnifyVid<Option<ast::float_ty>> for ty::FloatVid {
     static fn appropriate_vals_and_bindings(&self, infcx: &v/mut InferCtxt)
         -> &v/mut ValsAndBindings<ty::FloatVid, Option<ast::float_ty>> {
         return &mut infcx.float_var_bindings;
     }
 }
 
-pub impl SimplyUnifiable for ast::float_ty {
+impl SimplyUnifiable for ast::float_ty {
     static fn to_type_err(&self, err: expected_found<ast::float_ty>)
         -> ty::type_err {
         return ty::terr_float_mismatch(err);
diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs
index 141a730ca8d34..628cccfa9a22f 100644
--- a/src/librustc/middle/typeck/rscope.rs
+++ b/src/librustc/middle/typeck/rscope.rs
@@ -26,7 +26,8 @@ pub trait region_scope {
 }
 
 pub enum empty_rscope { empty_rscope }
-pub impl region_scope for empty_rscope {
+
+impl region_scope for empty_rscope {
     pure fn anon_region(&self, _span: span) -> Result<ty::Region, ~str> {
         result::Ok(ty::re_static)
     }
@@ -40,7 +41,8 @@ pub impl region_scope for empty_rscope {
 }
 
 pub enum type_rscope = Option<ty::region_variance>;
-pub impl region_scope for type_rscope {
+
+impl region_scope for type_rscope {
     pure fn anon_region(&self, _span: span) -> Result<ty::Region, ~str> {
         match **self {
           Some(_) => result::Ok(ty::re_bound(ty::br_self)),
@@ -74,7 +76,8 @@ pub fn in_anon_rscope<RS:region_scope + Copy + Durable>(self: RS,
                                                      -> @anon_rscope {
     @anon_rscope {anon: r, base: self as region_scope}
 }
-pub impl region_scope for @anon_rscope {
+
+impl region_scope for @anon_rscope {
     pure fn anon_region(&self, _span: span) -> Result<ty::Region, ~str> {
         result::Ok(self.anon)
     }
@@ -97,7 +100,8 @@ pub fn in_binding_rscope<RS:region_scope + Copy + Durable>(self: RS)
     let base = self as region_scope;
     @mut binding_rscope { base: base, anon_bindings: 0 }
 }
-pub impl region_scope for @mut binding_rscope {
+
+impl region_scope for @mut binding_rscope {
     pure fn anon_region(&self, _span: span) -> Result<ty::Region, ~str> {
         // XXX: Unsafe to work around purity
         unsafe {
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 11a1b9f357657..0add792663027 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -59,7 +59,7 @@ pub struct Config {
     pandoc_cmd: Option<~str>
 }
 
-pub impl Clone for Config {
+impl Clone for Config {
     fn clone(&self) -> Config { copy *self }
 }
 
diff --git a/src/libstd/arc.rs b/src/libstd/arc.rs
index 61b5ffd845f89..f258e649122bd 100644
--- a/src/libstd/arc.rs
+++ b/src/libstd/arc.rs
@@ -17,6 +17,7 @@ use sync;
 use sync::{Mutex, mutex_with_condvars, RWlock, rwlock_with_condvars};
 
 use core::cast;
+use core::cell::Cell;
 use core::pipes;
 use core::prelude::*;
 use core::private::{SharedMutableState, shared_mutable_state};
@@ -532,17 +533,17 @@ mod tests {
         let arc = ~MutexARC(false);
         let arc2 = ~arc.clone();
         let (p,c) = comm::oneshot();
-        let (c,p) = (~mut Some(c), ~mut Some(p));
+        let (c,p) = (Cell(c), Cell(p));
         do task::spawn || {
             // wait until parent gets in
-            comm::recv_one(option::swap_unwrap(p));
+            comm::recv_one(p.take());
             do arc2.access_cond |state, cond| {
                 *state = true;
                 cond.signal();
             }
         }
         do arc.access_cond |state, cond| {
-            comm::send_one(option::swap_unwrap(c), ());
+            comm::send_one(c.take(), ());
             assert !*state;
             while !*state {
                 cond.wait();
diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index 13c0bbe1a674c..2ee994bdf32b4 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -258,7 +258,7 @@ pub trait ByteChan {
 
 const CONTINUE: [u8 * 4] = [0xAA, 0xBB, 0xCC, 0xDD];
 
-pub impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
+impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
     fn recv() -> T {
         match self.try_recv() {
             Some(val) => val,
@@ -358,7 +358,7 @@ pub mod flatteners {
         bogus: ()
     }
 
-    pub impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
+    impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             assert size_of::<T>() != 0;
             assert size_of::<T>() == buf.len();
@@ -368,7 +368,7 @@ pub mod flatteners {
         }
     }
 
-    pub impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
+    impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
         fn flatten(&self, val: T) -> ~[u8] {
             assert size_of::<T>() != 0;
             let val: *T = ptr::to_unsafe_ptr(&val);
@@ -406,14 +406,14 @@ pub mod flatteners {
         serialize_value: SerializeValue<T>
     }
 
-    pub impl<D:Decoder,T:Decodable<D>> Unflattener<T>
+    impl<D:Decoder,T:Decodable<D>> Unflattener<T>
             for DeserializingUnflattener<D, T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             (self.deserialize_buffer)(buf)
         }
     }
 
-    pub impl<S:Encoder,T:Encodable<S>> Flattener<T>
+    impl<S:Encoder,T:Encodable<S>> Flattener<T>
             for SerializingFlattener<S, T> {
         fn flatten(&self, val: T) -> ~[u8] {
             (self.serialize_value)(&val)
@@ -519,7 +519,7 @@ pub mod bytepipes {
         writer: W
     }
 
-    pub impl<R:Reader> BytePort for ReaderBytePort<R> {
+    impl<R:Reader> BytePort for ReaderBytePort<R> {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             let mut left = count;
             let mut bytes = ~[];
@@ -541,7 +541,7 @@ pub mod bytepipes {
         }
     }
 
-    pub impl<W:Writer> ByteChan for WriterByteChan<W> {
+    impl<W:Writer> ByteChan for WriterByteChan<W> {
         fn send(&self, val: ~[u8]) {
             self.writer.write(val);
         }
@@ -572,7 +572,7 @@ pub mod bytepipes {
         chan: comm::Chan<~[u8]>
     }
 
-    pub impl BytePort for PipeBytePort {
+    impl BytePort for PipeBytePort {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             if self.buf.len() >= count {
                 let mut bytes = ::core::util::replace(&mut self.buf, ~[]);
@@ -604,7 +604,7 @@ pub mod bytepipes {
         }
     }
 
-    pub impl ByteChan for PipeByteChan {
+    impl ByteChan for PipeByteChan {
         fn send(&self, val: ~[u8]) {
             self.chan.send(val)
         }
diff --git a/src/libstd/future.rs b/src/libstd/future.rs
index b6b001727a45a..7f48466ed0a87 100644
--- a/src/libstd/future.rs
+++ b/src/libstd/future.rs
@@ -23,6 +23,7 @@
 
 use core::cast::copy_lifetime;
 use core::cast;
+use core::cell::Cell;
 use core::either::Either;
 use core::option;
 use core::comm::{oneshot, ChanOne, PortOne, send_one, recv_one};
@@ -103,11 +104,9 @@ pub fn from_port<A:Owned>(port: PortOne<A>) ->
      * waiting for the result to be received on the port.
      */
 
-    let port = ~mut Some(port);
+    let port = Cell(port);
     do from_fn || {
-        let mut port_ = None;
-        port_ <-> *port;
-        let port = option::unwrap(port_);
+        let port = port.take();
         match recv(port) {
             oneshot::send(data) => data
         }
@@ -136,9 +135,9 @@ pub fn spawn<A:Owned>(blk: fn~() -> A) -> Future<A> {
 
     let (chan, port) = oneshot::init();
 
-    let chan = ~mut Some(chan);
+    let chan = Cell(chan);
     do task::spawn || {
-        let chan = option::swap_unwrap(&mut *chan);
+        let chan = chan.take();
         send_one(chan, blk());
     }
 
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index d16b1282c7c0b..c6e76aa1a688c 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -82,7 +82,7 @@ pub fn Encoder(wr: io::Writer) -> Encoder {
     Encoder { wr: wr }
 }
 
-pub impl serialize::Encoder for Encoder {
+impl serialize::Encoder for Encoder {
     fn emit_nil(&self) { self.wr.write_str("null") }
 
     fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
@@ -217,7 +217,7 @@ pub fn PrettyEncoder(wr: io::Writer) -> PrettyEncoder {
     PrettyEncoder { wr: wr, indent: 0 }
 }
 
-pub impl serialize::Encoder for PrettyEncoder {
+impl serialize::Encoder for PrettyEncoder {
     fn emit_nil(&self) { self.wr.write_str("null") }
 
     fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
@@ -323,7 +323,7 @@ pub impl serialize::Encoder for PrettyEncoder {
     }
 }
 
-pub impl<S:serialize::Encoder> serialize::Encodable<S> for Json {
+impl<S:serialize::Encoder> serialize::Encodable<S> for Json {
     fn encode(&self, s: &S) {
         match *self {
             Number(v) => v.encode(s),
@@ -768,7 +768,7 @@ priv impl Decoder {
     }
 }
 
-pub impl serialize::Decoder for Decoder {
+impl serialize::Decoder for Decoder {
     fn read_nil(&self) -> () {
         debug!("read_nil");
         match *self.pop() {
diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs
index cb9090225bf1c..dd873650b662e 100644
--- a/src/libstd/prettyprint.rs
+++ b/src/libstd/prettyprint.rs
@@ -22,7 +22,7 @@ pub fn Serializer(wr: io::Writer) -> Serializer {
     Serializer { wr: wr }
 }
 
-pub impl serialize::Encoder for Serializer {
+impl serialize::Encoder for Serializer {
     fn emit_nil(&self) {
         self.wr.write_str(~"()")
     }
diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs
index 3178e141097f9..66db951e12bde 100644
--- a/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@ -113,210 +113,210 @@ pub trait Decodable<D:Decoder> {
     static fn decode(&self, d: &D) -> Self;
 }
 
-pub impl<S:Encoder> Encodable<S> for uint {
+impl<S:Encoder> Encodable<S> for uint {
     fn encode(&self, s: &S) { s.emit_uint(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for uint {
+impl<D:Decoder> Decodable<D> for uint {
     static fn decode(&self, d: &D) -> uint {
         d.read_uint()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u8 {
+impl<S:Encoder> Encodable<S> for u8 {
     fn encode(&self, s: &S) { s.emit_u8(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u8 {
+impl<D:Decoder> Decodable<D> for u8 {
     static fn decode(&self, d: &D) -> u8 {
         d.read_u8()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u16 {
+impl<S:Encoder> Encodable<S> for u16 {
     fn encode(&self, s: &S) { s.emit_u16(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u16 {
+impl<D:Decoder> Decodable<D> for u16 {
     static fn decode(&self, d: &D) -> u16 {
         d.read_u16()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u32 {
+impl<S:Encoder> Encodable<S> for u32 {
     fn encode(&self, s: &S) { s.emit_u32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u32 {
+impl<D:Decoder> Decodable<D> for u32 {
     static fn decode(&self, d: &D) -> u32 {
         d.read_u32()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u64 {
+impl<S:Encoder> Encodable<S> for u64 {
     fn encode(&self, s: &S) { s.emit_u64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u64 {
+impl<D:Decoder> Decodable<D> for u64 {
     static fn decode(&self, d: &D) -> u64 {
         d.read_u64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for int {
+impl<S:Encoder> Encodable<S> for int {
     fn encode(&self, s: &S) { s.emit_int(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for int {
+impl<D:Decoder> Decodable<D> for int {
     static fn decode(&self, d: &D) -> int {
         d.read_int()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i8 {
+impl<S:Encoder> Encodable<S> for i8 {
     fn encode(&self, s: &S) { s.emit_i8(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i8 {
+impl<D:Decoder> Decodable<D> for i8 {
     static fn decode(&self, d: &D) -> i8 {
         d.read_i8()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i16 {
+impl<S:Encoder> Encodable<S> for i16 {
     fn encode(&self, s: &S) { s.emit_i16(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i16 {
+impl<D:Decoder> Decodable<D> for i16 {
     static fn decode(&self, d: &D) -> i16 {
         d.read_i16()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i32 {
+impl<S:Encoder> Encodable<S> for i32 {
     fn encode(&self, s: &S) { s.emit_i32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i32 {
+impl<D:Decoder> Decodable<D> for i32 {
     static fn decode(&self, d: &D) -> i32 {
         d.read_i32()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i64 {
+impl<S:Encoder> Encodable<S> for i64 {
     fn encode(&self, s: &S) { s.emit_i64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i64 {
+impl<D:Decoder> Decodable<D> for i64 {
     static fn decode(&self, d: &D) -> i64 {
         d.read_i64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for &str {
+impl<S:Encoder> Encodable<S> for &str {
     fn encode(&self, s: &S) { s.emit_borrowed_str(*self) }
 }
 
-pub impl<S:Encoder> Encodable<S> for ~str {
+impl<S:Encoder> Encodable<S> for ~str {
     fn encode(&self, s: &S) { s.emit_owned_str(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for ~str {
+impl<D:Decoder> Decodable<D> for ~str {
     static fn decode(&self, d: &D) -> ~str {
         d.read_owned_str()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for @str {
+impl<S:Encoder> Encodable<S> for @str {
     fn encode(&self, s: &S) { s.emit_managed_str(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for @str {
+impl<D:Decoder> Decodable<D> for @str {
     static fn decode(&self, d: &D) -> @str {
         d.read_managed_str()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for float {
+impl<S:Encoder> Encodable<S> for float {
     fn encode(&self, s: &S) { s.emit_float(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for float {
+impl<D:Decoder> Decodable<D> for float {
     static fn decode(&self, d: &D) -> float {
         d.read_float()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for f32 {
+impl<S:Encoder> Encodable<S> for f32 {
     fn encode(&self, s: &S) { s.emit_f32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for f32 {
+impl<D:Decoder> Decodable<D> for f32 {
     static fn decode(&self, d: &D) -> f32 {
         d.read_f32() }
 }
 
-pub impl<S:Encoder> Encodable<S> for f64 {
+impl<S:Encoder> Encodable<S> for f64 {
     fn encode(&self, s: &S) { s.emit_f64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for f64 {
+impl<D:Decoder> Decodable<D> for f64 {
     static fn decode(&self, d: &D) -> f64 {
         d.read_f64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for bool {
+impl<S:Encoder> Encodable<S> for bool {
     fn encode(&self, s: &S) { s.emit_bool(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for bool {
+impl<D:Decoder> Decodable<D> for bool {
     static fn decode(&self, d: &D) -> bool {
         d.read_bool()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for () {
+impl<S:Encoder> Encodable<S> for () {
     fn encode(&self, s: &S) { s.emit_nil() }
 }
 
-pub impl<D:Decoder> Decodable<D> for () {
+impl<D:Decoder> Decodable<D> for () {
     static fn decode(&self, d: &D) -> () {
         d.read_nil()
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &T {
     fn encode(&self, s: &S) {
         s.emit_borrowed(|| (**self).encode(s))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T {
     fn encode(&self, s: &S) {
         s.emit_owned(|| (**self).encode(s))
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T {
     static fn decode(&self, d: &D) -> ~T {
         d.read_owned(|| ~Decodable::decode(d))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
     fn encode(&self, s: &S) {
         s.emit_managed(|| (**self).encode(s))
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
     static fn decode(&self, d: &D) -> @T {
         d.read_managed(|| @Decodable::decode(d))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
     fn encode(&self, s: &S) {
         do s.emit_borrowed_vec(self.len()) {
             for self.eachi |i, e| {
@@ -326,7 +326,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
     fn encode(&self, s: &S) {
         do s.emit_owned_vec(self.len()) {
             for self.eachi |i, e| {
@@ -336,7 +336,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
     static fn decode(&self, d: &D) -> ~[T] {
         do d.read_owned_vec |len| {
             do vec::from_fn(len) |i| {
@@ -346,7 +346,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
     fn encode(&self, s: &S) {
         do s.emit_managed_vec(self.len()) {
             for self.eachi |i, e| {
@@ -356,7 +356,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
     static fn decode(&self, d: &D) -> @[T] {
         do d.read_managed_vec |len| {
             do at_vec::from_fn(len) |i| {
@@ -366,7 +366,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
     fn encode(&self, s: &S) {
         do s.emit_enum(~"option") {
             match *self {
@@ -381,7 +381,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
     static fn decode(&self, d: &D) -> Option<T> {
         do d.read_enum(~"option") {
             do d.read_enum_variant |i| {
@@ -396,8 +396,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
     }
 }
 
-pub impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S>
-        for (T0, T1) {
+impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S> for (T0, T1) {
     fn encode(&self, s: &S) {
         match *self {
             (ref t0, ref t1) => {
@@ -410,8 +409,7 @@ pub impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S>
     }
 }
 
-pub impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D>
-        for (T0, T1) {
+impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D> for (T0, T1) {
     static fn decode(&self, d: &D) -> (T0, T1) {
         do d.read_tup(2) {
             (
@@ -422,7 +420,7 @@ pub impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D>
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -441,7 +439,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -458,7 +456,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -479,7 +477,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -498,7 +496,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -521,7 +519,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -552,7 +550,7 @@ pub trait EncoderHelpers {
     fn emit_from_vec<T>(&self, v: &[T], f: fn(v: &T));
 }
 
-pub impl<S:Encoder> EncoderHelpers for S {
+impl<S:Encoder> EncoderHelpers for S {
     fn emit_from_vec<T>(&self, v: &[T], f: fn(v: &T)) {
         do self.emit_owned_vec(v.len()) {
             for v.eachi |i, e| {
@@ -568,7 +566,7 @@ pub trait DecoderHelpers {
     fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T];
 }
 
-pub impl<D:Decoder> DecoderHelpers for D {
+impl<D:Decoder> DecoderHelpers for D {
     fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T] {
         do self.read_owned_vec |len| {
             do vec::from_fn(len) |i| {
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index d2515df3e1b40..75f38da5a19a1 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -455,8 +455,7 @@ impl<T:Copy + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert len1 != 0 && len2 != 0 && base1+len1 == base2;
 
-        let tmp = vec::cast_to_mut(
-            vec::slice(array, base1, base1+len1).to_vec());
+        let mut tmp = vec::slice(array, base1, base1+len1).to_vec();
 
         let mut c1 = 0;
         let mut c2 = base2;
@@ -559,8 +558,7 @@ impl<T:Copy + Ord> MergeState<T> {
                 base2: uint, len2: uint) {
         assert len1 != 1 && len2 != 0 && base1 + len1 == base2;
 
-        let tmp = vec::cast_to_mut(
-            vec::slice(array, base2, base2+len2).to_vec());
+        let mut tmp = vec::slice(array, base2, base2+len2).to_vec();
 
         let mut c1 = base1 + len1 - 1;
         let mut c2 = len2 - 1;
diff --git a/src/libstd/stats.rs b/src/libstd/stats.rs
index fb6f80a650084..7dafdec95e072 100644
--- a/src/libstd/stats.rs
+++ b/src/libstd/stats.rs
@@ -52,7 +52,7 @@ impl Stats for &[f64] {
 
     fn median(self) -> f64 {
         assert self.len() != 0;
-        let tmp = vec::cast_to_mut(vec::from_slice(self));
+        let mut tmp = vec::from_slice(self);
         sort::tim_sort(tmp);
         if tmp.len() & 1 == 0 {
             let m = tmp.len() / 2;
diff --git a/src/libstd/sync.rs b/src/libstd/sync.rs
index 016847a5bfd7d..1ff51e8bff030 100644
--- a/src/libstd/sync.rs
+++ b/src/libstd/sync.rs
@@ -15,6 +15,7 @@
  * in std.
  */
 
+use core::cell::Cell;
 use core::option;
 use core::pipes;
 use core::prelude::*;
@@ -799,9 +800,9 @@ mod tests {
             let s = ~semaphore(1);
             let s2 = ~s.clone();
             let (p,c) = comm::stream();
-            let child_data = ~mut Some((s2, c));
+            let child_data = Cell((s2, c));
             do s.access {
-                let (s2,c) = option::swap_unwrap(child_data);
+                let (s2, c) = child_data.take();
                 do task::spawn || {
                     c.send(());
                     do s2.access { }
@@ -976,13 +977,13 @@ mod tests {
             let mut sibling_convos = ~[];
             for 2.times {
                 let (p,c) = comm::stream();
-                let c = ~mut Some(c);
+                let c = Cell(c);
                 sibling_convos.push(p);
                 let mi = ~m2.clone();
                 // spawn sibling task
-                do task::spawn || { // linked
+                do task::spawn { // linked
                     do mi.lock_cond |cond| {
-                        let c = option::swap_unwrap(c);
+                        let c = c.take();
                         c.send(()); // tell sibling to go ahead
                         let _z = SendOnFailure(c);
                         cond.wait(); // block forever
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index e14e9665216f6..bfeaf8400bc44 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -377,7 +377,7 @@ pub fn run_tests_console(opts: &TestOpts,
 
 fn print_failures(st: @ConsoleTestState) {
     st.out.write_line(~"\nfailures:");
-    let failures = vec::cast_to_mut(st.failures.map(|t| t.name.to_str()));
+    let mut failures = st.failures.map(|t| t.name.to_str());
     sort::tim_sort(failures);
     for vec::each(failures) |name| {
         st.out.write_line(fmt!("    %s", name.to_str()));
diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs
index 8ce68a41f81bf..c85aa78d9834a 100644
--- a/src/libstd/workcache.rs
+++ b/src/libstd/workcache.rs
@@ -15,6 +15,7 @@ use sha1;
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 use sort;
 
+use core::cell::Cell;
 use core::cmp;
 use core::either::{Either, Left, Right};
 use core::io;
@@ -139,7 +140,7 @@ impl WorkKey {
 
 type WorkMap = LinearMap<WorkKey, ~str>;
 
-pub impl<S:Encoder> Encodable<S> for WorkMap {
+impl<S:Encoder> Encodable<S> for WorkMap {
     fn encode(&self, s: &S) {
         let mut d = ~[];
         for self.each |&(k, v)| {
@@ -150,7 +151,7 @@ pub impl<S:Encoder> Encodable<S> for WorkMap {
     }
 }
 
-pub impl<D:Decoder> Decodable<D> for WorkMap {
+impl<D:Decoder> Decodable<D> for WorkMap {
     static fn decode(&self, d: &D) -> WorkMap {
         let v : ~[(WorkKey,~str)] = Decodable::decode(d);
         let mut w = LinearMap::new();
@@ -339,11 +340,11 @@ impl TPrep for @Mut<Prep> {
                     let mut blk = None;
                     blk <-> bo;
                     let blk = blk.unwrap();
-                    let chan = ~mut Some(chan);
+                    let chan = Cell(chan);
                     do task::spawn || {
                         let exe = Exec{discovered_inputs: LinearMap::new(),
                                        discovered_outputs: LinearMap::new()};
-                        let chan = option::swap_unwrap(&mut *chan);
+                        let chan = chan.take();
                         let v = blk(&exe);
                         send_one(chan, (exe, v));
                     }
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 5af67aa0e3b33..744cb92fb1c2c 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -61,7 +61,7 @@ type Name = uint;
 // with a macro expansion
 type Mrk = uint;
 
-pub impl<S:Encoder> Encodable<S> for ident {
+impl<S:Encoder> Encodable<S> for ident {
     fn encode(&self, s: &S) {
         let intr = match unsafe {
             task::local_data::local_data_get(interner_key!())
@@ -74,7 +74,7 @@ pub impl<S:Encoder> Encodable<S> for ident {
     }
 }
 
-pub impl<D:Decoder> Decodable<D> for ident {
+impl<D:Decoder> Decodable<D> for ident {
     static fn decode(d: &D) -> ident {
         let intr = match unsafe {
             task::local_data::local_data_get(interner_key!())
@@ -87,7 +87,7 @@ pub impl<D:Decoder> Decodable<D> for ident {
     }
 }
 
-pub impl to_bytes::IterBytes for ident {
+impl to_bytes::IterBytes for ident {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         self.repr.iter_bytes(lsb0, f)
     }
@@ -246,7 +246,7 @@ pub enum binding_mode {
     bind_infer
 }
 
-pub impl to_bytes::IterBytes for binding_mode {
+impl to_bytes::IterBytes for binding_mode {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
           bind_by_copy => 0u8.iter_bytes(lsb0, f),
@@ -291,7 +291,7 @@ pub enum pat_ {
 #[deriving_eq]
 pub enum mutability { m_mutbl, m_imm, m_const, }
 
-pub impl to_bytes::IterBytes for mutability {
+impl to_bytes::IterBytes for mutability {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -304,13 +304,13 @@ pub enum Abi {
     RustAbi
 }
 
-pub impl to_bytes::IterBytes for Abi {
+impl to_bytes::IterBytes for Abi {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f)
     }
 }
 
-pub impl ToStr for Abi {
+impl ToStr for Abi {
     pure fn to_str(&self) -> ~str {
         match *self {
             RustAbi => ~"\"rust\""
@@ -327,13 +327,13 @@ pub enum Sigil {
     ManagedSigil
 }
 
-pub impl to_bytes::IterBytes for Sigil {
+impl to_bytes::IterBytes for Sigil {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f)
     }
 }
 
-pub impl ToStr for Sigil {
+impl ToStr for Sigil {
     pure fn to_str(&self) -> ~str {
         match *self {
             BorrowedSigil => ~"&",
@@ -412,7 +412,7 @@ pub enum inferable<T> {
     infer(node_id)
 }
 
-pub impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> {
+impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         match *self {
           expl(ref t) =>
@@ -430,7 +430,7 @@ pub impl<T:to_bytes::IterBytes> to_bytes::IterBytes for inferable<T> {
 #[deriving_eq]
 pub enum rmode { by_ref, by_val, by_copy }
 
-pub impl to_bytes::IterBytes for rmode {
+impl to_bytes::IterBytes for rmode {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -771,13 +771,13 @@ pub enum trait_method {
 #[deriving_eq]
 pub enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
 
-pub impl ToStr for int_ty {
+impl ToStr for int_ty {
     pure fn to_str(&self) -> ~str {
         ::ast_util::int_ty_to_str(*self)
     }
 }
 
-pub impl to_bytes::IterBytes for int_ty {
+impl to_bytes::IterBytes for int_ty {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -788,13 +788,13 @@ pub impl to_bytes::IterBytes for int_ty {
 #[deriving_eq]
 pub enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
 
-pub impl ToStr for uint_ty {
+impl ToStr for uint_ty {
     pure fn to_str(&self) -> ~str {
         ::ast_util::uint_ty_to_str(*self)
     }
 }
 
-pub impl to_bytes::IterBytes for uint_ty {
+impl to_bytes::IterBytes for uint_ty {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -805,13 +805,13 @@ pub impl to_bytes::IterBytes for uint_ty {
 #[deriving_eq]
 pub enum float_ty { ty_f, ty_f32, ty_f64, }
 
-pub impl ToStr for float_ty {
+impl ToStr for float_ty {
     pure fn to_str(&self) -> ~str {
         ::ast_util::float_ty_to_str(*self)
     }
 }
 
-pub impl to_bytes::IterBytes for float_ty {
+impl to_bytes::IterBytes for float_ty {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -865,7 +865,7 @@ pub enum Onceness {
     Many
 }
 
-pub impl ToStr for Onceness {
+impl ToStr for Onceness {
     pure fn to_str(&self) -> ~str {
         match *self {
             Once => ~"once",
@@ -874,7 +874,7 @@ pub impl ToStr for Onceness {
     }
 }
 
-pub impl to_bytes::IterBytes for Onceness {
+impl to_bytes::IterBytes for Onceness {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f);
     }
@@ -924,7 +924,7 @@ pub enum ty_ {
     ty_infer,
 }
 
-pub impl to_bytes::IterBytes for Ty {
+impl to_bytes::IterBytes for Ty {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.span.lo, &self.span.hi, lsb0, f);
     }
@@ -960,7 +960,7 @@ pub enum purity {
     extern_fn, // declared with "extern fn"
 }
 
-pub impl ToStr for purity {
+impl ToStr for purity {
     pure fn to_str(&self) -> ~str {
         match *self {
             impure_fn => ~"impure",
@@ -971,7 +971,7 @@ pub impl ToStr for purity {
     }
 }
 
-pub impl to_bytes::IterBytes for purity {
+impl to_bytes::IterBytes for purity {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -986,7 +986,7 @@ pub enum ret_style {
     return_val, // everything else
 }
 
-pub impl to_bytes::IterBytes for ret_style {
+impl to_bytes::IterBytes for ret_style {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
@@ -1268,7 +1268,7 @@ pub enum item_ {
 #[deriving_eq]
 pub enum struct_mutability { struct_mutable, struct_immutable }
 
-pub impl to_bytes::IterBytes for struct_mutability {
+impl to_bytes::IterBytes for struct_mutability {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as u8).iter_bytes(lsb0, f)
     }
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 74f67808a5e97..959454841a2a7 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -34,7 +34,7 @@ pub enum path_elt {
     path_name(ident)
 }
 
-pub impl cmp::Eq for path_elt {
+impl cmp::Eq for path_elt {
     pure fn eq(&self, other: &path_elt) -> bool {
         match (*self) {
             path_mod(e0a) => {
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index fec3a961a52a2..4c5c4da514273 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -198,7 +198,7 @@ pub pure fn is_call_expr(e: @expr) -> bool {
 }
 
 // This makes def_id hashable
-pub impl to_bytes::IterBytes for def_id {
+impl to_bytes::IterBytes for def_id {
     #[inline(always)]
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.crate, &self.node, lsb0, f);
@@ -303,7 +303,7 @@ pub trait inlined_item_utils {
     fn accept<E>(&self, e: E, v: visit::vt<E>);
 }
 
-pub impl inlined_item_utils for inlined_item {
+impl inlined_item_utils for inlined_item {
     fn ident(&self) -> ident {
         match *self {
             ii_item(i) => /* FIXME (#2543) */ copy i.ident,
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 1ab55fe9035bc..65711d9894a73 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -46,71 +46,71 @@ pub enum CharPos = uint;
 // XXX: Lots of boilerplate in these impls, but so far my attempts to fix
 // have been unsuccessful
 
-pub impl Pos for BytePos {
+impl Pos for BytePos {
     static pure fn from_uint(n: uint) -> BytePos { BytePos(n) }
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl cmp::Eq for BytePos {
+impl cmp::Eq for BytePos {
     pure fn eq(&self, other: &BytePos) -> bool { **self == **other }
     pure fn ne(&self, other: &BytePos) -> bool { !(*self).eq(other) }
 }
 
-pub impl cmp::Ord for BytePos {
+impl cmp::Ord for BytePos {
     pure fn lt(&self, other: &BytePos) -> bool { **self < **other }
     pure fn le(&self, other: &BytePos) -> bool { **self <= **other }
     pure fn ge(&self, other: &BytePos) -> bool { **self >= **other }
     pure fn gt(&self, other: &BytePos) -> bool { **self > **other }
 }
 
-pub impl Add<BytePos, BytePos> for BytePos {
+impl Add<BytePos, BytePos> for BytePos {
     pure fn add(&self, rhs: &BytePos) -> BytePos {
         BytePos(**self + **rhs)
     }
 }
 
-pub impl Sub<BytePos, BytePos> for BytePos {
+impl Sub<BytePos, BytePos> for BytePos {
     pure fn sub(&self, rhs: &BytePos) -> BytePos {
         BytePos(**self - **rhs)
     }
 }
 
-pub impl to_bytes::IterBytes for BytePos {
+impl to_bytes::IterBytes for BytePos {
     pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) {
         (**self).iter_bytes(lsb0, f)
     }
 }
 
-pub impl Pos for CharPos {
+impl Pos for CharPos {
     static pure fn from_uint(n: uint) -> CharPos { CharPos(n) }
     pure fn to_uint(&self) -> uint { **self }
 }
 
-pub impl cmp::Eq for CharPos {
+impl cmp::Eq for CharPos {
     pure fn eq(&self, other: &CharPos) -> bool { **self == **other }
     pure fn ne(&self, other: &CharPos) -> bool { !(*self).eq(other) }
 }
 
-pub impl cmp::Ord for CharPos {
+impl cmp::Ord for CharPos {
     pure fn lt(&self, other: &CharPos) -> bool { **self < **other }
     pure fn le(&self, other: &CharPos) -> bool { **self <= **other }
     pure fn ge(&self, other: &CharPos) -> bool { **self >= **other }
     pure fn gt(&self, other: &CharPos) -> bool { **self > **other }
 }
 
-pub impl to_bytes::IterBytes for CharPos {
+impl to_bytes::IterBytes for CharPos {
     pure fn iter_bytes(&self, +lsb0: bool, &&f: to_bytes::Cb) {
         (**self).iter_bytes(lsb0, f)
     }
 }
 
-pub impl Add<CharPos,CharPos> for CharPos {
+impl Add<CharPos,CharPos> for CharPos {
     pure fn add(&self, rhs: &CharPos) -> CharPos {
         CharPos(**self + **rhs)
     }
 }
 
-pub impl Sub<CharPos,CharPos> for CharPos {
+impl Sub<CharPos,CharPos> for CharPos {
     pure fn sub(&self, rhs: &CharPos) -> CharPos {
         CharPos(**self - **rhs)
     }
@@ -133,19 +133,19 @@ pub struct span {
 #[deriving_eq]
 pub struct spanned<T> { node: T, span: span }
 
-pub impl cmp::Eq for span {
+impl cmp::Eq for span {
     pure fn eq(&self, other: &span) -> bool {
         return (*self).lo == (*other).lo && (*self).hi == (*other).hi;
     }
     pure fn ne(&self, other: &span) -> bool { !(*self).eq(other) }
 }
 
-pub impl<S:Encoder> Encodable<S> for span {
+impl<S:Encoder> Encodable<S> for span {
     /* Note #1972 -- spans are encoded but not decoded */
     fn encode(&self, _s: &S) { }
 }
 
-pub impl<D:Decoder> Decodable<D> for span {
+impl<D:Decoder> Decodable<D> for span {
     static fn decode(_d: &D) -> span {
         dummy_sp()
     }
diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index 0019acc1291f4..9e60e2151744b 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -1192,7 +1192,7 @@ mod test {
         }
     }
 
-    pub impl Encoder for TestEncoder {
+    impl Encoder for TestEncoder {
         fn emit_nil(&self) { self.add_to_log(CallToEmitNil) }
 
         fn emit_uint(&self, +v: uint) {self.add_to_log(CallToEmitUint(v)); }
diff --git a/src/libsyntax/ext/pipes/ast_builder.rs b/src/libsyntax/ext/pipes/ast_builder.rs
index 49f7fe5853e7b..6adea6395a356 100644
--- a/src/libsyntax/ext/pipes/ast_builder.rs
+++ b/src/libsyntax/ext/pipes/ast_builder.rs
@@ -54,7 +54,7 @@ pub trait append_types {
     fn add_tys(+tys: ~[@ast::Ty]) -> @ast::path;
 }
 
-pub impl append_types for @ast::path {
+impl append_types for @ast::path {
     fn add_ty(ty: @ast::Ty) -> @ast::path {
         @ast::path { types: vec::append_one(self.types, ty),
                      .. *self}
@@ -119,7 +119,7 @@ pub trait ext_ctxt_ast_builder {
     fn strip_bounds(&self, bounds: &[ast::ty_param]) -> ~[ast::ty_param];
 }
 
-pub impl ext_ctxt_ast_builder for ext_ctxt {
+impl ext_ctxt_ast_builder for ext_ctxt {
     fn ty_option(&self, ty: @ast::Ty) -> @ast::Ty {
         self.ty_path_ast_builder(path_global(~[
             self.ident_of(~"core"),
diff --git a/src/libsyntax/ext/pipes/check.rs b/src/libsyntax/ext/pipes/check.rs
index cc42a0992cbed..f456f7b81ae15 100644
--- a/src/libsyntax/ext/pipes/check.rs
+++ b/src/libsyntax/ext/pipes/check.rs
@@ -37,7 +37,7 @@ use ext::base::ext_ctxt;
 use ext::pipes::proto::{state, protocol, next_state};
 use ext::pipes::proto;
 
-pub impl proto::visitor<(), (), ()> for ext_ctxt {
+impl proto::visitor<(), (), ()> for ext_ctxt {
     fn visit_proto(&self, _proto: protocol,
                    _states: &[()]) { }
 
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index 66feb7cc753cf..9a330db9f1825 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -23,7 +23,7 @@ pub trait proto_parser {
     fn parse_message(&self, state: state);
 }
 
-pub impl proto_parser for parser::Parser {
+impl proto_parser for parser::Parser {
     fn parse_proto(&self, id: ~str) -> protocol {
         let proto = protocol(id, *self.span);
 
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index 444b09d9ae458..84d46e318b1cd 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -46,7 +46,7 @@ pub trait gen_init {
     fn gen_init_bounded(&self, ext_cx: ext_ctxt) -> @ast::expr;
 }
 
-pub impl gen_send for message {
+impl gen_send for message {
     fn gen_send(&mut self, cx: ext_ctxt, try: bool) -> @ast::item {
         debug!("pipec: gen_send");
         let name = self.name();
@@ -196,7 +196,7 @@ pub impl gen_send for message {
     }
 }
 
-pub impl to_type_decls for state {
+impl to_type_decls for state {
     fn to_type_decls(&self, cx: ext_ctxt) -> ~[@ast::item] {
         debug!("pipec: to_type_decls");
         // This compiles into two different type declarations. Say the
@@ -307,7 +307,7 @@ pub impl to_type_decls for state {
     }
 }
 
-pub impl gen_init for protocol {
+impl gen_init for protocol {
     fn gen_init(&self, cx: ext_ctxt) -> @ast::item {
         let ext_cx = cx;
 
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
index 7c6dc1f937dca..d22feff947075 100644
--- a/src/libsyntax/ext/pipes/proto.rs
+++ b/src/libsyntax/ext/pipes/proto.rs
@@ -21,7 +21,7 @@ use core::to_str::ToStr;
 #[deriving_eq]
 pub enum direction { send, recv }
 
-pub impl ToStr for direction {
+impl ToStr for direction {
     pure fn to_str(&self) -> ~str {
         match *self {
           send => ~"Send",
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index dacb6f60e3764..2d8b62629ee27 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -694,7 +694,7 @@ pub fn default_ast_fold() -> ast_fold_fns {
           new_span: noop_span};
 }
 
-pub impl ast_fold for ast_fold_fns {
+impl ast_fold for ast_fold_fns {
     /* naturally, a macro to write these would be nice */
     fn fold_crate(c: crate) -> crate {
         let (n, s) = (self.fold_crate)(c.node, c.span, self as ast_fold);
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 51cc25e84a33c..dc5bdeba92a88 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -127,7 +127,7 @@ impl reader for StringReader {
     fn dup(@mut self) -> reader { dup_string_reader(self) as reader }
 }
 
-pub impl reader for TtReader {
+impl reader for TtReader {
     fn is_eof(@mut self) -> bool { self.cur_tok == token::EOF }
     fn next_token(@mut self) -> TokenAndSpan { tt_next_token(self) }
     fn fatal(@mut self, m: ~str) -> ! {
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 7b3030124b72f..b384e7ebdd0f4 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -49,9 +49,11 @@ pub enum ObsoleteSyntax {
     ObsoleteImplSyntax,
     ObsoleteTraitBoundSeparator,
     ObsoleteMutOwnedPointer,
+    ObsoleteMutVector,
+    ObsoleteTraitImplVisibility,
 }
 
-pub impl to_bytes::IterBytes for ObsoleteSyntax {
+impl to_bytes::IterBytes for ObsoleteSyntax {
     #[inline(always)]
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         (*self as uint).iter_bytes(lsb0, f);
@@ -128,11 +130,23 @@ pub impl Parser {
                 "write `+` between trait bounds"
             ),
             ObsoleteMutOwnedPointer => (
-                "mutable owned pointer",
+                "const or mutable owned pointer",
                 "mutability inherits through `~` pointers; place the `~` box
                  in a mutable location, like a mutable local variable or an \
                  `@mut` box"
             ),
+            ObsoleteMutVector => (
+                "const or mutable vector",
+                "mutability inherits through `~` pointers; place the vector \
+                 in a mutable location, like a mutable local variable or an \
+                 `@mut` box"
+            ),
+            ObsoleteTraitImplVisibility => (
+                "visibility-qualified trait implementation",
+                "`pub` or `priv` is meaningless for trait implementations, \
+                 because the `impl...for...` form defines overloads for \
+                 methods that already exist; remove the `pub` or `priv`"
+            ),
         };
 
         self.report(sp, kind, kind_str, desc);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index af25a4f6e58dc..59ad35b38e4ff 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -76,6 +76,7 @@ use parse::obsolete::{ObsoleteStructCtor, ObsoleteWith};
 use parse::obsolete::{ObsoleteSyntax, ObsoleteLowerCaseKindBounds};
 use parse::obsolete::{ObsoleteUnsafeBlock, ObsoleteImplSyntax};
 use parse::obsolete::{ObsoleteTraitBoundSeparator, ObsoleteMutOwnedPointer};
+use parse::obsolete::{ObsoleteMutVector, ObsoleteTraitImplVisibility};
 use parse::prec::{as_prec, token_to_binop};
 use parse::token::{can_begin_expr, is_ident, is_ident_or_path};
 use parse::token::{is_plain_ident, INTERPOLATED, special_idents};
@@ -624,6 +625,9 @@ pub impl Parser {
         } else if *self.token == token::LBRACKET {
             self.expect(token::LBRACKET);
             let mt = self.parse_mt();
+            if mt.mutbl == m_mutbl {    // `m_const` too after snapshot
+                self.obsolete(*self.last_span, ObsoleteMutVector);
+            }
 
             // Parse the `* 3` in `[ int * 3 ]`
             let t = match self.maybe_parse_fixed_vstore_with_star() {
@@ -678,7 +682,7 @@ pub impl Parser {
         // reflected in the AST type.
         let mt = self.parse_mt();
 
-        if mt.mutbl == m_mutbl && sigil == OwnedSigil {
+        if mt.mutbl != m_imm && sigil == OwnedSigil {
             self.obsolete(*self.last_span, ObsoleteMutOwnedPointer);
         }
 
@@ -1134,6 +1138,10 @@ pub impl Parser {
         } else if *self.token == token::LBRACKET {
             self.bump();
             let mutbl = self.parse_mutability();
+            if mutbl == m_mutbl {   // `m_const` too after snapshot
+                self.obsolete(*self.last_span, ObsoleteMutVector);
+            }
+
             if *self.token == token::RBRACKET {
                 // Empty vector.
                 self.bump();
@@ -1574,6 +1582,10 @@ pub impl Parser {
           token::TILDE => {
             self.bump();
             let m = self.parse_mutability();
+            if m != m_imm {
+                self.obsolete(*self.last_span, ObsoleteMutOwnedPointer);
+            }
+
             let e = self.parse_prefix_expr();
             hi = e.span.hi;
             // HACK: turn ~[...] into a ~-evec
@@ -2930,9 +2942,9 @@ pub impl Parser {
     }
 
     // Parses two variants (with the region/type params always optional):
-    //    impl<T> ~[T] : to_str { ... }
-    //    impl<T> to_str for ~[T] { ... }
-    fn parse_item_impl() -> item_info {
+    //    impl<T> Foo { ... }
+    //    impl<T> ToStr for ~[T] { ... }
+    fn parse_item_impl(visibility: ast::visibility) -> item_info {
         fn wrap_path(p: Parser, pt: @path) -> @Ty {
             @Ty {
                 id: p.get_id(),
@@ -2981,6 +2993,12 @@ pub impl Parser {
             None
         };
 
+        // Do not allow visibility to be specified in `impl...for...`. It is
+        // meaningless.
+        if opt_trait.is_some() && visibility != ast::inherited {
+            self.obsolete(*self.span, ObsoleteTraitImplVisibility);
+        }
+
         let mut meths = ~[];
         if !self.eat(token::SEMI) {
             self.expect(token::LBRACE);
@@ -3848,7 +3866,8 @@ pub impl Parser {
                                           maybe_append(attrs, extra_attrs)));
         } else if items_allowed && self.eat_keyword(~"impl") {
             // IMPL ITEM
-            let (ident, item_, extra_attrs) = self.parse_item_impl();
+            let (ident, item_, extra_attrs) =
+                self.parse_item_impl(visibility);
             return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_,
                                           visibility,
                                           maybe_append(attrs, extra_attrs)));
diff --git a/src/test/auxiliary/cci_class_cast.rs b/src/test/auxiliary/cci_class_cast.rs
index a2896dad814c2..5006c72ad156b 100644
--- a/src/test/auxiliary/cci_class_cast.rs
+++ b/src/test/auxiliary/cci_class_cast.rs
@@ -17,7 +17,7 @@ pub mod kitty {
       name : ~str,
     }
 
-    pub impl ToStr for cat {
+    impl ToStr for cat {
        pure fn to_str(&self) -> ~str { copy self.name }
     }
 
diff --git a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs
index 2b3fd47e5bc49..f578ad82d6d80 100644
--- a/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs
+++ b/src/test/auxiliary/crate-method-reexport-grrrrrrr2.rs
@@ -19,7 +19,7 @@ pub mod name_pool {
         fn add(s: ~str);
     }
 
-    pub impl add for name_pool {
+    impl add for name_pool {
         fn add(s: ~str) {
         }
     }
@@ -34,7 +34,7 @@ pub mod rust {
         fn cx();
     }
 
-    pub impl cx for rt {
+    impl cx for rt {
         fn cx() {
         }
     }
diff --git a/src/test/auxiliary/issue-3012-1.rs b/src/test/auxiliary/issue-3012-1.rs
index cbc1c4b2fec44..36343d42b7589 100644
--- a/src/test/auxiliary/issue-3012-1.rs
+++ b/src/test/auxiliary/issue-3012-1.rs
@@ -16,7 +16,7 @@ pub mod socket {
         sockfd: libc::c_int,
     }
 
-    pub impl Drop for socket_handle {
+    impl Drop for socket_handle {
         fn finalize(&self) {
             /* c::close(self.sockfd); */
         }
diff --git a/src/test/auxiliary/issue2170lib.rs b/src/test/auxiliary/issue2170lib.rs
index d664ad62edf1d..0690a01744947 100644
--- a/src/test/auxiliary/issue2170lib.rs
+++ b/src/test/auxiliary/issue2170lib.rs
@@ -15,7 +15,7 @@ pub struct rsrc {
   x: i32,
 }
 
-pub impl Drop for rsrc {
+impl Drop for rsrc {
     fn finalize(&self) {
         foo(self.x);
     }
diff --git a/src/test/auxiliary/trait_inheritance_overloading_xc.rs b/src/test/auxiliary/trait_inheritance_overloading_xc.rs
index 2ed3b3b1f5c98..67da2541ca212 100644
--- a/src/test/auxiliary/trait_inheritance_overloading_xc.rs
+++ b/src/test/auxiliary/trait_inheritance_overloading_xc.rs
@@ -17,25 +17,25 @@ pub struct MyInt {
     val: int
 }
 
-pub impl Add<MyInt, MyInt> for MyInt {
+impl Add<MyInt, MyInt> for MyInt {
     pure fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) }
 }
 
-pub impl Sub<MyInt, MyInt> for MyInt {
+impl Sub<MyInt, MyInt> for MyInt {
     pure fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) }
 }
 
-pub impl Mul<MyInt, MyInt> for MyInt {
+impl Mul<MyInt, MyInt> for MyInt {
     pure fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) }
 }
 
-pub impl Eq for MyInt {
+impl Eq for MyInt {
     pure fn eq(&self, other: &MyInt) -> bool { self.val == other.val }
 
     pure fn ne(&self, other: &MyInt) -> bool { !self.eq(other) }
 }
 
-pub impl MyNum for MyInt;
+impl MyNum for MyInt;
 
 pure fn mi(v: int) -> MyInt { MyInt { val: v } }
 
diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs
index 227ea5c1521c0..90ca7c1797c3a 100644
--- a/src/test/compile-fail/issue-3953.rs
+++ b/src/test/compile-fail/issue-3953.rs
@@ -19,7 +19,7 @@ trait Hahaha: Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq Eq //~ ERROR Duplicat
 
 enum Lol = int;
 
-pub impl Hahaha for Lol { }
+impl Hahaha for Lol { }
 
 impl Eq for Lol {
     pure fn eq(&self, other: &Lol) -> bool { **self != **other }
diff --git a/src/test/compile-fail/issue-3969.rs b/src/test/compile-fail/issue-3969.rs
index a003563928738..e2bf708feabc7 100644
--- a/src/test/compile-fail/issue-3969.rs
+++ b/src/test/compile-fail/issue-3969.rs
@@ -16,7 +16,7 @@ trait BikeMethods {
     fn woops(&const self) -> ~str;
 }
 
-pub impl BikeMethods for Bike {
+impl BikeMethods for Bike {
     static fn woops(&const self) -> ~str { ~"foo" }
     //~^ ERROR method `woops` is declared as static in its impl, but not in its trait
 }
diff --git a/src/test/compile-fail/mutable-huh-unique-assign.rs b/src/test/compile-fail/mutable-huh-unique-assign.rs
deleted file mode 100644
index 8b59879acd979..0000000000000
--- a/src/test/compile-fail/mutable-huh-unique-assign.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
-    fn f(&&v: ~const int) {
-        *v = 1 //~ ERROR assigning to dereference of const ~ pointer
-    }
-
-    let v = ~0;
-
-    f(v);
-}
diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index 6ad3344599734..72f6d23cacce1 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -9,10 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    // Once cast_to_mut is removed, pick a better function to import
-    // for this test!
-    use vec::cast_to_mut;
-    log(debug, vec::len(cast_to_mut(~[1, 2])));
+    use vec::from_fn;
+    log(debug, vec::len(from_fn(2, |i| i)));
     {
         use vec::*;
         log(debug, len(~[2]));
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index b97ebb04f716d..4a7263266b78f 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -155,7 +155,7 @@ pub mod pipes {
         p: Option<*packet<T>>,
     }
 
-    pub impl<T:Owned> Drop for send_packet<T> {
+    impl<T:Owned> Drop for send_packet<T> {
         fn finalize(&self) {
             unsafe {
                 if self.p != None {
@@ -187,7 +187,7 @@ pub mod pipes {
         p: Option<*packet<T>>,
     }
 
-    pub impl<T:Owned> Drop for recv_packet<T> {
+    impl<T:Owned> Drop for recv_packet<T> {
         fn finalize(&self) {
             unsafe {
                 if self.p != None {
diff --git a/src/test/run-pass/pipe-presentation-examples.rs b/src/test/run-pass/pipe-presentation-examples.rs
index 85ab1f89dbeca..8749c1cb1133b 100644
--- a/src/test/run-pass/pipe-presentation-examples.rs
+++ b/src/test/run-pass/pipe-presentation-examples.rs
@@ -79,7 +79,7 @@ pub struct Buffer {
 
 }
 
-pub impl Drop for Buffer {
+impl Drop for Buffer {
     fn finalize(&self) {}
 }
 
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 201193fd738e8..d1b2870fef627 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -16,12 +16,12 @@ pub trait plus {
 
 mod a {
     use plus;
-    pub impl plus for uint { fn plus() -> int { self as int + 20 } }
+    impl plus for uint { fn plus() -> int { self as int + 20 } }
 }
 
 mod b {
     use plus;
-    pub impl plus for ~str { fn plus() -> int { 200 } }
+    impl plus for ~str { fn plus() -> int { 200 } }
 }
 
 trait uint_utils {
diff --git a/src/test/run-pass/static-methods-in-traits2.rs b/src/test/run-pass/static-methods-in-traits2.rs
index b4c28fd52a64c..20ab9014c700b 100644
--- a/src/test/run-pass/static-methods-in-traits2.rs
+++ b/src/test/run-pass/static-methods-in-traits2.rs
@@ -2,7 +2,7 @@ pub trait Number: NumConv {
     static pure fn from<T:Number>(n: T) -> Self;
 }
 
-pub impl Number for float {
+impl Number for float {
     static pure fn from<T:Number>(n: T) -> float { n.to_float() }
 }
 
@@ -10,7 +10,7 @@ pub trait NumConv {
     pure fn to_float(&self) -> float;
 }
 
-pub impl NumConv for float {
+impl NumConv for float {
     pure fn to_float(&self) -> float { *self }
 }
 
diff --git a/src/test/run-pass/trait-inheritance-num2.rs b/src/test/run-pass/trait-inheritance-num2.rs
index 64b30d71e1dff..f20181d22d344 100644
--- a/src/test/run-pass/trait-inheritance-num2.rs
+++ b/src/test/run-pass/trait-inheritance-num2.rs
@@ -21,84 +21,84 @@ use std::cmp::FuzzyEq;
 pub trait TypeExt {}
 
 
-pub impl TypeExt for u8 {}
-pub impl TypeExt for u16 {}
-pub impl TypeExt for u32 {}
-pub impl TypeExt for u64 {}
-pub impl TypeExt for uint {}
+impl TypeExt for u8 {}
+impl TypeExt for u16 {}
+impl TypeExt for u32 {}
+impl TypeExt for u64 {}
+impl TypeExt for uint {}
 
-pub impl TypeExt for i8 {}
-pub impl TypeExt for i16 {}
-pub impl TypeExt for i32 {}
-pub impl TypeExt for i64 {}
-pub impl TypeExt for int {}
+impl TypeExt for i8 {}
+impl TypeExt for i16 {}
+impl TypeExt for i32 {}
+impl TypeExt for i64 {}
+impl TypeExt for int {}
 
-pub impl TypeExt for f32 {}
-pub impl TypeExt for f64 {}
-pub impl TypeExt for float {}
+impl TypeExt for f32 {}
+impl TypeExt for f64 {}
+impl TypeExt for float {}
 
 
 pub trait NumExt: TypeExt Eq Ord NumCast {}
 
-pub impl NumExt for u8 {}
-pub impl NumExt for u16 {}
-pub impl NumExt for u32 {}
-pub impl NumExt for u64 {}
-pub impl NumExt for uint {}
+impl NumExt for u8 {}
+impl NumExt for u16 {}
+impl NumExt for u32 {}
+impl NumExt for u64 {}
+impl NumExt for uint {}
 
-pub impl NumExt for i8 {}
-pub impl NumExt for i16 {}
-pub impl NumExt for i32 {}
-pub impl NumExt for i64 {}
-pub impl NumExt for int {}
+impl NumExt for i8 {}
+impl NumExt for i16 {}
+impl NumExt for i32 {}
+impl NumExt for i64 {}
+impl NumExt for int {}
 
-pub impl NumExt for f32 {}
-pub impl NumExt for f64 {}
-pub impl NumExt for float {}
+impl NumExt for f32 {}
+impl NumExt for f64 {}
+impl NumExt for float {}
 
 
 pub trait UnSignedExt: NumExt {}
 
-pub impl UnSignedExt for u8 {}
-pub impl UnSignedExt for u16 {}
-pub impl UnSignedExt for u32 {}
-pub impl UnSignedExt for u64 {}
-pub impl UnSignedExt for uint {}
+impl UnSignedExt for u8 {}
+impl UnSignedExt for u16 {}
+impl UnSignedExt for u32 {}
+impl UnSignedExt for u64 {}
+impl UnSignedExt for uint {}
 
 
 pub trait SignedExt: NumExt {}
 
-pub impl SignedExt for i8 {}
-pub impl SignedExt for i16 {}
-pub impl SignedExt for i32 {}
-pub impl SignedExt for i64 {}
-pub impl SignedExt for int {}
+impl SignedExt for i8 {}
+impl SignedExt for i16 {}
+impl SignedExt for i32 {}
+impl SignedExt for i64 {}
+impl SignedExt for int {}
 
-pub impl SignedExt for f32 {}
-pub impl SignedExt for f64 {}
-pub impl SignedExt for float {}
+impl SignedExt for f32 {}
+impl SignedExt for f64 {}
+impl SignedExt for float {}
 
 
 pub trait IntegerExt: NumExt {}
 
-pub impl IntegerExt for u8 {}
-pub impl IntegerExt for u16 {}
-pub impl IntegerExt for u32 {}
-pub impl IntegerExt for u64 {}
-pub impl IntegerExt for uint {}
+impl IntegerExt for u8 {}
+impl IntegerExt for u16 {}
+impl IntegerExt for u32 {}
+impl IntegerExt for u64 {}
+impl IntegerExt for uint {}
 
-pub impl IntegerExt for i8 {}
-pub impl IntegerExt for i16 {}
-pub impl IntegerExt for i32 {}
-pub impl IntegerExt for i64 {}
-pub impl IntegerExt for int {}
+impl IntegerExt for i8 {}
+impl IntegerExt for i16 {}
+impl IntegerExt for i32 {}
+impl IntegerExt for i64 {}
+impl IntegerExt for int {}
 
 
 pub trait FloatExt: NumExt FuzzyEq<Self> {}
 
-pub impl FloatExt for f32 {}
-pub impl FloatExt for f64 {}
-pub impl FloatExt for float {}
+impl FloatExt for f32 {}
+impl FloatExt for f64 {}
+impl FloatExt for float {}
 
 
 fn test_float_ext<T:FloatExt>(n: T) { io::println(fmt!("%?", n < n)) }
diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs
index f184ab2741a1d..adb9f01fff8a8 100644
--- a/src/test/run-pass/trait-inheritance-num3.rs
+++ b/src/test/run-pass/trait-inheritance-num3.rs
@@ -13,7 +13,7 @@ use num::NumCast::from;
 
 pub trait NumExt: Eq Ord NumCast {}
 
-pub impl NumExt for f32 {}
+impl NumExt for f32 {}
 
 fn num_eq_one<T:NumExt>(n: T) { io::println(fmt!("%?", n == from(1))) }
 
diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs
index 692d50e541a97..d10126dddb6cc 100644
--- a/src/test/run-pass/trait-inheritance-num5.rs
+++ b/src/test/run-pass/trait-inheritance-num5.rs
@@ -13,8 +13,8 @@ use num::NumCast::from;
 
 pub trait NumExt: Eq NumCast {}
 
-pub impl NumExt for f32 {}
-pub impl NumExt for int {}
+impl NumExt for f32 {}
+impl NumExt for int {}
 
 fn num_eq_one<T:NumExt>() -> T {
     from(1)
diff --git a/src/test/run-pass/trait-static-method-overwriting.rs b/src/test/run-pass/trait-static-method-overwriting.rs
index d416f3f6c910e..9565919a5d8c7 100644
--- a/src/test/run-pass/trait-static-method-overwriting.rs
+++ b/src/test/run-pass/trait-static-method-overwriting.rs
@@ -19,7 +19,7 @@ mod base {
         dummy: (),
     }
 
-    pub impl ::base::HasNew<Foo> for Foo {
+    impl ::base::HasNew<Foo> for Foo {
         static pure fn new() -> Foo {
 			unsafe { io::println("Foo"); }
             Foo { dummy: () }
@@ -30,7 +30,7 @@ mod base {
         dummy: (),
     }
 
-    pub impl ::base::HasNew<Bar> for Bar {
+    impl ::base::HasNew<Bar> for Bar {
         static pure fn new() -> Bar {
 			unsafe { io::println("Bar"); }
             Bar { dummy: () }