Make ast_fold take &mut self

sfackler · sfackler · commit 3965dddf49aa · 2013-12-29T23:41:05.000-08:00
diff --git a/src/librustc/front/assign_node_ids.rs b/src/librustc/front/assign_node_ids.rs
@@ -18,14 +18,14 @@ struct NodeIdAssigner {
 }
 
 impl ast_fold for NodeIdAssigner {
-    fn new_id(&self, old_id: ast::NodeId) -> ast::NodeId {
+    fn new_id(&mut self, old_id: ast::NodeId) -> ast::NodeId {
         assert_eq!(old_id, ast::DUMMY_NODE_ID);
         self.sess.next_node_id()
     }
 }
 
 pub fn assign_node_ids(sess: Session, crate: ast::Crate) -> ast::Crate {
-    let fold = NodeIdAssigner {
+    let mut fold = NodeIdAssigner {
         sess: sess,
     };
     fold.fold_crate(crate)
diff --git a/src/librustc/front/config.rs b/src/librustc/front/config.rs
@@ -24,25 +24,25 @@ pub fn strip_unconfigured_items(crate: ast::Crate) -> ast::Crate {
 }
 
 impl<'a> fold::ast_fold for Context<'a> {
-    fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {
+    fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {
         fold_mod(self, module)
     }
-    fn fold_block(&self, block: ast::P<ast::Block>) -> ast::P<ast::Block> {
+    fn fold_block(&mut self, block: ast::P<ast::Block>) -> ast::P<ast::Block> {
         fold_block(self, block)
     }
-    fn fold_foreign_mod(&self, foreign_module: &ast::foreign_mod)
+    fn fold_foreign_mod(&mut self, foreign_module: &ast::foreign_mod)
                         -> ast::foreign_mod {
         fold_foreign_mod(self, foreign_module)
     }
-    fn fold_item_underscore(&self, item: &ast::item_) -> ast::item_ {
+    fn fold_item_underscore(&mut self, item: &ast::item_) -> ast::item_ {
         fold_item_underscore(self, item)
     }
 }
 
 pub fn strip_items(crate: ast::Crate,
                    in_cfg: |attrs: &[ast::Attribute]| -> bool)
                    -> ast::Crate {
-    let ctxt = Context {
+    let mut ctxt = Context {
         in_cfg: in_cfg,
     };
     ctxt.fold_crate(crate)
@@ -57,7 +57,7 @@ fn filter_view_item<'r>(cx: &Context, view_item: &'r ast::view_item)
     }
 }
 
-fn fold_mod(cx: &Context, m: &ast::_mod) -> ast::_mod {
+fn fold_mod(cx: &mut Context, m: &ast::_mod) -> ast::_mod {
     let filtered_items = m.items.iter()
             .filter(|&a| item_in_cfg(cx, *a))
             .flat_map(|&x| cx.fold_item(x).move_iter())
@@ -80,7 +80,7 @@ fn filter_foreign_item(cx: &Context, item: @ast::foreign_item)
     }
 }
 
-fn fold_foreign_mod(cx: &Context, nm: &ast::foreign_mod) -> ast::foreign_mod {
+fn fold_foreign_mod(cx: &mut Context, nm: &ast::foreign_mod) -> ast::foreign_mod {
     let filtered_items = nm.items
                            .iter()
                            .filter_map(|a| filter_foreign_item(cx, *a))
@@ -95,7 +95,7 @@ fn fold_foreign_mod(cx: &Context, nm: &ast::foreign_mod) -> ast::foreign_mod {
     }
 }
 
-fn fold_item_underscore(cx: &Context, item: &ast::item_) -> ast::item_ {
+fn fold_item_underscore(cx: &mut Context, item: &ast::item_) -> ast::item_ {
     let item = match *item {
         ast::item_impl(ref a, ref b, c, ref methods) => {
             let methods = methods.iter().filter(|m| method_in_cfg(cx, **m))
@@ -129,7 +129,7 @@ fn retain_stmt(cx: &Context, stmt: @ast::Stmt) -> bool {
     }
 }
 
-fn fold_block(cx: &Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {
+fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {
     let resulting_stmts = b.stmts.iter()
             .filter(|&a| retain_stmt(cx, *a))
             .flat_map(|&stmt| cx.fold_stmt(stmt).move_iter())
diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs
@@ -56,7 +56,7 @@ struct StandardLibraryInjector {
 }
 
 impl fold::ast_fold for StandardLibraryInjector {
-    fn fold_crate(&self, crate: ast::Crate) -> ast::Crate {
+    fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {
         let version = STD_VERSION.to_managed();
         let vers_item = attr::mk_name_value_item_str(@"vers", version);
         let mut vis = ~[ast::view_item {
@@ -108,7 +108,7 @@ impl fold::ast_fold for StandardLibraryInjector {
         }
     }
 
-    fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {
+    fn fold_item(&mut self, item: @ast::item) -> SmallVector<@ast::item> {
         if !no_prelude(item.attrs) {
             // only recur if there wasn't `#[no_implicit_prelude];`
             // on this item, i.e. this means that the prelude is not
@@ -119,7 +119,7 @@ impl fold::ast_fold for StandardLibraryInjector {
         }
     }
 
-    fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {
+    fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {
         let prelude_path = ast::Path {
             span: dummy_sp(),
             global: false,
@@ -158,7 +158,7 @@ impl fold::ast_fold for StandardLibraryInjector {
 }
 
 fn inject_libstd_ref(sess: Session, crate: ast::Crate) -> ast::Crate {
-    let fold = StandardLibraryInjector {
+    let mut fold = StandardLibraryInjector {
         sess: sess,
     };
     fold.fold_crate(crate)
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
@@ -67,7 +67,7 @@ struct TestHarnessGenerator {
 }
 
 impl fold::ast_fold for TestHarnessGenerator {
-    fn fold_crate(&self, c: ast::Crate) -> ast::Crate {
+    fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate {
         let folded = fold::noop_fold_crate(c, self);
 
         // Add a special __test module to the crate that will contain code
@@ -78,7 +78,7 @@ impl fold::ast_fold for TestHarnessGenerator {
         }
     }
 
-    fn fold_item(&self, i: @ast::item) -> SmallVector<@ast::item> {
+    fn fold_item(&mut self, i: @ast::item) -> SmallVector<@ast::item> {
         {
             let mut path = self.cx.path.borrow_mut();
             path.get().push(i.ident);
@@ -122,7 +122,7 @@ impl fold::ast_fold for TestHarnessGenerator {
         res
     }
 
-    fn fold_mod(&self, m: &ast::_mod) -> ast::_mod {
+    fn fold_mod(&mut self, m: &ast::_mod) -> ast::_mod {
         // Remove any #[main] from the AST so it doesn't clash with
         // the one we're going to add. Only if compiling an executable.
 
@@ -172,7 +172,7 @@ fn generate_test_harness(sess: session::Session, crate: ast::Crate)
         }
     });
 
-    let fold = TestHarnessGenerator {
+    let mut fold = TestHarnessGenerator {
         cx: cx
     };
     let res = fold.fold_crate(crate);
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
@@ -301,7 +301,7 @@ struct NestedItemsDropper {
 }
 
 impl fold::ast_fold for NestedItemsDropper {
-    fn fold_block(&self, blk: ast::P<ast::Block>) -> ast::P<ast::Block> {
+    fn fold_block(&mut self, blk: ast::P<ast::Block>) -> ast::P<ast::Block> {
         let stmts_sans_items = blk.stmts.iter().filter_map(|stmt| {
             match stmt.node {
                 ast::StmtExpr(_, _) | ast::StmtSemi(_, _) |
@@ -340,7 +340,7 @@ impl fold::ast_fold for NestedItemsDropper {
 // nested items, as otherwise it would get confused when translating
 // inlined items.
 fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
-    let fld = NestedItemsDropper {
+    let mut fld = NestedItemsDropper {
         contents: (),
     };
 
@@ -365,17 +365,17 @@ struct AstRenumberer {
 }
 
 impl fold::ast_fold for AstRenumberer {
-    fn new_id(&self, id: ast::NodeId) -> ast::NodeId {
+    fn new_id(&mut self, id: ast::NodeId) -> ast::NodeId {
         self.xcx.tr_id(id)
     }
-    fn new_span(&self, span: Span) -> Span {
+    fn new_span(&mut self, span: Span) -> Span {
         self.xcx.tr_span(span)
     }
 }
 
 fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
     -> ast::inlined_item {
-    let fld = AstRenumberer {
+    let mut fld = AstRenumberer {
         xcx: xcx,
     };
     match ii {
diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs
@@ -80,7 +80,7 @@ struct ReadyCtx {
     fns: ~[ListenerFn]
 }
 
-fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &CrateSetup)
+fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &mut CrateSetup)
             -> ast::_mod {
     fn strip_main(item: @ast::item) -> @ast::item {
         @ast::item {
@@ -101,7 +101,7 @@ fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &CrateSetup)
     }, fold)
 }
 
-fn fold_item(ctx: @mut ReadyCtx, item: @ast::item, fold: &CrateSetup)
+fn fold_item(ctx: @mut ReadyCtx, item: @ast::item, fold: &mut CrateSetup)
              -> SmallVector<@ast::item> {
     ctx.path.push(item.ident);
 
@@ -145,10 +145,10 @@ struct CrateSetup {
 }
 
 impl fold::ast_fold for CrateSetup {
-    fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {
+    fn fold_item(&mut self, item: @ast::item) -> SmallVector<@ast::item> {
         fold_item(self.ctx, item, self)
     }
-    fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {
+    fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {
         fold_mod(self.ctx, module, self)
     }
 }
@@ -162,7 +162,7 @@ pub fn ready_crate(sess: session::Session,
         path: ~[],
         fns: ~[]
     };
-    let fold = CrateSetup {
+    let mut fold = CrateSetup {
         ctx: ctx,
     };
     fold.fold_crate(crate)
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
@@ -324,11 +324,11 @@ impl ExtCtxt {
         loop {
             match e.node {
                 ast::ExprMac(..) => {
-                    let expander = expand::MacroExpander {
+                    let mut expander = expand::MacroExpander {
                         extsbox: @mut syntax_expander_table(),
                         cx: self,
                     };
-                    e = expand::expand_expr(e, &expander);
+                    e = expand::expand_expr(e, &mut expander);
                 }
                 _ => return e
             }
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
@@ -908,7 +908,7 @@ struct Duplicator<'a> {
 }
 
 impl<'a> ast_fold for Duplicator<'a> {
-    fn new_id(&self, _: NodeId) -> NodeId {
+    fn new_id(&mut self, _: NodeId) -> NodeId {
         ast::DUMMY_NODE_ID
     }
 }
@@ -925,7 +925,7 @@ pub trait Duplicate {
 
 impl Duplicate for @ast::Expr {
     fn duplicate(&self, cx: &ExtCtxt) -> @ast::Expr {
-        let folder = Duplicator {
+        let mut folder = Duplicator {
             cx: cx,
         };
         folder.fold_expr(*self)
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs

Original file line number	Diff line number	Diff line change
`@@ -18,14 +18,14 @@ struct NodeIdAssigner {`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`impl ast_fold for NodeIdAssigner {`
`21`		`- fn new_id(&self, old_id: ast::NodeId) -> ast::NodeId {`
	`21`	`+ fn new_id(&mut self, old_id: ast::NodeId) -> ast::NodeId {`
`22`	`22`	`assert_eq!(old_id, ast::DUMMY_NODE_ID);`
`23`	`23`	`self.sess.next_node_id()`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`pub fn assign_node_ids(sess: Session, crate: ast::Crate) -> ast::Crate {`
`28`		`- let fold = NodeIdAssigner {`
	`28`	`+ let mut fold = NodeIdAssigner {`
`29`	`29`	`sess: sess,`
`30`	`30`	`};`
`31`	`31`	`fold.fold_crate(crate)`
Original file line number	Diff line number	Diff line change
`@@ -24,25 +24,25 @@ pub fn strip_unconfigured_items(crate: ast::Crate) -> ast::Crate {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`impl<'a> fold::ast_fold for Context<'a> {`
`27`		`- fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {`
	`27`	`+ fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {`
`28`	`28`	`fold_mod(self, module)`
`29`	`29`	`}`
`30`		`- fn fold_block(&self, block: ast::P<ast::Block>) -> ast::P<ast::Block> {`
	`30`	`+ fn fold_block(&mut self, block: ast::P<ast::Block>) -> ast::P<ast::Block> {`
`31`	`31`	`fold_block(self, block)`
`32`	`32`	`}`
`33`		`- fn fold_foreign_mod(&self, foreign_module: &ast::foreign_mod)`
	`33`	`+ fn fold_foreign_mod(&mut self, foreign_module: &ast::foreign_mod)`
`34`	`34`	`-> ast::foreign_mod {`
`35`	`35`	`fold_foreign_mod(self, foreign_module)`
`36`	`36`	`}`
`37`		`- fn fold_item_underscore(&self, item: &ast::item_) -> ast::item_ {`
	`37`	`+ fn fold_item_underscore(&mut self, item: &ast::item_) -> ast::item_ {`
`38`	`38`	`fold_item_underscore(self, item)`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`pub fn strip_items(crate: ast::Crate,`
`43`	`43`	`in_cfg: \|attrs: &[ast::Attribute]\| -> bool)`
`44`	`44`	`-> ast::Crate {`
`45`		`- let ctxt = Context {`
	`45`	`+ let mut ctxt = Context {`
`46`	`46`	`in_cfg: in_cfg,`
`47`	`47`	`};`
`48`	`48`	`ctxt.fold_crate(crate)`
`@@ -57,7 +57,7 @@ fn filter_view_item<'r>(cx: &Context, view_item: &'r ast::view_item)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-fn fold_mod(cx: &Context, m: &ast::_mod) -> ast::_mod {`
	`60`	`+fn fold_mod(cx: &mut Context, m: &ast::_mod) -> ast::_mod {`
`61`	`61`	`let filtered_items = m.items.iter()`
`62`	`62`	`.filter(\|&a\| item_in_cfg(cx, *a))`
`63`	`63`	`.flat_map(\|&x\| cx.fold_item(x).move_iter())`
`@@ -80,7 +80,7 @@ fn filter_foreign_item(cx: &Context, item: @ast::foreign_item)`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`		`-fn fold_foreign_mod(cx: &Context, nm: &ast::foreign_mod) -> ast::foreign_mod {`
	`83`	`+fn fold_foreign_mod(cx: &mut Context, nm: &ast::foreign_mod) -> ast::foreign_mod {`
`84`	`84`	`let filtered_items = nm.items`
`85`	`85`	`.iter()`
`86`	`86`	`.filter_map(\|a\| filter_foreign_item(cx, *a))`
`@@ -95,7 +95,7 @@ fn fold_foreign_mod(cx: &Context, nm: &ast::foreign_mod) -> ast::foreign_mod {`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`		`-fn fold_item_underscore(cx: &Context, item: &ast::item_) -> ast::item_ {`
	`98`	`+fn fold_item_underscore(cx: &mut Context, item: &ast::item_) -> ast::item_ {`
`99`	`99`	`let item = match *item {`
`100`	`100`	`ast::item_impl(ref a, ref b, c, ref methods) => {`
`101`	`101`	`let methods = methods.iter().filter(\|m\| method_in_cfg(cx, **m))`
`@@ -129,7 +129,7 @@ fn retain_stmt(cx: &Context, stmt: @ast::Stmt) -> bool {`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`132`		`-fn fold_block(cx: &Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {`
	`132`	`+fn fold_block(cx: &mut Context, b: ast::P<ast::Block>) -> ast::P<ast::Block> {`
`133`	`133`	`let resulting_stmts = b.stmts.iter()`
`134`	`134`	`.filter(\|&a\| retain_stmt(cx, *a))`
`135`	`135`	`.flat_map(\|&stmt\| cx.fold_stmt(stmt).move_iter())`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ struct StandardLibraryInjector {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`impl fold::ast_fold for StandardLibraryInjector {`
`59`		`- fn fold_crate(&self, crate: ast::Crate) -> ast::Crate {`
	`59`	`+ fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {`
`60`	`60`	`let version = STD_VERSION.to_managed();`
`61`	`61`	`let vers_item = attr::mk_name_value_item_str(@"vers", version);`
`62`	`62`	`let mut vis = ~[ast::view_item {`
`@@ -108,7 +108,7 @@ impl fold::ast_fold for StandardLibraryInjector {`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`- fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {`
	`111`	`+ fn fold_item(&mut self, item: @ast::item) -> SmallVector<@ast::item> {`
`112`	`112`	`if !no_prelude(item.attrs) {`
`113`	`113`	// only recur if there wasn't `#[no_implicit_prelude];`
`114`	`114`	`// on this item, i.e. this means that the prelude is not`
`@@ -119,7 +119,7 @@ impl fold::ast_fold for StandardLibraryInjector {`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`		`- fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {`
	`122`	`+ fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {`
`123`	`123`	`let prelude_path = ast::Path {`
`124`	`124`	`span: dummy_sp(),`
`125`	`125`	`global: false,`
`@@ -158,7 +158,7 @@ impl fold::ast_fold for StandardLibraryInjector {`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`fn inject_libstd_ref(sess: Session, crate: ast::Crate) -> ast::Crate {`
`161`		`- let fold = StandardLibraryInjector {`
	`161`	`+ let mut fold = StandardLibraryInjector {`
`162`	`162`	`sess: sess,`
`163`	`163`	`};`
`164`	`164`	`fold.fold_crate(crate)`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ struct TestHarnessGenerator {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`impl fold::ast_fold for TestHarnessGenerator {`
`70`		`- fn fold_crate(&self, c: ast::Crate) -> ast::Crate {`
	`70`	`+ fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate {`
`71`	`71`	`let folded = fold::noop_fold_crate(c, self);`
`72`	`72`
`73`	`73`	`// Add a special __test module to the crate that will contain code`
`@@ -78,7 +78,7 @@ impl fold::ast_fold for TestHarnessGenerator {`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`81`		`- fn fold_item(&self, i: @ast::item) -> SmallVector<@ast::item> {`
	`81`	`+ fn fold_item(&mut self, i: @ast::item) -> SmallVector<@ast::item> {`
`82`	`82`	`{`
`83`	`83`	`let mut path = self.cx.path.borrow_mut();`
`84`	`84`	`path.get().push(i.ident);`
`@@ -122,7 +122,7 @@ impl fold::ast_fold for TestHarnessGenerator {`
`122`	`122`	`res`
`123`	`123`	`}`
`124`	`124`
`125`		`- fn fold_mod(&self, m: &ast::_mod) -> ast::_mod {`
	`125`	`+ fn fold_mod(&mut self, m: &ast::_mod) -> ast::_mod {`
`126`	`126`	`// Remove any #[main] from the AST so it doesn't clash with`
`127`	`127`	`// the one we're going to add. Only if compiling an executable.`
`128`	`128`
`@@ -172,7 +172,7 @@ fn generate_test_harness(sess: session::Session, crate: ast::Crate)`
`172`	`172`	`}`
`173`	`173`	`});`
`174`	`174`
`175`		`- let fold = TestHarnessGenerator {`
	`175`	`+ let mut fold = TestHarnessGenerator {`
`176`	`176`	`cx: cx`
`177`	`177`	`};`
`178`	`178`	`let res = fold.fold_crate(crate);`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ struct ReadyCtx {`
`80`	`80`	`fns: ~[ListenerFn]`
`81`	`81`	`}`
`82`	`82`
`83`		`-fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &CrateSetup)`
	`83`	`+fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &mut CrateSetup)`
`84`	`84`	`-> ast::_mod {`
`85`	`85`	`fn strip_main(item: @ast::item) -> @ast::item {`
`86`	`86`	`@ast::item {`
`@@ -101,7 +101,7 @@ fn fold_mod(_ctx: @mut ReadyCtx, m: &ast::_mod, fold: &CrateSetup)`
`101`	`101`	`}, fold)`
`102`	`102`	`}`
`103`	`103`
`104`		`-fn fold_item(ctx: @mut ReadyCtx, item: @ast::item, fold: &CrateSetup)`
	`104`	`+fn fold_item(ctx: @mut ReadyCtx, item: @ast::item, fold: &mut CrateSetup)`
`105`	`105`	`-> SmallVector<@ast::item> {`
`106`	`106`	`ctx.path.push(item.ident);`
`107`	`107`
`@@ -145,10 +145,10 @@ struct CrateSetup {`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`impl fold::ast_fold for CrateSetup {`
`148`		`- fn fold_item(&self, item: @ast::item) -> SmallVector<@ast::item> {`
	`148`	`+ fn fold_item(&mut self, item: @ast::item) -> SmallVector<@ast::item> {`
`149`	`149`	`fold_item(self.ctx, item, self)`
`150`	`150`	`}`
`151`		`- fn fold_mod(&self, module: &ast::_mod) -> ast::_mod {`
	`151`	`+ fn fold_mod(&mut self, module: &ast::_mod) -> ast::_mod {`
`152`	`152`	`fold_mod(self.ctx, module, self)`
`153`	`153`	`}`
`154`	`154`	`}`
`@@ -162,7 +162,7 @@ pub fn ready_crate(sess: session::Session,`
`162`	`162`	`path: ~[],`
`163`	`163`	`fns: ~[]`
`164`	`164`	`};`
`165`		`- let fold = CrateSetup {`
	`165`	`+ let mut fold = CrateSetup {`
`166`	`166`	`ctx: ctx,`
`167`	`167`	`};`
`168`	`168`	`fold.fold_crate(crate)`
Original file line number	Diff line number	Diff line change
`@@ -324,11 +324,11 @@ impl ExtCtxt {`
`324`	`324`	`loop {`
`325`	`325`	`match e.node {`
`326`	`326`	`ast::ExprMac(..) => {`
`327`		`- let expander = expand::MacroExpander {`
	`327`	`+ let mut expander = expand::MacroExpander {`
`328`	`328`	`extsbox: @mut syntax_expander_table(),`
`329`	`329`	`cx: self,`
`330`	`330`	`};`
`331`		`- e = expand::expand_expr(e, &expander);`
	`331`	`+ e = expand::expand_expr(e, &mut expander);`
`332`	`332`	`}`
`333`	`333`	`_ => return e`
`334`	`334`	`}`
Original file line number	Diff line number	Diff line change
`@@ -908,7 +908,7 @@ struct Duplicator<'a> {`
`908`	`908`	`}`
`909`	`909`
`910`	`910`	`impl<'a> ast_fold for Duplicator<'a> {`
`911`		`- fn new_id(&self, _: NodeId) -> NodeId {`
	`911`	`+ fn new_id(&mut self, _: NodeId) -> NodeId {`
`912`	`912`	`ast::DUMMY_NODE_ID`
`913`	`913`	`}`
`914`	`914`	`}`
`@@ -925,7 +925,7 @@ pub trait Duplicate {`
`925`	`925`
`926`	`926`	`impl Duplicate for @ast::Expr {`
`927`	`927`	`fn duplicate(&self, cx: &ExtCtxt) -> @ast::Expr {`
`928`		`- let folder = Duplicator {`
	`928`	`+ let mut folder = Duplicator {`
`929`	`929`	`cx: cx,`
`930`	`930`	`};`
`931`	`931`	`folder.fold_expr(*self)`