rustc: Move the AST from @t to Gc<T>

Author: alexcrichton

src/doc/tutorial.md

@@ -1710,14 +1710,14 @@ having ownership of the box. It allows the creation of cycles, and the individua
 not have a destructor.
 
 ~~~
-use std::gc::Gc;
+use std::gc::GC;
 
 // A fixed-size array allocated in a garbage-collected box
-let x = Gc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+let x = box(GC) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 let y = x; // does not perform a move, unlike with `Rc`
 let z = x;
 
-assert!(*z.borrow() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert!(*z == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 ~~~
 
 With shared ownership, mutability cannot be inherited so the boxes are always immutable. However,

src/liballoc/rc.rs

@@ -320,7 +320,7 @@ mod tests {
     #[test]
     fn gc_inside() {
         // see issue #11532
-        use realstd::gc::Gc;
+        use std::gc::GC;
         let a = Rc::new(RefCell::new(box(GC) 1));
         assert!(a.try_borrow_mut().is_some());
     }

src/libcore/clone.rs

@@ -110,6 +110,7 @@ extern_fn_clone!(A, B, C, D, E, F, G, H)
 mod test {
     use prelude::*;
     use realstd::owned::Box;
+    use realstd::gc::{Gc, GC};
 
     fn realclone<T: ::realstd::clone::Clone>(t: &T) -> T {
         use realstd::clone::Clone;
@@ -130,9 +131,9 @@ mod test {
 
     #[test]
     fn test_managed_clone() {
-        let a = @5i;
-        let b: @int = a.clone();
-        assert_eq!(a, b);
+        let a = box(GC) 5i;
+        let b: Gc<int> = realclone(&a);
+        assert!(a == b);
     }
 
     #[test]

src/librustc/driver/driver.rs

@@ -705,7 +705,7 @@ fn print_flowgraph<W:io::Writer>(analysis: CrateAnalysis,
                                  block: ast::P<ast::Block>,
                                  mut out: W) -> io::IoResult<()> {
     let ty_cx = &analysis.ty_cx;
-    let cfg = cfg::CFG::new(ty_cx, block);
+    let cfg = cfg::CFG::new(ty_cx, &*block);
     let lcfg = LabelledCFG { ast_map: &ty_cx.map,
                              cfg: &cfg,
                              name: format!("block{}", block.id).to_string(), };

src/librustc/front/config.rs

@@ -12,6 +12,8 @@ use syntax::fold::Folder;
 use syntax::{ast, fold, attr};
 use syntax::codemap;
 
+use std::gc::Gc;
+
 struct Context<'a> {
     in_cfg: |attrs: &[ast::Attribute]|: 'a -> bool,
 }
@@ -36,7 +38,7 @@ impl<'a> fold::Folder for Context<'a> {
     fn fold_item_underscore(&mut self, item: &ast::Item_) -> ast::Item_ {
         fold_item_underscore(self, item)
     }
-    fn fold_expr(&mut self, expr: @ast::Expr) -> @ast::Expr {
+    fn fold_expr(&mut self, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
         fold_expr(self, expr)
     }
 }
@@ -60,8 +62,8 @@ fn filter_view_item<'r>(cx: &mut Context, view_item: &'r ast::ViewItem)
 }
 
 fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod {
-    let filtered_items: Vec<&@ast::Item> = m.items.iter()
-            .filter(|&a| item_in_cfg(cx, *a))
+    let filtered_items: Vec<&Gc<ast::Item>> = m.items.iter()
+            .filter(|a| item_in_cfg(cx, &***a))
             .collect();
     let flattened_items = filtered_items.move_iter()
             .flat_map(|&x| cx.fold_item(x).move_iter())
@@ -76,9 +78,9 @@ fn fold_mod(cx: &mut Context, m: &ast::Mod) -> ast::Mod {
     }
 }
 
-fn filter_foreign_item(cx: &mut Context, item: @ast::ForeignItem)
-                       -> Option<@ast::ForeignItem> {
-    if foreign_item_in_cfg(cx, item) {
+fn filter_foreign_item(cx: &mut Context, item: Gc<ast::ForeignItem>)
+                       -> Option<Gc<ast::ForeignItem>> {
+    if foreign_item_in_cfg(cx, &*item) {
         Some(item)
     } else {
         None
@@ -103,7 +105,7 @@ fn fold_foreign_mod(cx: &mut Context, nm: &ast::ForeignMod) -> ast::ForeignMod {
 fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
     let item = match *item {
         ast::ItemImpl(ref a, ref b, c, ref methods) => {
-            let methods = methods.iter().filter(|m| method_in_cfg(cx, **m))
+            let methods = methods.iter().filter(|m| method_in_cfg(cx, &***m))
                 .map(|x| *x).collect();
             ast::ItemImpl((*a).clone(), (*b).clone(), c, methods)
         }
@@ -114,8 +116,8 @@ fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
                                  .collect();
             ast::ItemTrait((*a).clone(), b, (*c).clone(), methods)
         }
-        ast::ItemStruct(def, ref generics) => {
-            ast::ItemStruct(fold_struct(cx, def), generics.clone())
+        ast::ItemStruct(ref def, ref generics) => {
+            ast::ItemStruct(fold_struct(cx, &**def), generics.clone())
         }
         ast::ItemEnum(ref def, ref generics) => {
             let mut variants = def.variants.iter().map(|c| c.clone()).
@@ -125,11 +127,11 @@ fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
                 } else {
                     Some(match v.node.kind {
                                 ast::TupleVariantKind(..) => v,
-                                ast::StructVariantKind(def) => {
-                                    let def = fold_struct(cx, def);
-                                    @codemap::Spanned {
+                                ast::StructVariantKind(ref def) => {
+                                    let def = fold_struct(cx, &**def);
+                                    box(GC) codemap::Spanned {
                                         node: ast::Variant_ {
-                                            kind: ast::StructVariantKind(def),
+                                            kind: ast::StructVariantKind(def.clone()),
                                             ..v.node.clone()
                                         },
                                         ..*v
@@ -148,24 +150,24 @@ fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
     fold::noop_fold_item_underscore(&item, cx)
 }
 
-fn fold_struct(cx: &mut Context, def: &ast::StructDef) -> @ast::StructDef {
+fn fold_struct(cx: &mut Context, def: &ast::StructDef) -> Gc<ast::StructDef> {
     let mut fields = def.fields.iter().map(|c| c.clone()).filter(|m| {
         (cx.in_cfg)(m.node.attrs.as_slice())
     });
-    @ast::StructDef {
+    box(GC) ast::StructDef {
         fields: fields.collect(),
         ctor_id: def.ctor_id,
         super_struct: def.super_struct.clone(),
         is_virtual: def.is_virtual,
     }
 }
 
-fn retain_stmt(cx: &mut Context, stmt: @ast::Stmt) -> bool {
+fn retain_stmt(cx: &mut Context, stmt: Gc<ast::Stmt>) -> bool {
     match stmt.node {
       ast::StmtDecl(decl, _) => {
         match decl.node {
-          ast::DeclItem(item) => {
-            item_in_cfg(cx, item)
+          ast::DeclItem(ref item) => {
+            item_in_cfg(cx, &**item)
           }
           _ => true
         }
@@ -175,10 +177,10 @@ fn retain_stmt(cx: &mut Context, stmt: @ast::Stmt) -> bool {
 }
 
 fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {
-    let resulting_stmts: Vec<&@ast::Stmt> =
+    let resulting_stmts: Vec<&Gc<ast::Stmt>> =
         b.stmts.iter().filter(|&a| retain_stmt(cx, *a)).collect();
     let resulting_stmts = resulting_stmts.move_iter()
-        .flat_map(|&stmt| cx.fold_stmt(stmt).move_iter())
+        .flat_map(|stmt| cx.fold_stmt(&**stmt).move_iter())
         .collect();
     let filtered_view_items = b.view_items.iter().filter_map(|a| {
         filter_view_item(cx, a).map(|x| cx.fold_view_item(x))
@@ -193,14 +195,14 @@ fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {
     })
 }
 
-fn fold_expr(cx: &mut Context, expr: @ast::Expr) -> @ast::Expr {
+fn fold_expr(cx: &mut Context, expr: Gc<ast::Expr>) -> Gc<ast::Expr> {
     let expr = match expr.node {
         ast::ExprMatch(ref m, ref arms) => {
             let arms = arms.iter()
                 .filter(|a| (cx.in_cfg)(a.attrs.as_slice()))
                 .map(|a| a.clone())
                 .collect();
-            @ast::Expr {
+            box(GC) ast::Expr {
                 id: expr.id,
                 span: expr.span.clone(),
                 node: ast::ExprMatch(m.clone(), arms),
@@ -236,7 +238,7 @@ fn trait_method_in_cfg(cx: &mut Context, meth: &ast::TraitMethod) -> bool {
 
 // Determine if an item should be translated in the current crate
 // configuration based on the item's attributes
-fn in_cfg(cfg: &[@ast::MetaItem], attrs: &[ast::Attribute]) -> bool {
+fn in_cfg(cfg: &[Gc<ast::MetaItem>], attrs: &[ast::Attribute]) -> bool {
     attr::test_cfg(cfg, attrs.iter().map(|x| *x))
 }
 

src/librustc/front/std_inject.rs

@@ -23,6 +23,7 @@ use syntax::parse::token;
 use syntax::util::small_vector::SmallVector;
 
 use std::mem;
+use std::gc::Gc;
 
 pub static VERSION: &'static str = "0.11.0-pre";
 
@@ -165,12 +166,12 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
         krate
     }
 
-    fn fold_item(&mut self, item: @ast::Item) -> SmallVector<@ast::Item> {
+    fn fold_item(&mut self, item: Gc<ast::Item>) -> SmallVector<Gc<ast::Item>> {
         if !no_prelude(item.attrs.as_slice()) {
             // only recur if there wasn't `#![no_implicit_prelude]`
             // on this item, i.e. this means that the prelude is not
             // implicitly imported though the whole subtree
-            fold::noop_fold_item(item, self)
+            fold::noop_fold_item(&*item, self)
         } else {
             SmallVector::one(item)
         }
@@ -193,7 +194,8 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
                 }),
         };
 
-        let vp = @codemap::dummy_spanned(ast::ViewPathGlob(prelude_path, ast::DUMMY_NODE_ID));
+        let vp = box(GC) codemap::dummy_spanned(ast::ViewPathGlob(prelude_path,
+                                                                  ast::DUMMY_NODE_ID));
         let vi2 = ast::ViewItem {
             node: ast::ViewItemUse(vp),
             attrs: Vec::new(),

src/librustc/front/test.rs

@@ -18,8 +18,8 @@ use front::config;
 use front::std_inject::with_version;
 
 use std::cell::RefCell;
+use std::gc::Gc;
 use std::slice;
-use std::vec::Vec;
 use std::vec;
 use syntax::ast_util::*;
 use syntax::attr::AttrMetaMethods;
@@ -86,7 +86,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         }
     }
 
-    fn fold_item(&mut self, i: @ast::Item) -> SmallVector<@ast::Item> {
+    fn fold_item(&mut self, i: Gc<ast::Item>) -> SmallVector<Gc<ast::Item>> {
         self.cx.path.borrow_mut().push(i.ident);
         debug!("current path: {}",
                ast_util::path_name_i(self.cx.path.borrow().as_slice()));
@@ -115,7 +115,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
             }
         }
 
-        let res = fold::noop_fold_item(i, self);
+        let res = fold::noop_fold_item(&*i, self);
         self.cx.path.borrow_mut().pop();
         res
     }
@@ -124,8 +124,8 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
         // Remove any #[main] from the AST so it doesn't clash with
         // the one we're going to add. Only if compiling an executable.
 
-        fn nomain(item: @ast::Item) -> @ast::Item {
-            @ast::Item {
+        fn nomain(item: Gc<ast::Item>) -> Gc<ast::Item> {
+            box(GC) ast::Item {
                 attrs: item.attrs.iter().filter_map(|attr| {
                     if !attr.name().equiv(&("main")) {
                         Some(*attr)
@@ -188,10 +188,10 @@ fn strip_test_functions(krate: ast::Crate) -> ast::Crate {
     })
 }
 
-fn is_test_fn(cx: &TestCtxt, i: @ast::Item) -> bool {
+fn is_test_fn(cx: &TestCtxt, i: Gc<ast::Item>) -> bool {
     let has_test_attr = attr::contains_name(i.attrs.as_slice(), "test");
 
-    fn has_test_signature(i: @ast::Item) -> bool {
+    fn has_test_signature(i: Gc<ast::Item>) -> bool {
         match &i.node {
           &ast::ItemFn(ref decl, _, _, ref generics, _) => {
             let no_output = match decl.output.node {
@@ -217,10 +217,10 @@ fn is_test_fn(cx: &TestCtxt, i: @ast::Item) -> bool {
     return has_test_attr && has_test_signature(i);
 }
 
-fn is_bench_fn(cx: &TestCtxt, i: @ast::Item) -> bool {
+fn is_bench_fn(cx: &TestCtxt, i: Gc<ast::Item>) -> bool {
     let has_bench_attr = attr::contains_name(i.attrs.as_slice(), "bench");
 
-    fn has_test_signature(i: @ast::Item) -> bool {
+    fn has_test_signature(i: Gc<ast::Item>) -> bool {
         match i.node {
             ast::ItemFn(ref decl, _, _, ref generics, _) => {
                 let input_cnt = decl.inputs.len();
@@ -247,7 +247,7 @@ fn is_bench_fn(cx: &TestCtxt, i: @ast::Item) -> bool {
     return has_bench_attr && has_test_signature(i);
 }
 
-fn is_ignored(cx: &TestCtxt, i: @ast::Item) -> bool {
+fn is_ignored(cx: &TestCtxt, i: Gc<ast::Item>) -> bool {
     i.attrs.iter().any(|attr| {
         // check ignore(cfg(foo, bar))
         attr.check_name("ignore") && match attr.meta_item_list() {
@@ -259,7 +259,7 @@ fn is_ignored(cx: &TestCtxt, i: @ast::Item) -> bool {
     })
 }
 
-fn should_fail(i: @ast::Item) -> bool {
+fn should_fail(i: Gc<ast::Item>) -> bool {
     attr::contains_name(i.attrs.as_slice(), "should_fail")
 }
 
@@ -293,7 +293,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
     let id_test = token::str_to_ident("test");
     let (vi, vis) = if cx.is_test_crate {
         (ast::ViewItemUse(
-            @nospan(ast::ViewPathSimple(id_test,
+            box(GC) nospan(ast::ViewPathSimple(id_test,
                                         path_node(vec!(id_test)),
                                         ast::DUMMY_NODE_ID))),
          ast::Public)
@@ -311,7 +311,7 @@ fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
     }
 }
 
-fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
+fn mk_test_module(cx: &TestCtxt) -> Gc<ast::Item> {
     // Link to test crate
     let view_items = vec!(mk_std(cx));
 
@@ -352,7 +352,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::Item {
 
     debug!("Synthetic test module:\n{}\n", pprust::item_to_str(&item));
 
-    return @item;
+    box(GC) item
 }
 
 fn nospan<T>(t: T) -> codemap::Spanned<T> {
@@ -383,7 +383,7 @@ fn path_node_global(ids: Vec<ast::Ident> ) -> ast::Path {
     }
 }
 
-fn mk_tests(cx: &TestCtxt) -> @ast::Item {
+fn mk_tests(cx: &TestCtxt) -> Gc<ast::Item> {
     // The vector of test_descs for this crate
     let test_descs = mk_test_descs(cx);
 
@@ -401,12 +401,12 @@ fn is_test_crate(krate: &ast::Crate) -> bool {
     }
 }
 
-fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
+fn mk_test_descs(cx: &TestCtxt) -> Gc<ast::Expr> {
     debug!("building test vector from {} tests", cx.testfns.borrow().len());
 
-    @ast::Expr {
+    box(GC) ast::Expr {
         id: ast::DUMMY_NODE_ID,
-        node: ast::ExprVstore(@ast::Expr {
+        node: ast::ExprVstore(box(GC) ast::Expr {
             id: ast::DUMMY_NODE_ID,
             node: ast::ExprVec(cx.testfns.borrow().iter().map(|test| {
                 mk_test_desc_and_fn_rec(cx, test)
@@ -417,7 +417,7 @@ fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
     }
 }
 
-fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
+fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> Gc<ast::Expr> {
     let span = test.span;
     let path = test.path.clone();
 
@@ -428,15 +428,15 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::Expr {
                     ast_util::path_name_i(path.as_slice()).as_slice()),
                     ast::CookedStr));
 
-    let name_expr = @ast::Expr {
+    let name_expr = box(GC) ast::Expr {
           id: ast::DUMMY_NODE_ID,
-          node: ast::ExprLit(@name_lit),
+          node: ast::ExprLit(box(GC) name_lit),
           span: span
     };
 
     let fn_path = path_node_global(path);
 
-    let fn_expr = @ast::Expr {
+    let fn_expr = box(GC) ast::Expr {
         id: ast::DUMMY_NODE_ID,
         node: ast::ExprPath(fn_path),
         span: span,