diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
index 5774a0485cb..213e8b44813 100644
--- a/src/librustc/lint/builtin.rs
+++ b/src/librustc/lint/builtin.rs
@@ -412,26 +412,16 @@ impl LintPass for CTypes {
     }
 }
 
-declare_lint!(MANAGED_HEAP_MEMORY, Allow,
-              "use of managed (@ type) heap memory")
-
 declare_lint!(OWNED_HEAP_MEMORY, Allow,
               "use of owned (Box type) heap memory")
 
-declare_lint!(HEAP_MEMORY, Allow,
-              "use of any (Box type or @ type) heap memory")
-
 pub struct HeapMemory;
 
 impl HeapMemory {
     fn check_heap_type(&self, cx: &Context, span: Span, ty: ty::t) {
-        let mut n_box = 0i;
         let mut n_uniq = 0i;
         ty::fold_ty(cx.tcx, ty, |t| {
             match ty::get(t).sty {
-                ty::ty_box(_) => {
-                    n_box += 1;
-                }
                 ty::ty_uniq(_) |
                 ty::ty_closure(box ty::ClosureTy {
                     store: ty::UniqTraitStore,
@@ -449,21 +439,13 @@ impl HeapMemory {
             let s = ty_to_string(cx.tcx, ty);
             let m = format!("type uses owned (Box type) pointers: {}", s);
             cx.span_lint(OWNED_HEAP_MEMORY, span, m.as_slice());
-            cx.span_lint(HEAP_MEMORY, span, m.as_slice());
-        }
-
-        if n_box > 0 {
-            let s = ty_to_string(cx.tcx, ty);
-            let m = format!("type uses managed (@ type) pointers: {}", s);
-            cx.span_lint(MANAGED_HEAP_MEMORY, span, m.as_slice());
-            cx.span_lint(HEAP_MEMORY, span, m.as_slice());
         }
     }
 }
 
 impl LintPass for HeapMemory {
     fn get_lints(&self) -> LintArray {
-        lint_array!(MANAGED_HEAP_MEMORY, OWNED_HEAP_MEMORY, HEAP_MEMORY)
+        lint_array!(OWNED_HEAP_MEMORY)
     }
 
     fn check_item(&mut self, cx: &Context, it: &ast::Item) {
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index ce5494ef477..a07518cf3f2 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -397,7 +397,6 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         assert_eq!(next(st), '|');
         return ty::mk_param(st.tcx, space, index, did);
       }
-      '@' => return ty::mk_box(st.tcx, parse_ty(st, |x,y| conv(x,y))),
       '~' => return ty::mk_uniq(st.tcx, parse_ty(st, |x,y| conv(x,y))),
       '*' => return ty::mk_ptr(st.tcx, parse_mt(st, |x,y| conv(x,y))),
       '&' => {
diff --git a/src/librustc/metadata/tyencode.rs b/src/librustc/metadata/tyencode.rs
index fd3e4fe6738..e3d8d0e5375 100644
--- a/src/librustc/metadata/tyencode.rs
+++ b/src/librustc/metadata/tyencode.rs
@@ -244,7 +244,6 @@ fn enc_sty(w: &mut SeekableMemWriter, cx: &ctxt, st: &ty::sty) {
             for t in ts.iter() { enc_ty(w, cx, *t); }
             mywrite!(w, "]");
         }
-        ty::ty_box(typ) => { mywrite!(w, "@"); enc_ty(w, cx, typ); }
         ty::ty_uniq(typ) => { mywrite!(w, "~"); enc_ty(w, cx, typ); }
         ty::ty_ptr(mt) => { mywrite!(w, "*"); enc_mt(w, cx, mt); }
         ty::ty_rptr(r, mt) => {
diff --git a/src/librustc/middle/borrowck/check_loans.rs b/src/librustc/middle/borrowck/check_loans.rs
index a5111cdf7c8..e114eb88705 100644
--- a/src/librustc/middle/borrowck/check_loans.rs
+++ b/src/librustc/middle/borrowck/check_loans.rs
@@ -815,11 +815,6 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                         return;
                     }
 
-                    mc::cat_deref(_, _, mc::GcPtr) => {
-                        assert_eq!(cmt.mutbl, mc::McImmutable);
-                        return;
-                    }
-
                     mc::cat_rvalue(..) |
                     mc::cat_static_item |
                     mc::cat_deref(_, _, mc::UnsafePtr(..)) |
diff --git a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
index 25439fce68c..1ae512a244c 100644
--- a/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
+++ b/src/librustc/middle/borrowck/gather_loans/gather_moves.rs
@@ -132,7 +132,6 @@ fn check_and_get_illegal_move_origin(bccx: &BorrowckCtxt,
     match cmt.cat {
         mc::cat_deref(_, _, mc::BorrowedPtr(..)) |
         mc::cat_deref(_, _, mc::Implicit(..)) |
-        mc::cat_deref(_, _, mc::GcPtr) |
         mc::cat_deref(_, _, mc::UnsafePtr(..)) |
         mc::cat_upvar(..) | mc::cat_static_item |
         mc::cat_copied_upvar(mc::CopiedUpvar { onceness: ast::Many, .. }) => {
diff --git a/src/librustc/middle/borrowck/gather_loans/lifetime.rs b/src/librustc/middle/borrowck/gather_loans/lifetime.rs
index c0712332525..8ec58fe0eee 100644
--- a/src/librustc/middle/borrowck/gather_loans/lifetime.rs
+++ b/src/librustc/middle/borrowck/gather_loans/lifetime.rs
@@ -82,8 +82,7 @@ impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
 
             mc::cat_downcast(ref base) |
             mc::cat_deref(ref base, _, mc::OwnedPtr) |     // L-Deref-Send
-            mc::cat_interior(ref base, _) |                // L-Field
-            mc::cat_deref(ref base, _, mc::GcPtr) => {
+            mc::cat_interior(ref base, _) => {             // L-Field
                 self.check(base, discr_scope)
             }
 
@@ -185,7 +184,6 @@ impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
             }
             mc::cat_downcast(ref cmt) |
             mc::cat_deref(ref cmt, _, mc::OwnedPtr) |
-            mc::cat_deref(ref cmt, _, mc::GcPtr) |
             mc::cat_interior(ref cmt, _) |
             mc::cat_discr(ref cmt, _) => {
                 self.scope(cmt)
diff --git a/src/librustc/middle/borrowck/gather_loans/move_error.rs b/src/librustc/middle/borrowck/gather_loans/move_error.rs
index b826768c937..1b18d07f590 100644
--- a/src/librustc/middle/borrowck/gather_loans/move_error.rs
+++ b/src/librustc/middle/borrowck/gather_loans/move_error.rs
@@ -114,7 +114,6 @@ fn report_cannot_move_out_of(bccx: &BorrowckCtxt, move_from: mc::cmt) {
     match move_from.cat {
         mc::cat_deref(_, _, mc::BorrowedPtr(..)) |
         mc::cat_deref(_, _, mc::Implicit(..)) |
-        mc::cat_deref(_, _, mc::GcPtr) |
         mc::cat_deref(_, _, mc::UnsafePtr(..)) |
         mc::cat_upvar(..) | mc::cat_static_item |
         mc::cat_copied_upvar(mc::CopiedUpvar { onceness: ast::Many, .. }) => {
diff --git a/src/librustc/middle/borrowck/gather_loans/restrictions.rs b/src/librustc/middle/borrowck/gather_loans/restrictions.rs
index e0018919b98..067a73fcc9b 100644
--- a/src/librustc/middle/borrowck/gather_loans/restrictions.rs
+++ b/src/librustc/middle/borrowck/gather_loans/restrictions.rs
@@ -101,16 +101,13 @@ impl<'a, 'tcx> RestrictionsContext<'a, 'tcx> {
                 self.extend(result, cmt.mutbl, LpInterior(i))
             }
 
-            mc::cat_deref(cmt_base, _, pk @ mc::OwnedPtr) |
-            mc::cat_deref(cmt_base, _, pk @ mc::GcPtr) => {
+            mc::cat_deref(cmt_base, _, pk @ mc::OwnedPtr) => {
                 // R-Deref-Send-Pointer
                 //
                 // When we borrow the interior of an owned pointer, we
                 // cannot permit the base to be mutated, because that
                 // would cause the unique pointer to be freed.
                 //
-                // For a managed pointer, the rules are basically the
-                // same, because this could be the last ref.
                 // Eventually we should make these non-special and
                 // just rely on Deref<T> implementation.
                 let result = self.restrict(cmt_base);
diff --git a/src/librustc/middle/borrowck/mod.rs b/src/librustc/middle/borrowck/mod.rs
index b411620dac0..234afc7ae7a 100644
--- a/src/librustc/middle/borrowck/mod.rs
+++ b/src/librustc/middle/borrowck/mod.rs
@@ -730,11 +730,6 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                     span,
                     format!("{} in a static location", prefix).as_slice());
             }
-            mc::AliasableManaged => {
-                self.tcx.sess.span_err(
-                    span,
-                    format!("{} in a `Gc` pointer", prefix).as_slice());
-            }
             mc::AliasableBorrowed => {
                 self.tcx.sess.span_err(
                     span,
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index bef63ec3153..90d75b9554b 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -440,11 +440,6 @@ fn construct_witness(cx: &MatchCheckCtxt, ctor: &Constructor,
             }
         }
 
-        ty::ty_box(_) => {
-            assert_eq!(pats_len, 1);
-            PatBox(pats.nth(0).unwrap())
-        }
-
         ty::ty_vec(_, Some(len)) => {
             assert_eq!(pats_len, len);
             PatVec(pats.collect(), None, vec![])
@@ -681,7 +676,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
 pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: ty::t) -> uint {
     match ty::get(ty).sty {
         ty::ty_tup(ref fs) => fs.len(),
-        ty::ty_box(_) | ty::ty_uniq(_) => 1u,
+        ty::ty_uniq(_) => 1u,
         ty::ty_rptr(_, ty::mt { ty: ty, .. }) => match ty::get(ty).sty {
             ty::ty_vec(_, None) => match *ctor {
                 Slice(length) => length,
diff --git a/src/librustc/middle/intrinsicck.rs b/src/librustc/middle/intrinsicck.rs
index dccb93f58cc..de291595ccc 100644
--- a/src/librustc/middle/intrinsicck.rs
+++ b/src/librustc/middle/intrinsicck.rs
@@ -28,8 +28,8 @@ fn type_size_is_affected_by_type_parameters(tcx: &ty::ctxt, typ: ty::t)
     let mut result = false;
     ty::maybe_walk_ty(typ, |typ| {
         match ty::get(typ).sty {
-            ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_ptr(_) |
-            ty::ty_rptr(..) | ty::ty_bare_fn(..) | ty::ty_closure(..) => {
+            ty::ty_uniq(_) | ty::ty_ptr(_) | ty::ty_rptr(..) |
+            ty::ty_bare_fn(..) | ty::ty_closure(..) => {
                 false
             }
             ty::ty_param(_) => {
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index 50c92b45fdf..3c9ebd86b94 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -279,8 +279,6 @@ lets_do_this! {
 
     ExchangeMallocFnLangItem,        "exchange_malloc",         exchange_malloc_fn;
     ExchangeFreeFnLangItem,          "exchange_free",           exchange_free_fn;
-    MallocFnLangItem,                "malloc",                  malloc_fn;
-    FreeFnLangItem,                  "free",                    free_fn;
     StrDupUniqFnLangItem,            "strdup_uniq",             strdup_uniq_fn;
 
     StartFnLangItem,                 "start",                   start_fn;
@@ -293,9 +291,7 @@ lets_do_this! {
 
     EhPersonalityLangItem,           "eh_personality",          eh_personality;
 
-    ManagedHeapLangItem,             "managed_heap",            managed_heap;
     ExchangeHeapLangItem,            "exchange_heap",           exchange_heap;
-    GcLangItem,                      "gc",                      gc;
     OwnedBoxLangItem,                "owned_box",               owned_box;
 
     CovariantTypeItem,               "covariant_type",          covariant_type;
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index bb44b1f55cb..273360c9279 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -104,7 +104,6 @@ pub struct CopiedUpvar {
 #[deriving(Clone, PartialEq, Eq, Hash)]
 pub enum PointerKind {
     OwnedPtr,
-    GcPtr,
     BorrowedPtr(ty::BorrowKind, ty::Region),
     Implicit(ty::BorrowKind, ty::Region),     // Implicit deref of a borrowed ptr.
     UnsafePtr(ast::Mutability)
@@ -191,10 +190,6 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             Some(deref_ptr(BorrowedPtr(ty::ImmBorrow, r)))
         }
 
-        ty::ty_box(..) => {
-            Some(deref_ptr(GcPtr))
-        }
-
         ty::ty_ptr(ref mt) => {
             Some(deref_ptr(UnsafePtr(mt.mutbl)))
         }
@@ -302,9 +297,6 @@ impl MutabilityCategory {
             BorrowedPtr(borrow_kind, _) | Implicit(borrow_kind, _) => {
                 MutabilityCategory::from_borrow_kind(borrow_kind)
             }
-            GcPtr => {
-                McImmutable
-            }
             UnsafePtr(m) => {
                 MutabilityCategory::from_mutbl(m)
             }
@@ -1200,7 +1192,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                           Implicit(..) => {
                             "dereference (dereference is implicit, due to indexing)".to_string()
                           }
-                          OwnedPtr | GcPtr => format!("dereference of `{}`", ptr_sigil(pk)),
+                          OwnedPtr => format!("dereference of `{}`", ptr_sigil(pk)),
                           _ => format!("dereference of `{}`-pointer", ptr_sigil(pk))
                       }
                   }
@@ -1237,7 +1229,6 @@ pub enum InteriorSafety {
 }
 
 pub enum AliasableReason {
-    AliasableManaged,
     AliasableBorrowed,
     AliasableOther,
     AliasableStatic(InteriorSafety),
@@ -1256,7 +1247,6 @@ impl cmt_ {
             cat_copied_upvar(..) |
             cat_local(..) |
             cat_deref(_, _, UnsafePtr(..)) |
-            cat_deref(_, _, GcPtr(..)) |
             cat_deref(_, _, BorrowedPtr(..)) |
             cat_deref(_, _, Implicit(..)) |
             cat_upvar(..) => {
@@ -1320,10 +1310,6 @@ impl cmt_ {
                 }
             }
 
-            cat_deref(_, _, GcPtr) => {
-                Some(AliasableManaged)
-            }
-
             cat_deref(_, _, BorrowedPtr(ty::ImmBorrow, _)) |
             cat_deref(_, _, Implicit(ty::ImmBorrow, _)) => {
                 Some(AliasableBorrowed)
@@ -1371,7 +1357,6 @@ impl Repr for categorization {
 pub fn ptr_sigil(ptr: PointerKind) -> &'static str {
     match ptr {
         OwnedPtr => "Box",
-        GcPtr => "Gc",
         BorrowedPtr(ty::ImmBorrow, _) |
         Implicit(ty::ImmBorrow, _) => "&",
         BorrowedPtr(ty::MutBorrow, _) |
diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs
index 9b179d3e895..080f9ff5bc7 100644
--- a/src/librustc/middle/traits/coherence.rs
+++ b/src/librustc/middle/traits/coherence.rs
@@ -104,11 +104,6 @@ pub fn ty_is_local(tcx: &ty::ctxt,
             krate == Some(ast::LOCAL_CRATE) || ty_is_local(tcx, t)
         }
 
-        ty::ty_box(t) => {
-            let krate = tcx.lang_items.gc().map(|d| d.krate);
-            krate == Some(ast::LOCAL_CRATE) || ty_is_local(tcx, t)
-        }
-
         ty::ty_vec(t, _) |
         ty::ty_ptr(ty::mt { ty: t, .. }) |
         ty::ty_rptr(_, ty::mt { ty: t, .. }) => {
diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs
index 61477fdeed5..b86fabccf93 100644
--- a/src/librustc/middle/traits/select.rs
+++ b/src/librustc/middle/traits/select.rs
@@ -713,23 +713,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 ok(self, Always)
             }
 
-            ty::ty_box(_) => {
-                match bound {
-                    ty::BoundSync |
-                    ty::BoundSend |
-                    ty::BoundCopy => {
-                        // Managed data is not copyable, sendable, nor
-                        // synchronized, regardless of referent.
-                        ok(self, Never)
-                    }
-
-                    ty::BoundSized => {
-                        // But it is sized, regardless of referent.
-                        ok(self, Always)
-                    }
-                }
-            }
-
             ty::ty_uniq(referent_ty) => {  // Box<T>
                 match bound {
                     ty::BoundCopy => {
diff --git a/src/librustc/middle/trans/adt.rs b/src/librustc/middle/trans/adt.rs
index 4d8e0145901..506b12de084 100644
--- a/src/librustc/middle/trans/adt.rs
+++ b/src/librustc/middle/trans/adt.rs
@@ -321,9 +321,6 @@ impl Case {
                     _ => return Some(ThinPointer(i))
                 },
 
-                // Gc<T> is just a pointer
-                ty::ty_box(..) => return Some(ThinPointer(i)),
-
                 // Functions are just pointers
                 ty::ty_bare_fn(..) => return Some(ThinPointer(i)),
 
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 03045777155..f65827753aa 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -397,36 +397,6 @@ pub fn malloc_raw_dyn_proc<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: ty::t) -> Resu
     Result::new(bcx, llbox)
 }
 
-
-pub fn malloc_raw_dyn_managed<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                          t: ty::t,
-                                          alloc_fn: LangItem,
-                                          size: ValueRef)
-                                          -> Result<'blk, 'tcx> {
-    let _icx = push_ctxt("malloc_raw_dyn_managed");
-    let ccx = bcx.ccx();
-
-    let langcall = require_alloc_fn(bcx, t, alloc_fn);
-
-    // Grab the TypeRef type of box_ptr_ty.
-    let box_ptr_ty = ty::mk_box(bcx.tcx(), t);
-    let llty = type_of(ccx, box_ptr_ty);
-    let llalign = C_uint(ccx, type_of::align_of(ccx, box_ptr_ty) as uint);
-
-    // Allocate space:
-    let drop_glue = glue::get_drop_glue(ccx, t);
-    let r = callee::trans_lang_call(
-        bcx,
-        langcall,
-        [
-            PointerCast(bcx, drop_glue, Type::glue_fn(ccx, Type::i8p(ccx)).ptr_to()),
-            size,
-            llalign
-        ],
-        None);
-    Result::new(r.bcx, PointerCast(r.bcx, r.val, llty))
-}
-
 // Type descriptor and type glue stuff
 
 pub fn get_tydesc(ccx: &CrateContext, t: ty::t) -> Rc<tydesc_info> {
diff --git a/src/librustc/middle/trans/cleanup.rs b/src/librustc/middle/trans/cleanup.rs
index 35464be0e43..20fd0b0eb3d 100644
--- a/src/librustc/middle/trans/cleanup.rs
+++ b/src/librustc/middle/trans/cleanup.rs
@@ -960,7 +960,6 @@ impl Cleanup for DropValue {
 }
 
 pub enum Heap {
-    HeapManaged,
     HeapExchange
 }
 
@@ -986,9 +985,6 @@ impl Cleanup for FreeValue {
         apply_debug_loc(bcx.fcx, debug_loc);
 
         match self.heap {
-            HeapManaged => {
-                glue::trans_free(bcx, self.ptr)
-            }
             HeapExchange => {
                 glue::trans_exchange_free_ty(bcx, self.ptr, self.content_ty)
             }
@@ -1019,9 +1015,6 @@ impl Cleanup for FreeSlice {
         apply_debug_loc(bcx.fcx, debug_loc);
 
         match self.heap {
-            HeapManaged => {
-                glue::trans_free(bcx, self.ptr)
-            }
             HeapExchange => {
                 glue::trans_exchange_free_dyn(bcx, self.ptr, self.size, self.align)
             }
diff --git a/src/librustc/middle/trans/common.rs b/src/librustc/middle/trans/common.rs
index 30f91c82930..7daee22e614 100644
--- a/src/librustc/middle/trans/common.rs
+++ b/src/librustc/middle/trans/common.rs
@@ -71,7 +71,7 @@ pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool {
     use middle::trans::type_of::sizing_type_of;
 
     let tcx = ccx.tcx();
-    let simple = ty::type_is_scalar(ty) || ty::type_is_boxed(ty) ||
+    let simple = ty::type_is_scalar(ty) ||
         ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
         type_is_newtype_immediate(ccx, ty) || ty::type_is_bot(ty) ||
         ty::type_is_simd(tcx, ty);
diff --git a/src/librustc/middle/trans/datum.rs b/src/librustc/middle/trans/datum.rs
index 84d9f2cb740..260bde0f07f 100644
--- a/src/librustc/middle/trans/datum.rs
+++ b/src/librustc/middle/trans/datum.rs
@@ -20,7 +20,6 @@ use middle::trans::common::*;
 use middle::trans::cleanup;
 use middle::trans::cleanup::CleanupMethods;
 use middle::trans::expr;
-use middle::trans::glue;
 use middle::trans::tvec;
 use middle::trans::type_of;
 use middle::ty;
@@ -240,14 +239,9 @@ impl KindOps for Lvalue {
          */
 
         if ty::type_needs_drop(bcx.tcx(), ty) {
-            if ty::type_moves_by_default(bcx.tcx(), ty) {
-                // cancel cleanup of affine values by zeroing out
-                let () = zero_mem(bcx, val, ty);
-                bcx
-            } else {
-                // incr. refcount for @T or newtype'd @T
-                glue::take_ty(bcx, val, ty)
-            }
+            // cancel cleanup of affine values by zeroing out
+            let () = zero_mem(bcx, val, ty);
+            bcx
         } else {
             bcx
         }
@@ -567,15 +561,15 @@ impl<K:KindOps> Datum<K> {
          * is moved).
          */
 
-        self.shallow_copy(bcx, dst);
+        self.shallow_copy_raw(bcx, dst);
 
         self.kind.post_store(bcx, self.val, self.ty)
     }
 
-    fn shallow_copy<'blk, 'tcx>(&self,
-                                bcx: Block<'blk, 'tcx>,
-                                dst: ValueRef)
-                                -> Block<'blk, 'tcx> {
+    fn shallow_copy_raw<'blk, 'tcx>(&self,
+                                    bcx: Block<'blk, 'tcx>,
+                                    dst: ValueRef)
+                                    -> Block<'blk, 'tcx> {
         /*!
          * Helper function that performs a shallow copy of this value
          * into `dst`, which should be a pointer to a memory location
@@ -584,10 +578,9 @@ impl<K:KindOps> Datum<K> {
          *
          * This function is private to datums because it leaves memory
          * in an unstable state, where the source value has been
-         * copied but not zeroed. Public methods are `store_to` (if
-         * you no longer need the source value) or
-         * `shallow_copy_and_take` (if you wish the source value to
-         * remain valid).
+         * copied but not zeroed. Public methods are `store_to`
+         * (if you no longer need the source value) or `shallow_copy`
+         * (if you wish the source value to remain valid).
          */
 
         let _icx = push_ctxt("copy_to_no_check");
@@ -605,22 +598,19 @@ impl<K:KindOps> Datum<K> {
         return bcx;
     }
 
-    pub fn shallow_copy_and_take<'blk, 'tcx>(&self,
-                                             bcx: Block<'blk, 'tcx>,
-                                             dst: ValueRef)
-                                             -> Block<'blk, 'tcx> {
+    pub fn shallow_copy<'blk, 'tcx>(&self,
+                                    bcx: Block<'blk, 'tcx>,
+                                    dst: ValueRef)
+                                    -> Block<'blk, 'tcx> {
         /*!
-         * Copies the value into a new location and runs any necessary
-         * take glue on the new location. This function always
+         * Copies the value into a new location. This function always
          * preserves the existing datum as a valid value. Therefore,
          * it does not consume `self` and, also, cannot be applied to
          * affine values (since they must never be duplicated).
          */
 
         assert!(!ty::type_moves_by_default(bcx.tcx(), self.ty));
-        let mut bcx = bcx;
-        bcx = self.shallow_copy(bcx, dst);
-        glue::take_ty(bcx, dst, self.ty)
+        self.shallow_copy_raw(bcx, dst)
     }
 
     #[allow(dead_code)] // useful for debugging
diff --git a/src/librustc/middle/trans/debuginfo.rs b/src/librustc/middle/trans/debuginfo.rs
index dc328833d54..a29fd7f6ceb 100644
--- a/src/librustc/middle/trans/debuginfo.rs
+++ b/src/librustc/middle/trans/debuginfo.rs
@@ -373,12 +373,6 @@ impl TypeMap {
                     unique_type_id.push_str(component_type_id.as_slice());
                 }
             },
-            ty::ty_box(inner_type) => {
-                unique_type_id.push_char('@');
-                let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
-                let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
-                unique_type_id.push_str(inner_type_id.as_slice());
-            },
             ty::ty_uniq(inner_type) => {
                 unique_type_id.push_char('~');
                 let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
@@ -596,18 +590,6 @@ impl TypeMap {
         let interner_key = self.unique_id_interner.intern(Rc::new(enum_variant_type_id));
         UniqueTypeId(interner_key)
     }
-
-    fn get_unique_type_id_of_gc_box(&mut self,
-                                    cx: &CrateContext,
-                                    element_type: ty::t)
-                                 -> UniqueTypeId {
-        let element_type_id = self.get_unique_type_id_of_type(cx, element_type);
-        let gc_box_type_id = format!("{{GC_BOX<{}>}}",
-                                     self.get_unique_type_id_as_string(element_type_id)
-                                         .as_slice());
-        let interner_key = self.unique_id_interner.intern(Rc::new(gc_box_type_id));
-        UniqueTypeId(interner_key)
-    }
 }
 
 // Returns from the enclosing function if the type metadata with the given
@@ -2646,105 +2628,6 @@ fn create_struct_stub(cx: &CrateContext,
     return metadata_stub;
 }
 
-fn at_box_metadata(cx: &CrateContext,
-                   at_pointer_type: ty::t,
-                   content_type: ty::t,
-                   unique_type_id: UniqueTypeId)
-                -> MetadataCreationResult {
-    let content_type_metadata = type_metadata(cx, content_type, codemap::DUMMY_SP);
-
-    return_if_metadata_created_in_meantime!(cx, unique_type_id);
-
-    let content_type_name = compute_debuginfo_type_name(cx, content_type, true);
-    let content_type_name = content_type_name.as_slice();
-    let content_llvm_type = type_of::type_of(cx, content_type);
-
-    let box_type_name = format!("GcBox<{}>", content_type_name);
-    let box_llvm_type = Type::at_box(cx, content_llvm_type);
-    let member_llvm_types = box_llvm_type.field_types();
-    assert!(box_layout_is_correct(cx,
-                                  member_llvm_types.as_slice(),
-                                  content_llvm_type));
-
-    let int_type = ty::mk_int();
-    let nil_pointer_type = ty::mk_nil_ptr(cx.tcx());
-    let nil_pointer_type_metadata = type_metadata(cx,
-                                                  nil_pointer_type,
-                                                  codemap::DUMMY_SP);
-    let member_descriptions = [
-        MemberDescription {
-            name: "refcnt".to_string(),
-            llvm_type: *member_llvm_types.get(0),
-            type_metadata: type_metadata(cx, int_type, codemap::DUMMY_SP),
-            offset: ComputedMemberOffset,
-            flags: FLAGS_ARTIFICAL,
-        },
-        MemberDescription {
-            name: "drop_glue".to_string(),
-            llvm_type: *member_llvm_types.get(1),
-            type_metadata: nil_pointer_type_metadata,
-            offset: ComputedMemberOffset,
-            flags: FLAGS_ARTIFICAL,
-        },
-        MemberDescription {
-            name: "prev".to_string(),
-            llvm_type: *member_llvm_types.get(2),
-            type_metadata: nil_pointer_type_metadata,
-            offset: ComputedMemberOffset,
-            flags: FLAGS_ARTIFICAL,
-        },
-        MemberDescription {
-            name: "next".to_string(),
-            llvm_type: *member_llvm_types.get(3),
-            type_metadata: nil_pointer_type_metadata,
-            offset: ComputedMemberOffset,
-            flags: FLAGS_ARTIFICAL,
-        },
-        MemberDescription {
-            name: "val".to_string(),
-            llvm_type: *member_llvm_types.get(4),
-            type_metadata: content_type_metadata,
-            offset: ComputedMemberOffset,
-            flags: FLAGS_ARTIFICAL,
-        }
-    ];
-
-    let gc_box_unique_id = debug_context(cx).type_map
-                                            .borrow_mut()
-                                            .get_unique_type_id_of_gc_box(cx, content_type);
-
-    let gc_box_metadata = composite_type_metadata(
-        cx,
-        box_llvm_type,
-        box_type_name.as_slice(),
-        gc_box_unique_id,
-        member_descriptions,
-        UNKNOWN_SCOPE_METADATA,
-        UNKNOWN_FILE_METADATA,
-        codemap::DUMMY_SP);
-
-    let gc_pointer_metadata = pointer_type_metadata(cx,
-                                                    at_pointer_type,
-                                                    gc_box_metadata);
-
-    return MetadataCreationResult::new(gc_pointer_metadata, false);
-
-    // Unfortunately, we cannot assert anything but the correct types here---and
-    // not whether the 'next' and 'prev' pointers are in the correct order.
-    fn box_layout_is_correct(cx: &CrateContext,
-                             member_llvm_types: &[Type],
-                             content_llvm_type: Type)
-                          -> bool {
-        member_llvm_types.len() == 5 &&
-        member_llvm_types[0] == cx.int_type() &&
-        member_llvm_types[1] == Type::generic_glue_fn(cx).ptr_to() &&
-        member_llvm_types[2] == Type::i8(cx).ptr_to() &&
-        member_llvm_types[3] == Type::i8(cx).ptr_to() &&
-        member_llvm_types[4] == content_llvm_type
-    }
-}
-
-
 fn fixed_vec_metadata(cx: &CrateContext,
                       unique_type_id: UniqueTypeId,
                       element_type: ty::t,
@@ -2968,9 +2851,6 @@ fn type_metadata(cx: &CrateContext,
         ty::ty_enum(def_id, _) => {
             prepare_enum_metadata(cx, t, def_id, unique_type_id, usage_site_span).finalize(cx)
         }
-        ty::ty_box(pointee_type) => {
-            at_box_metadata(cx, t, pointee_type, unique_type_id)
-        }
         ty::ty_vec(typ, Some(len)) => {
             fixed_vec_metadata(cx, unique_type_id, typ, len, usage_site_span)
         }
@@ -3702,7 +3582,7 @@ fn populate_scope_map(cx: &CrateContext,
             ast::ExprInlineAsm(ast::InlineAsm { inputs: ref inputs,
                                                 outputs: ref outputs,
                                                 .. }) => {
-                // inputs, outputs: ~[(String, Gc<expr>)]
+                // inputs, outputs: Vec<(String, P<Expr>)>
                 for &(_, ref exp) in inputs.iter() {
                     walk_expr(cx, &**exp, scope_stack, scope_map);
                 }
@@ -3777,10 +3657,6 @@ fn push_debuginfo_type_name(cx: &CrateContext,
             push_debuginfo_type_name(cx, inner_type, true, output);
             output.push_char('>');
         },
-        ty::ty_box(inner_type) => {
-            output.push_char('@');
-            push_debuginfo_type_name(cx, inner_type, true, output);
-        },
         ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => {
             output.push_char('*');
             match mutbl {
diff --git a/src/librustc/middle/trans/doc.rs b/src/librustc/middle/trans/doc.rs
index 56bf2561338..d6df0d88a76 100644
--- a/src/librustc/middle/trans/doc.rs
+++ b/src/librustc/middle/trans/doc.rs
@@ -65,7 +65,7 @@ Some of the datum methods, however, are designed to work only on
 copyable values such as ints or pointers. Those methods may borrow the
 datum (`&self`) rather than consume it, but they always include
 assertions on the type of the value represented to check that this
-makes sense. An example is `shallow_copy_and_take()`, which duplicates
+makes sense. An example is `shallow_copy()`, which duplicates
 a datum value.
 
 Translating an expression always yields a `Datum<Expr>` result, but
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index 0b47544c562..cd4ad85d094 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -38,7 +38,6 @@ use llvm;
 use llvm::{ValueRef};
 use metadata::csearch;
 use middle::def;
-use middle::lang_items::MallocFnLangItem;
 use middle::mem_categorization::Typer;
 use middle::subst;
 use middle::subst::Subst;
@@ -624,18 +623,15 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             DatumBlock::new(bcx, scratch.to_expr_datum())
         }
         ast::ExprBox(_, ref contents) => {
-            // Special case for `Box<T>` and `Gc<T>`
+            // Special case for `Box<T>`
             let box_ty = expr_ty(bcx, expr);
             let contents_ty = expr_ty(bcx, &**contents);
             match ty::get(box_ty).sty {
                 ty::ty_uniq(..) => {
                     trans_uniq_expr(bcx, box_ty, &**contents, contents_ty)
                 }
-                ty::ty_box(..) => {
-                    trans_managed_expr(bcx, box_ty, &**contents, contents_ty)
-                }
                 _ => bcx.sess().span_bug(expr.span,
-                                         "expected unique or managed box")
+                                         "expected unique box")
             }
 
         }
@@ -1572,26 +1568,6 @@ fn trans_uniq_expr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     immediate_rvalue_bcx(bcx, val, box_ty).to_expr_datumblock()
 }
 
-fn trans_managed_expr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                  box_ty: ty::t,
-                                  contents: &ast::Expr,
-                                  contents_ty: ty::t)
-                                  -> DatumBlock<'blk, 'tcx, Expr> {
-    let _icx = push_ctxt("trans_managed_expr");
-    let fcx = bcx.fcx;
-    let ty = type_of::type_of(bcx.ccx(), contents_ty);
-    let Result {bcx, val: bx} = malloc_raw_dyn_managed(bcx, contents_ty, MallocFnLangItem,
-                                                        llsize_of(bcx.ccx(), ty));
-    let body = GEPi(bcx, bx, [0u, abi::box_field_body]);
-
-    let custom_cleanup_scope = fcx.push_custom_cleanup_scope();
-    fcx.schedule_free_value(cleanup::CustomScope(custom_cleanup_scope),
-                            bx, cleanup::HeapManaged, contents_ty);
-    let bcx = trans_into(bcx, contents, SaveIn(body));
-    fcx.pop_custom_cleanup_scope(custom_cleanup_scope);
-    immediate_rvalue_bcx(bcx, bx, box_ty).to_expr_datumblock()
-}
-
 fn trans_addr_of<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                              expr: &ast::Expr,
                              subexpr: &ast::Expr)
@@ -1924,10 +1900,6 @@ pub fn cast_type_kind(tcx: &ty::ctxt, t: ty::t) -> cast_kind {
 }
 
 fn cast_is_noop(t_in: ty::t, t_out: ty::t) -> bool {
-    if ty::type_is_boxed(t_in) || ty::type_is_boxed(t_out) {
-        return false;
-    }
-
     match (ty::deref(t_in, true), ty::deref(t_out, true)) {
         (Some(ty::mt{ ty: t_in, .. }), Some(ty::mt{ ty: t_out, .. })) => {
             t_in == t_out
@@ -2160,15 +2132,6 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             }
         }
 
-        ty::ty_box(content_ty) => {
-            let datum = unpack_datum!(
-                bcx, datum.to_lvalue_datum(bcx, "deref", expr.id));
-            let llptrref = datum.to_llref();
-            let llptr = Load(bcx, llptrref);
-            let llbody = GEPi(bcx, llptr, [0u, abi::box_field_body]);
-            DatumBlock::new(bcx, Datum::new(llbody, content_ty, LvalueExpr))
-        }
-
         ty::ty_ptr(ty::mt { ty: content_ty, .. }) |
         ty::ty_rptr(_, ty::mt { ty: content_ty, .. }) => {
             if ty::type_is_sized(bcx.tcx(), content_ty) {
diff --git a/src/librustc/middle/trans/glue.rs b/src/librustc/middle/trans/glue.rs
index c8cc89ca66a..33a46c0ba36 100644
--- a/src/librustc/middle/trans/glue.rs
+++ b/src/librustc/middle/trans/glue.rs
@@ -17,7 +17,7 @@ use back::abi;
 use back::link::*;
 use llvm::{ValueRef, True, get_param};
 use llvm;
-use middle::lang_items::{FreeFnLangItem, ExchangeFreeFnLangItem};
+use middle::lang_items::ExchangeFreeFnLangItem;
 use middle::subst;
 use middle::subst::Subst;
 use middle::trans::adt;
@@ -46,15 +46,6 @@ use libc::c_uint;
 use syntax::ast;
 use syntax::parse::token;
 
-pub fn trans_free<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef)
-                              -> Block<'blk, 'tcx> {
-    let _icx = push_ctxt("trans_free");
-    callee::trans_lang_call(cx,
-        langcall(cx, None, "", FreeFnLangItem),
-        [PointerCast(cx, v, Type::i8p(cx.ccx()))],
-        Some(expr::Ignore)).bcx
-}
-
 pub fn trans_exchange_free_dyn<'blk, 'tcx>(cx: Block<'blk, 'tcx>, v: ValueRef,
                                            size: ValueRef, align: ValueRef)
                                            -> Block<'blk, 'tcx> {
@@ -87,20 +78,6 @@ pub fn trans_exchange_free_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ptr: ValueRef,
     }
 }
 
-pub fn take_ty<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v: ValueRef, t: ty::t)
-                           -> Block<'blk, 'tcx> {
-    // NB: v is an *alias* of type t here, not a direct value.
-    let _icx = push_ctxt("take_ty");
-    match ty::get(t).sty {
-        ty::ty_box(_) => incr_refcnt_of_boxed(bcx, v),
-        _ if ty::type_is_structural(t)
-          && ty::type_needs_drop(bcx.tcx(), t) => {
-            iter_structural_ty(bcx, v, t, take_ty)
-        }
-        _ => bcx
-    }
-}
-
 pub fn get_drop_glue_type(ccx: &CrateContext, t: ty::t) -> ty::t {
     let tcx = ccx.tcx();
     // Even if there is no dtor for t, there might be one deeper down and we
@@ -446,9 +423,6 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
     // NB: v0 is an *alias* of type t here, not a direct value.
     let _icx = push_ctxt("make_drop_glue");
     match ty::get(t).sty {
-        ty::ty_box(body_ty) => {
-            decr_refcnt_maybe_free(bcx, v0, body_ty)
-        }
         ty::ty_uniq(content_ty) => {
             match ty::get(content_ty).sty {
                 ty::ty_vec(ty, None) => {
@@ -568,48 +542,6 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: ty::t)
     }
 }
 
-fn decr_refcnt_maybe_free<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                      box_ptr_ptr: ValueRef,
-                                      t: ty::t) -> Block<'blk, 'tcx> {
-    let _icx = push_ctxt("decr_refcnt_maybe_free");
-    let fcx = bcx.fcx;
-    let ccx = bcx.ccx();
-
-    let decr_bcx = fcx.new_temp_block("decr");
-    let free_bcx = fcx.new_temp_block("free");
-    let next_bcx = fcx.new_temp_block("next");
-
-    let box_ptr = Load(bcx, box_ptr_ptr);
-    let llnotnull = IsNotNull(bcx, box_ptr);
-    CondBr(bcx, llnotnull, decr_bcx.llbb, next_bcx.llbb);
-
-    let rc_ptr = GEPi(decr_bcx, box_ptr, [0u, abi::box_field_refcnt]);
-    let rc = Sub(decr_bcx, Load(decr_bcx, rc_ptr), C_int(ccx, 1));
-    Store(decr_bcx, rc, rc_ptr);
-    CondBr(decr_bcx, IsNull(decr_bcx, rc), free_bcx.llbb, next_bcx.llbb);
-
-    let v = Load(free_bcx, box_ptr_ptr);
-    let body = GEPi(free_bcx, v, [0u, abi::box_field_body]);
-    let free_bcx = drop_ty(free_bcx, body, t, None);
-    let free_bcx = trans_free(free_bcx, v);
-    Br(free_bcx, next_bcx.llbb);
-
-    next_bcx
-}
-
-fn incr_refcnt_of_boxed<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                    box_ptr_ptr: ValueRef) -> Block<'blk, 'tcx> {
-    let _icx = push_ctxt("incr_refcnt_of_boxed");
-    let ccx = bcx.ccx();
-    let box_ptr = Load(bcx, box_ptr_ptr);
-    let rc_ptr = GEPi(bcx, box_ptr, [0u, abi::box_field_refcnt]);
-    let rc = Load(bcx, rc_ptr);
-    let rc = Add(bcx, rc, C_int(ccx, 1));
-    Store(bcx, rc, rc_ptr);
-    bcx
-}
-
-
 // Generates the declaration for (but doesn't emit) a type descriptor.
 pub fn declare_tydesc(ccx: &CrateContext, t: ty::t) -> tydesc_info {
     // If emit_tydescs already ran, then we shouldn't be creating any new
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
index 03550299fbd..f004bea23c7 100644
--- a/src/librustc/middle/trans/reflect.rs
+++ b/src/librustc/middle/trans/reflect.rs
@@ -169,14 +169,6 @@ impl<'a, 'blk, 'tcx> Reflector<'a, 'blk, 'tcx> {
               extra.push(self.c_tydesc(ty));
               self.visit("evec_fixed", extra.as_slice())
           }
-          // Should remove mt from box and uniq.
-          ty::ty_box(typ) => {
-              let extra = self.c_mt(&ty::mt {
-                  ty: typ,
-                  mutbl: ast::MutImmutable,
-              });
-              self.visit("box", extra.as_slice())
-          }
           ty::ty_ptr(ref mt) => {
               match ty::get(mt.ty).sty {
                   ty::ty_vec(ty, None) => {
diff --git a/src/librustc/middle/trans/tvec.rs b/src/librustc/middle/trans/tvec.rs
index 848e59e2a60..fac0ef2014e 100644
--- a/src/librustc/middle/trans/tvec.rs
+++ b/src/librustc/middle/trans/tvec.rs
@@ -325,7 +325,7 @@ pub fn write_content<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
                     let bcx = iter_vec_loop(bcx, lldest, vt,
                                   C_uint(bcx.ccx(), count), |set_bcx, lleltptr, _| {
-                        elem.shallow_copy_and_take(set_bcx, lleltptr)
+                        elem.shallow_copy(set_bcx, lleltptr)
                     });
 
                     elem.add_clean_if_rvalue(bcx, element.id);
diff --git a/src/librustc/middle/trans/type_of.rs b/src/librustc/middle/trans/type_of.rs
index 54f24516867..d41cd7ed9e5 100644
--- a/src/librustc/middle/trans/type_of.rs
+++ b/src/librustc/middle/trans/type_of.rs
@@ -174,7 +174,6 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
         ty::ty_uint(t) => Type::uint_from_ty(cx, t),
         ty::ty_float(t) => Type::float_from_ty(cx, t),
 
-        ty::ty_box(..) => Type::i8p(cx),
         ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
             if ty::type_is_sized(cx.tcx(), ty) {
                 Type::i8p(cx)
@@ -299,9 +298,6 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
         let name = llvm_type_name(cx, an_unboxed_closure, did, []);
         adt::incomplete_type_of(cx, &*repr, name.as_slice())
       }
-      ty::ty_box(typ) => {
-          Type::at_box(cx, type_of(cx, typ)).ptr_to()
-      }
 
       ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
           match ty::get(ty).sty {
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index b38f362dcf1..edbdf427c0b 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -940,7 +940,6 @@ pub enum sty {
     /// the `ast_ty_to_ty_cache`. This is probably true for `ty_struct` as
     /// well.`
     ty_enum(DefId, Substs),
-    ty_box(t),
     ty_uniq(t),
     ty_str,
     ty_vec(t, Option<uint>), // Second field is length.
@@ -1621,7 +1620,7 @@ pub fn mk_t(cx: &ctxt, st: sty) -> t {
           flags |= sflags(substs);
           flags |= flags_for_bounds(bounds);
       }
-      &ty_box(tt) | &ty_uniq(tt) | &ty_vec(tt, _) | &ty_open(tt) => {
+      &ty_uniq(tt) | &ty_vec(tt, _) | &ty_open(tt) => {
         flags |= get(tt).flags
       }
       &ty_ptr(ref m) => {
@@ -1776,8 +1775,6 @@ pub fn mk_enum(cx: &ctxt, did: ast::DefId, substs: Substs) -> t {
     mk_t(cx, ty_enum(did, substs))
 }
 
-pub fn mk_box(cx: &ctxt, ty: t) -> t { mk_t(cx, ty_box(ty)) }
-
 pub fn mk_uniq(cx: &ctxt, ty: t) -> t { mk_t(cx, ty_uniq(ty)) }
 
 pub fn mk_ptr(cx: &ctxt, tm: mt) -> t { mk_t(cx, ty_ptr(tm)) }
@@ -1901,7 +1898,7 @@ pub fn maybe_walk_ty(ty: t, f: |t| -> bool) {
     match get(ty).sty {
         ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) |
         ty_str | ty_infer(_) | ty_param(_) | ty_unboxed_closure(_, _) | ty_err => {}
-        ty_box(ty) | ty_uniq(ty) | ty_vec(ty, _) | ty_open(ty) => maybe_walk_ty(ty, f),
+        ty_uniq(ty) | ty_vec(ty, _) | ty_open(ty) => maybe_walk_ty(ty, f),
         ty_ptr(ref tm) | ty_rptr(_, ref tm) => {
             maybe_walk_ty(tm.ty, f);
         }
@@ -2014,7 +2011,7 @@ pub fn type_is_vec(ty: t) -> bool {
     match get(ty).sty {
         ty_vec(..) => true,
         ty_ptr(mt{ty: t, ..}) | ty_rptr(_, mt{ty: t, ..}) |
-        ty_box(t) | ty_uniq(t) => match get(t).sty {
+        ty_uniq(t) => match get(t).sty {
             ty_vec(_, None) => true,
             _ => false
         },
@@ -2067,13 +2064,6 @@ pub fn simd_size(cx: &ctxt, ty: t) -> uint {
     }
 }
 
-pub fn type_is_boxed(ty: t) -> bool {
-    match get(ty).sty {
-      ty_box(_) => true,
-      _ => false
-    }
-}
-
 pub fn type_is_region_ptr(ty: t) -> bool {
     match get(ty).sty {
         ty_rptr(..) => true,
@@ -2144,29 +2134,22 @@ pub fn type_needs_unwind_cleanup(cx: &ctxt, ty: t) -> bool {
 
     let mut tycache = HashSet::new();
     let needs_unwind_cleanup =
-        type_needs_unwind_cleanup_(cx, ty, &mut tycache, false);
+        type_needs_unwind_cleanup_(cx, ty, &mut tycache);
     cx.needs_unwind_cleanup_cache.borrow_mut().insert(ty, needs_unwind_cleanup);
-    return needs_unwind_cleanup;
+    needs_unwind_cleanup
 }
 
 fn type_needs_unwind_cleanup_(cx: &ctxt, ty: t,
-                              tycache: &mut HashSet<t>,
-                              encountered_box: bool) -> bool {
+                              tycache: &mut HashSet<t>) -> bool {
 
     // Prevent infinite recursion
     if !tycache.insert(ty) {
         return false;
     }
 
-    let mut encountered_box = encountered_box;
     let mut needs_unwind_cleanup = false;
     maybe_walk_ty(ty, |ty| {
-        let old_encountered_box = encountered_box;
         let result = match get(ty).sty {
-          ty_box(_) => {
-            encountered_box = true;
-            true
-          }
           ty_nil | ty_bot | ty_bool | ty_int(_) | ty_uint(_) | ty_float(_) |
           ty_tup(_) | ty_ptr(_) => {
             true
@@ -2176,33 +2159,21 @@ fn type_needs_unwind_cleanup_(cx: &ctxt, ty: t,
                 for aty in v.args.iter() {
                     let t = aty.subst(cx, substs);
                     needs_unwind_cleanup |=
-                        type_needs_unwind_cleanup_(cx, t, tycache,
-                                                   encountered_box);
+                        type_needs_unwind_cleanup_(cx, t, tycache);
                 }
             }
             !needs_unwind_cleanup
           }
-          ty_uniq(_) => {
-            // Once we're inside a box, the annihilator will find
-            // it and destroy it.
-            if !encountered_box {
-                needs_unwind_cleanup = true;
-                false
-            } else {
-                true
-            }
-          }
           _ => {
             needs_unwind_cleanup = true;
             false
           }
         };
 
-        encountered_box = old_encountered_box;
         result
     });
 
-    return needs_unwind_cleanup;
+    needs_unwind_cleanup
 }
 
 /**
@@ -2460,10 +2431,6 @@ pub fn type_contents(cx: &ctxt, ty: t) -> TypeContents {
                 closure_contents(cx, &**c) | TC::ReachesFfiUnsafe
             }
 
-            ty_box(typ) => {
-                tc_ty(cx, typ, cache).managed_pointer() | TC::ReachesFfiUnsafe
-            }
-
             ty_uniq(typ) => {
                 TC::ReachesFfiUnsafe | match get(typ).sty {
                     ty_str => TC::OwnsOwned,
@@ -2782,7 +2749,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool {
             ty_vec(_, None) => {
                 false
             }
-            ty_box(typ) | ty_uniq(typ) | ty_open(typ) => {
+            ty_uniq(typ) | ty_open(typ) => {
                 type_requires(cx, seen, r_ty, typ)
             }
             ty_rptr(_, ref mt) => {
@@ -3092,7 +3059,7 @@ pub fn type_is_c_like_enum(cx: &ctxt, ty: t) -> bool {
 // Some types---notably unsafe ptrs---can only be dereferenced explicitly.
 pub fn deref(t: t, explicit: bool) -> Option<mt> {
     match get(t).sty {
-        ty_box(ty) | ty_uniq(ty) => {
+        ty_uniq(ty) => {
             Some(mt {
                 ty: ty,
                 mutbl: ast::MutImmutable,
@@ -3106,9 +3073,7 @@ pub fn deref(t: t, explicit: bool) -> Option<mt> {
 
 pub fn deref_or_dont(t: t) -> t {
     match get(t).sty {
-        ty_box(ty) | ty_uniq(ty) => {
-            ty
-        },
+        ty_uniq(ty) => ty,
         ty_rptr(_, mt) | ty_ptr(mt) => mt.ty,
         _ => t
     }
@@ -3124,7 +3089,7 @@ pub fn close_type(cx: &ctxt, t: t) -> t {
 
 pub fn type_content(t: t) -> t {
     match get(t).sty {
-        ty_box(ty) | ty_uniq(ty) => ty,
+        ty_uniq(ty) => ty,
         ty_rptr(_, mt) |ty_ptr(mt) => mt.ty,
         _ => t
     }
@@ -3695,14 +3660,13 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
         }
 
         ast::ExprBox(ref place, _) => {
-            // Special case `Box<T>`/`Gc<T>` for now:
+            // Special case `Box<T>` for now:
             let definition = match tcx.def_map.borrow().find(&place.id) {
                 Some(&def) => def,
                 None => fail!("no def for place"),
             };
             let def_id = definition.def_id();
-            if tcx.lang_items.exchange_heap() == Some(def_id) ||
-               tcx.lang_items.managed_heap() == Some(def_id) {
+            if tcx.lang_items.exchange_heap() == Some(def_id) {
                 RvalueDatumExpr
             } else {
                 RvalueDpsExpr
@@ -3753,7 +3717,6 @@ pub fn ty_sort_string(cx: &ctxt, t: t) -> String {
         }
 
         ty_enum(id, _) => format!("enum {}", item_path_str(cx, id)),
-        ty_box(_) => "Gc-ptr".to_string(),
         ty_uniq(_) => "box".to_string(),
         ty_vec(_, Some(_)) => "array".to_string(),
         ty_vec(_, None) => "unsized array".to_string(),
@@ -5223,19 +5186,15 @@ pub fn hash_crate_independent(tcx: &ctxt, t: t, svh: &Svh) -> u64 {
                 byte!(8);
                 did(&mut state, d);
             }
-            ty_box(_) => {
+            ty_uniq(_) => {
                 byte!(9);
             }
-            ty_uniq(_) => {
-                byte!(10);
-            }
             ty_vec(_, Some(n)) => {
-                byte!(11);
+                byte!(10);
                 n.hash(&mut state);
             }
             ty_vec(_, None) => {
                 byte!(11);
-                0u8.hash(&mut state);
             }
             ty_ptr(m) => {
                 byte!(12);
@@ -5586,7 +5545,6 @@ pub fn accumulate_lifetimes_in_type(accumulator: &mut Vec<ty::Region>,
             ty_int(_) |
             ty_uint(_) |
             ty_float(_) |
-            ty_box(_) |
             ty_uniq(_) |
             ty_str |
             ty_vec(_, _) |
diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs
index 2e964c457bf..44420ddd7f3 100644
--- a/src/librustc/middle/ty_fold.rs
+++ b/src/librustc/middle/ty_fold.rs
@@ -458,9 +458,6 @@ pub fn super_fold_mt<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
 pub fn super_fold_sty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
                                                  sty: &ty::sty) -> ty::sty {
     match *sty {
-        ty::ty_box(typ) => {
-            ty::ty_box(typ.fold_with(this))
-        }
         ty::ty_uniq(typ) => {
             ty::ty_uniq(typ.fold_with(this))
         }
diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs
index 72c3c1715e0..4d21090dd2c 100644
--- a/src/librustc/middle/typeck/astconv.rs
+++ b/src/librustc/middle/typeck/astconv.rs
@@ -559,44 +559,6 @@ pub fn ast_ty_to_builtin_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                               "not enough type parameters supplied to `Box<T>`");
                     Some(ty::mk_err())
                 }
-                def::DefTy(did, _) | def::DefStruct(did)
-                        if Some(did) == this.tcx().lang_items.gc() => {
-                    if path.segments
-                           .iter()
-                           .flat_map(|s| s.types.iter())
-                           .count() > 1 {
-                        span_err!(this.tcx().sess, path.span, E0048,
-                                  "`Gc` has only one type parameter");
-                    }
-
-                    for inner_ast_type in path.segments
-                                              .iter()
-                                              .flat_map(|s| s.types.iter()) {
-                        return Some(mk_pointer(this,
-                                               rscope,
-                                               ast::MutImmutable,
-                                               &**inner_ast_type,
-                                               Box,
-                                               |typ| {
-                            match ty::get(typ).sty {
-                                ty::ty_str => {
-                                    span_err!(this.tcx().sess, path.span, E0114,
-                                              "`Gc<str>` is not a type");
-                                    ty::mk_err()
-                                }
-                                ty::ty_vec(_, None) => {
-                                    span_err!(this.tcx().sess, path.span, E0115,
-                                              "`Gc<[T]>` is not a type");
-                                    ty::mk_err()
-                                }
-                                _ => ty::mk_box(this.tcx(), typ),
-                            }
-                        }))
-                    }
-                    this.tcx().sess.span_bug(path.span,
-                                             "not enough type parameters \
-                                              supplied to `Gc<T>`")
-                }
                 _ => None
             }
         }
@@ -606,7 +568,6 @@ pub fn ast_ty_to_builtin_ty<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
 
 #[deriving(Show)]
 enum PointerTy {
-    Box,
     RPtr(ty::Region),
     Uniq
 }
@@ -614,7 +575,6 @@ enum PointerTy {
 impl PointerTy {
     fn default_region(&self) -> ty::Region {
         match *self {
-            Box => ty::ReStatic,
             Uniq => ty::ReStatic,
             RPtr(r) => r,
         }
@@ -702,14 +662,6 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                                        r,
                                        ty::mt {mutbl: a_seq_mutbl, ty: tr});
                 }
-                _ => {
-                    tcx.sess.span_err(
-                        a_seq_ty.span,
-                        "~trait or &trait are the only supported \
-                         forms of casting-to-trait");
-                    return ty::mk_err();
-                }
-
             }
         }
         ast::TyPath(ref path, ref opt_bounds, id) => {
@@ -726,11 +678,6 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                         RPtr(r) => {
                             return ty::mk_str_slice(tcx, r, ast::MutImmutable);
                         }
-                        _ => {
-                            tcx.sess
-                               .span_err(path.span,
-                                         "managed strings are not supported")
-                        }
                     }
                 }
                 Some(&def::DefTrait(trait_def_id)) => {
@@ -767,13 +714,6 @@ fn mk_pointer<'tcx, AC: AstConv<'tcx>, RS: RegionScope>(
                         RPtr(r) => {
                             return ty::mk_rptr(tcx, r, ty::mt{mutbl: a_seq_mutbl, ty: tr});
                         }
-                        _ => {
-                            tcx.sess.span_err(
-                                path.span,
-                                "~trait or &trait are the only supported \
-                                 forms of casting-to-trait");
-                            return ty::mk_err();
-                        }
                     };
                 }
                 _ => {}
diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs
index 3d522a7c548..8711f4de512 100644
--- a/src/librustc/middle/typeck/check/method.rs
+++ b/src/librustc/middle/typeck/check/method.rs
@@ -1094,7 +1094,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
 
         let tcx = self.tcx();
         match ty::get(self_ty).sty {
-            ty_bare_fn(..) | ty_box(..) | ty_uniq(..) | ty_rptr(..) |
+            ty_bare_fn(..) | ty_uniq(..) | ty_rptr(..) |
             ty_infer(IntVar(_)) |
             ty_infer(FloatVar(_)) |
             ty_param(..) | ty_nil | ty_bot | ty_bool |
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index d8b5185a47a..194c2c35c88 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -3820,12 +3820,6 @@ fn check_expr_with_unifier(fcx: &FnCtxt,
                   if tcx.lang_items.exchange_heap() == Some(def_id) {
                       fcx.write_ty(id, ty::mk_uniq(tcx, referent_ty));
                       checked = true
-                  } else if tcx.lang_items.managed_heap() == Some(def_id) {
-                      fcx.register_region_obligation(infer::Managed(expr.span),
-                                                     referent_ty,
-                                                     ty::ReStatic);
-                      fcx.write_ty(id, ty::mk_box(tcx, referent_ty));
-                      checked = true
                   }
               }
               _ => {}
diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs
index 53edcb303f7..4d19bc16a3e 100644
--- a/src/librustc/middle/typeck/check/regionck.rs
+++ b/src/librustc/middle/typeck/check/regionck.rs
@@ -1466,7 +1466,6 @@ fn link_region(rcx: &Rcx,
 
             mc::cat_discr(cmt_base, _) |
             mc::cat_downcast(cmt_base) |
-            mc::cat_deref(cmt_base, _, mc::GcPtr(..)) |
             mc::cat_deref(cmt_base, _, mc::OwnedPtr) |
             mc::cat_interior(cmt_base, _) => {
                 // Borrowing interior or owned data requires the base
@@ -1699,7 +1698,6 @@ fn adjust_upvar_borrow_kind_for_mut(rcx: &Rcx,
             }
 
             mc::cat_deref(_, _, mc::UnsafePtr(..)) |
-            mc::cat_deref(_, _, mc::GcPtr) |
             mc::cat_static_item |
             mc::cat_rvalue(_) |
             mc::cat_copied_upvar(_) |
@@ -1750,7 +1748,6 @@ fn adjust_upvar_borrow_kind_for_unique(rcx: &Rcx, cmt: mc::cmt) {
             }
 
             mc::cat_deref(_, _, mc::UnsafePtr(..)) |
-            mc::cat_deref(_, _, mc::GcPtr) |
             mc::cat_static_item |
             mc::cat_rvalue(_) |
             mc::cat_copied_upvar(_) |
diff --git a/src/librustc/middle/typeck/check/regionmanip.rs b/src/librustc/middle/typeck/check/regionmanip.rs
index db9877698a3..5d75d590a09 100644
--- a/src/librustc/middle/typeck/check/regionmanip.rs
+++ b/src/librustc/middle/typeck/check/regionmanip.rs
@@ -129,7 +129,6 @@ impl<'a, 'tcx> Wf<'a, 'tcx> {
 
             ty::ty_vec(t, _) |
             ty::ty_ptr(ty::mt { ty: t, .. }) |
-            ty::ty_box(t) |
             ty::ty_uniq(t) => {
                 self.accumulate_from_ty(t)
             }
diff --git a/src/librustc/middle/typeck/check/vtable2.rs b/src/librustc/middle/typeck/check/vtable2.rs
index bdcf4d73c3b..1d765c6c7c6 100644
--- a/src/librustc/middle/typeck/check/vtable2.rs
+++ b/src/librustc/middle/typeck/check/vtable2.rs
@@ -95,7 +95,7 @@ pub fn check_object_cast(fcx: &FnCtxt,
         }
     }
 
-    // Because we currently give unsound lifetimes to the "ty_box", I
+    // Because we currently give unsound lifetimes to the "t_box", I
     // could have written &'static ty::TyTrait here, but it seems
     // gratuitously unsafe.
     fn object_trait<'a>(t: &'a ty::t) -> &'a ty::TyTrait {
diff --git a/src/librustc/middle/typeck/coherence/mod.rs b/src/librustc/middle/typeck/coherence/mod.rs
index cef6e31b937..f6ac0e1666c 100644
--- a/src/librustc/middle/typeck/coherence/mod.rs
+++ b/src/librustc/middle/typeck/coherence/mod.rs
@@ -23,7 +23,7 @@ use middle::subst::{Substs};
 use middle::ty::get;
 use middle::ty::{ImplContainer, ImplOrTraitItemId, MethodTraitItemId};
 use middle::ty::{TypeTraitItemId, lookup_item_type};
-use middle::ty::{t, ty_bool, ty_char, ty_bot, ty_box, ty_enum, ty_err};
+use middle::ty::{t, ty_bool, ty_char, ty_bot, ty_enum, ty_err};
 use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int, ty_nil, ty_open};
 use middle::ty::{ty_param, Polytype, ty_ptr};
 use middle::ty::{ty_rptr, ty_struct, ty_trait, ty_tup};
@@ -84,8 +84,8 @@ fn get_base_type(inference_context: &InferCtxt,
 
         ty_nil | ty_bot | ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) |
         ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_closure(..) | ty_tup(..) |
-        ty_infer(..) | ty_param(..) | ty_err | ty_open(..) |
-        ty_box(_) | ty_uniq(_) | ty_ptr(_) | ty_rptr(_, _) => {
+        ty_infer(..) | ty_param(..) | ty_err | ty_open(..) | ty_uniq(_) |
+        ty_ptr(_) | ty_rptr(_, _) => {
             debug!("(getting base type) no base type; found {:?}",
                    get(original_type).sty);
             None
diff --git a/src/librustc/middle/typeck/infer/coercion.rs b/src/librustc/middle/typeck/infer/coercion.rs
index 7f9f569c37e..a0c190c5c81 100644
--- a/src/librustc/middle/typeck/infer/coercion.rs
+++ b/src/librustc/middle/typeck/infer/coercion.rs
@@ -258,7 +258,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         let r_borrow = self.get_ref().infcx.next_region_var(coercion);
 
         let inner_ty = match *sty_a {
-            ty::ty_box(_) | ty::ty_uniq(_) => return Err(ty::terr_mismatch),
+            ty::ty_uniq(_) => return Err(ty::terr_mismatch),
             ty::ty_rptr(_, mt_a) => mt_a.ty,
             _ => {
                 return self.subtype(a, b);
diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs
index 4412b7d94d4..a742cf45059 100644
--- a/src/librustc/middle/typeck/infer/combine.rs
+++ b/src/librustc/middle/typeck/infer/combine.rs
@@ -495,10 +495,6 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C, a: ty::t, b: ty::t) -> cres<t
           Ok(ty::mk_unboxed_closure(tcx, a_id, region))
       }
 
-      (&ty::ty_box(a_inner), &ty::ty_box(b_inner)) => {
-        this.tys(a_inner, b_inner).and_then(|typ| Ok(ty::mk_box(tcx, typ)))
-      }
-
       (&ty::ty_uniq(a_inner), &ty::ty_uniq(b_inner)) => {
             let typ = try!(this.tys(a_inner, b_inner));
             check_ptr_to_unsized(this, a, b, a_inner, b_inner, ty::mk_uniq(tcx, typ))
diff --git a/src/librustc/middle/typeck/infer/error_reporting.rs b/src/librustc/middle/typeck/infer/error_reporting.rs
index 0149220fde4..8ff5b3c9024 100644
--- a/src/librustc/middle/typeck/infer/error_reporting.rs
+++ b/src/librustc/middle/typeck/infer/error_reporting.rs
@@ -776,11 +776,6 @@ impl<'a, 'tcx> ErrorReporting for InferCtxt<'a, 'tcx> {
                     sup,
                     "");
             }
-            infer::Managed(span) => {
-                self.tcx.sess.span_err(
-                    span,
-                    format!("cannot put borrowed references into managed memory").as_slice());
-            }
         }
     }
 
@@ -1612,11 +1607,6 @@ impl<'a, 'tcx> ErrorReportingHelpers for InferCtxt<'a, 'tcx> {
                              does not outlive the data it points at",
                             self.ty_to_string(ty)).as_slice());
             }
-            infer::Managed(span) => {
-                self.tcx.sess.span_note(
-                    span,
-                    "...so that the value can be stored in managed memory.");
-            }
             infer::RelateParamBound(span, param_ty, t) => {
                 self.tcx.sess.span_note(
                     span,
diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs
index c36192777f0..44bda134909 100644
--- a/src/librustc/middle/typeck/infer/mod.rs
+++ b/src/librustc/middle/typeck/infer/mod.rs
@@ -216,9 +216,6 @@ pub enum SubregionOrigin {
 
     // An auto-borrow that does not enclose the expr where it occurs
     AutoBorrow(Span),
-
-    // Managed data cannot contain borrowed pointers.
-    Managed(Span),
 }
 
 /// Reasons to create a region inference variable
@@ -1029,7 +1026,6 @@ impl SubregionOrigin {
             CallReturn(a) => a,
             AddrOf(a) => a,
             AutoBorrow(a) => a,
-            Managed(a) => a,
         }
     }
 }
@@ -1102,7 +1098,6 @@ impl Repr for SubregionOrigin {
             CallReturn(a) => format!("CallReturn({})", a.repr(tcx)),
             AddrOf(a) => format!("AddrOf({})", a.repr(tcx)),
             AutoBorrow(a) => format!("AutoBorrow({})", a.repr(tcx)),
-            Managed(a) => format!("Managed({})", a.repr(tcx)),
         }
     }
 }
diff --git a/src/librustc/middle/typeck/infer/skolemize.rs b/src/librustc/middle/typeck/infer/skolemize.rs
index 4002f598449..54ece395be9 100644
--- a/src/librustc/middle/typeck/infer/skolemize.rs
+++ b/src/librustc/middle/typeck/infer/skolemize.rs
@@ -143,7 +143,6 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeSkolemizer<'a, 'tcx> {
             ty::ty_uint(..) |
             ty::ty_float(..) |
             ty::ty_enum(..) |
-            ty::ty_box(..) |
             ty::ty_uniq(..) |
             ty::ty_str |
             ty::ty_err |
diff --git a/src/librustc/middle/typeck/variance.rs b/src/librustc/middle/typeck/variance.rs
index a6edfcf80fd..9317ba2c7fa 100644
--- a/src/librustc/middle/typeck/variance.rs
+++ b/src/librustc/middle/typeck/variance.rs
@@ -742,7 +742,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraints_from_mt(mt, variance);
             }
 
-            ty::ty_uniq(typ) | ty::ty_box(typ) | ty::ty_vec(typ, _) | ty::ty_open(typ) => {
+            ty::ty_uniq(typ) | ty::ty_vec(typ, _) | ty::ty_open(typ) => {
                 self.add_constraints_from_ty(typ, variance);
             }
 
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 5ca6d08720f..18cf805bccb 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -17,7 +17,7 @@ use middle::ty::{ReEarlyBound, BrFresh, ctxt};
 use middle::ty::{ReFree, ReScope, ReInfer, ReStatic, Region, ReEmpty};
 use middle::ty::{ReSkolemized, ReVar};
 use middle::ty::{mt, t, ParamTy};
-use middle::ty::{ty_bool, ty_char, ty_bot, ty_box, ty_struct, ty_enum};
+use middle::ty::{ty_bool, ty_char, ty_bot, ty_struct, ty_enum};
 use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn, ty_closure};
 use middle::ty::{ty_nil, ty_param, ty_ptr, ty_rptr, ty_tup, ty_open};
 use middle::ty::{ty_unboxed_closure};
@@ -375,7 +375,6 @@ pub fn ty_to_string(cx: &ctxt, typ: t) -> String {
       ty_int(t) => ast_util::int_ty_to_string(t, None).to_string(),
       ty_uint(t) => ast_util::uint_ty_to_string(t, None).to_string(),
       ty_float(t) => ast_util::float_ty_to_string(t).to_string(),
-      ty_box(typ) => format!("Gc<{}>", ty_to_string(cx, typ)),
       ty_uniq(typ) => format!("Box<{}>", ty_to_string(cx, typ)),
       ty_ptr(ref tm) => {
           format!("*{} {}", match tm.mutbl {