Remove Gc (garbage "collected") boxes.

src/doc/guide-pointers.md

@@ -632,19 +632,6 @@ This part is coming soon.
 
 This part is coming soon.
 
-# Gc
-
-The `Gc<T>` type exists for historical reasons, and is [still used
-internally](https://github.com/rust-lang/rust/issues/7929) by the compiler.
-It is not even a 'real' garbage collected type at the moment.
-
-In the future, Rust may have a real garbage collected type, and so it
-has not yet been removed for that reason.
-
-## Best practices
-
-There is currently no legitimate use case for the `Gc<T>` type.
-
 # Raw Pointers
 
 This part is coming soon.

src/doc/guide-runtime.md

@@ -31,7 +31,6 @@ list):
 * Task synchronization
 * Task-local storage
 * Logging
-* Local heaps (GC heaps)
 * Task unwinding
 
 ## What is the runtime accomplishing?

src/doc/guide-unsafe.md

@@ -208,9 +208,7 @@ pub struct Unique<T> {
 // Implement methods for creating and using the values in the box.
 
 // NB: For simplicity and correctness, we require that T has kind Send
-// (owned boxes relax this restriction, and can contain managed (GC) boxes).
-// This is because, as implemented, the garbage collector would not know
-// about any shared boxes stored in the malloc'd region of memory.
+// (owned boxes relax this restriction).
 impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         unsafe {

src/doc/reference.md

@@ -3381,7 +3381,7 @@ fn main() {
 
 ```
 
-Patterns can also dereference pointers by using the `&`, `box` or `@` symbols,
+Patterns can also dereference pointers by using the `&`, `box` symbols,
 as appropriate. For example, these two matches on `x: &int` are equivalent:
 
 ```

src/liballoc/lib.rs

@@ -92,7 +92,6 @@ pub use boxed as owned;
 
 pub mod heap;
 pub mod libc_heap;
-pub mod util;
 
 // Primitive types using the heaps above
 

src/liballoc/rc.rs

@@ -541,14 +541,6 @@ mod tests {
         assert!(y.upgrade().is_none());
     }
 
-    #[test]
-    fn gc_inside() {
-        // see issue #11532
-        use std::gc::GC;
-        let a = Rc::new(RefCell::new(box(GC) 1i));
-        assert!(a.try_borrow_mut().is_some());
-    }
-
     #[test]
     fn weak_self_cyclic() {
         struct Cycle {

src/libcollections/lib.rs

@@ -20,7 +20,7 @@
        html_playground_url = "http://play.rust-lang.org/")]
 
 #![allow(unknown_features)]
-#![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
+#![feature(macro_rules, default_type_params, phase, globs)]
 #![feature(unsafe_destructor, import_shadowing, slicing_syntax)]
 #![no_std]
 

src/libcollections/ringbuf.rs

@@ -532,7 +532,6 @@ impl<T: fmt::Show> fmt::Show for RingBuf<T> {
 mod tests {
     use std::fmt::Show;
     use std::prelude::*;
-    use std::gc::{GC, Gc};
     use std::hash;
     use test::Bencher;
     use test;
@@ -587,43 +586,6 @@ mod tests {
         assert_eq!(*d.get(3), 4);
     }
 
-    #[test]
-    #[allow(deprecated)]
-    fn test_boxes() {
-        let a: Gc<int> = box(GC) 5;
-        let b: Gc<int> = box(GC) 72;
-        let c: Gc<int> = box(GC) 64;
-        let d: Gc<int> = box(GC) 175;
-
-        let mut deq = RingBuf::new();
-        assert_eq!(deq.len(), 0);
-        deq.push_front(a);
-        deq.push_front(b);
-        deq.push(c);
-        assert_eq!(deq.len(), 3);
-        deq.push(d);
-        assert_eq!(deq.len(), 4);
-        assert_eq!(deq.front(), Some(&b));
-        assert_eq!(deq.back(), Some(&d));
-        assert_eq!(deq.pop_front(), Some(b));
-        assert_eq!(deq.pop(), Some(d));
-        assert_eq!(deq.pop(), Some(c));
-        assert_eq!(deq.pop(), Some(a));
-        assert_eq!(deq.len(), 0);
-        deq.push(c);
-        assert_eq!(deq.len(), 1);
-        deq.push_front(b);
-        assert_eq!(deq.len(), 2);
-        deq.push(d);
-        assert_eq!(deq.len(), 3);
-        deq.push_front(a);
-        assert_eq!(deq.len(), 4);
-        assert_eq!(*deq.get(0), a);
-        assert_eq!(*deq.get(1), b);
-        assert_eq!(*deq.get(2), c);
-        assert_eq!(*deq.get(3), d);
-    }
-
     #[cfg(test)]
     fn test_parameterized<T:Clone + PartialEq + Show>(a: T, b: T, c: T, d: T) {
         let mut deq = RingBuf::new();
@@ -755,12 +717,6 @@ mod tests {
         test_parameterized::<int>(5, 72, 64, 175);
     }
 
-    #[test]
-    fn test_param_at_int() {
-        test_parameterized::<Gc<int>>(box(GC) 5, box(GC) 72,
-                                      box(GC) 64, box(GC) 175);
-    }
-
     #[test]
     fn test_param_taggy() {
         test_parameterized::<Taggy>(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42));

src/libcore/lib.rs

@@ -58,7 +58,7 @@
 
 #![no_std]
 #![allow(unknown_features)]
-#![feature(globs, intrinsics, lang_items, macro_rules, managed_boxes, phase)]
+#![feature(globs, intrinsics, lang_items, macro_rules, phase)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
 #![deny(missing_doc)]
 

src/libcore/raw.rs

@@ -20,15 +20,6 @@
 
 use mem;
 
-/// The representation of `std::gc::Gc`.
-pub struct GcBox<T> {
-    pub ref_count: uint,
-    pub drop_glue: fn(ptr: *mut u8),
-    pub prev: *mut GcBox<T>,
-    pub next: *mut GcBox<T>,
-    pub data: T,
-}
-
 /// The representation of a Rust slice
 pub struct Slice<T> {
     pub data: *const T,

src/libcoretest/iter.rs

@@ -529,9 +529,8 @@ fn test_rposition() {
 #[test]
 #[should_fail]
 fn test_rposition_fail() {
-    use std::gc::GC;
-    let v = [(box 0i, box(GC) 0i), (box 0i, box(GC) 0i),
-             (box 0i, box(GC) 0i), (box 0i, box(GC) 0i)];
+    let v = [(box 0i, box 0i), (box 0i, box 0i),
+             (box 0i, box 0i), (box 0i, box 0i)];
     let mut i = 0i;
     v.iter().rposition(|_elt| {
         if i == 2 {

src/libdebug/lib.rs

@@ -25,7 +25,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 #![experimental]
-#![feature(managed_boxes, macro_rules)]
+#![feature(macro_rules)]
 #![allow(experimental)]
 
 pub mod fmt;

src/libdebug/reflect.rs

@@ -18,7 +18,6 @@ Runtime type reflection
 
 use std::intrinsics::{Disr, Opaque, TyDesc, TyVisitor};
 use std::mem;
-use std::gc::Gc;
 
 /**
  * Trait for visitor that wishes to reflect on data.
@@ -194,9 +193,9 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
 
     fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
-        self.align_to::<Gc<u8>>();
+        self.align_to::<Box<u8>>();
         if ! self.inner.visit_box(mtbl, inner) { return false; }
-        self.bump_past::<Gc<u8>>();
+        self.bump_past::<Box<u8>>();
         true
     }
 

src/libdebug/repr.rs

@@ -274,13 +274,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         self.get::<&str>(|this, s| this.write_escaped_slice(*s))
     }
 
-    fn visit_box(&mut self, mtbl: uint, inner: *const TyDesc) -> bool {
-        try!(self, self.writer.write("box(GC) ".as_bytes()));
-        self.write_mut_qualifier(mtbl);
-        self.get::<&raw::GcBox<()>>(|this, b| {
-            let p = &b.data as *const () as *const u8;
-            this.visit_ptr_inner(p, inner)
-        })
+    fn visit_box(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool {
+        try!(self, self.writer.write("box(GC) ???".as_bytes()));
+        true
     }
 
     fn visit_uniq(&mut self, _mtbl: uint, inner: *const TyDesc) -> bool {
@@ -576,7 +572,6 @@ fn test_repr() {
     use std::io::stdio::println;
     use std::char::is_alphabetic;
     use std::mem::swap;
-    use std::gc::GC;
 
     fn exact_test<T>(t: &T, e:&str) {
         let mut m = io::MemWriter::new();
@@ -591,7 +586,6 @@ fn test_repr() {
     exact_test(&1.234f64, "1.234f64");
     exact_test(&("hello"), "\"hello\"");
 
-    exact_test(&(box(GC) 10i), "box(GC) 10");
     exact_test(&(box 10i), "box 10");
     exact_test(&(&10i), "&10");
     let mut x = 10i;
@@ -605,8 +599,6 @@ fn test_repr() {
                "&[\"hi\", \"there\"]");
     exact_test(&(P{a:10, b:1.234}),
                "repr::P{a: 10, b: 1.234f64}");
-    exact_test(&(box(GC) P{a:10, b:1.234}),
-               "box(GC) repr::P{a: 10, b: 1.234f64}");
     exact_test(&(box P{a:10, b:1.234}),
                "box repr::P{a: 10, b: 1.234f64}");
 

src/libfourcc/lib.rs

@@ -50,7 +50,7 @@ fn main() {
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 
-#![feature(plugin_registrar, managed_boxes)]
+#![feature(plugin_registrar)]
 
 extern crate syntax;
 extern crate rustc;

src/libhexfloat/lib.rs

@@ -46,7 +46,7 @@ fn main() {
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
-#![feature(plugin_registrar, managed_boxes)]
+#![feature(plugin_registrar)]
 
 extern crate syntax;
 extern crate rustc;

src/libregex_macros/lib.rs

@@ -19,7 +19,7 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
 
-#![feature(plugin_registrar, managed_boxes, quote)]
+#![feature(plugin_registrar, quote)]
 
 extern crate regex;
 extern crate syntax;

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) {
@@ -1289,7 +1271,7 @@ impl LintPass for UnnecessaryAllocation {
 
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
         match e.node {
-            ast::ExprUnary(ast::UnUniq, _) | ast::ExprUnary(ast::UnBox, _) => (),
+            ast::ExprUnary(ast::UnUniq, _) => (),
             _ => return
         }
 

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))),
       '&' => {

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) => {

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(..)) |