---

yaml
---
r: 64379
b: refs/heads/snap-stage3
c: 0cc7074
h: refs/heads/master
i:
  64377: 9022afb
  64375: c8e08e3
v: v3

Author: michaelwoerister

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: af54f633fd72dda691e70aef9aeadd36f0fab8b9
+refs/heads/snap-stage3: 0cc70743d2cf6edb782c1daa9b0f554484ed21eb
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -422,7 +422,7 @@ pub fn pretty_print_input(sess: Session, cfg: ast::crate_cfg, input: &input,
           pprust::node_block(s, ref blk) => {
             pp::space(s.s);
             pprust::synth_comment(
-                s, ~"block " + int::to_str(blk.node.id));
+                s, ~"block " + int::to_str(blk.id));
           }
           pprust::node_expr(s, expr) => {
             pp::space(s.s);

branches/snap-stage3/src/librustc/front/config.rs

@@ -33,7 +33,7 @@ pub fn strip_items(crate: &ast::crate, in_cfg: in_cfg_pred)
 
     let precursor = @fold::AstFoldFns {
           fold_mod: |a,b| fold_mod(ctxt, a, b),
-          fold_block: fold::wrap(|a,b| fold_block(ctxt, a, b) ),
+          fold_block: |a,b| fold_block(ctxt, a, b),
           fold_foreign_mod: |a,b| fold_foreign_mod(ctxt, a, b),
           fold_item_underscore: |a,b| {
             // Bad copy.
@@ -133,21 +133,22 @@ fn filter_stmt(cx: @Context, stmt: @ast::stmt) ->
 
 fn fold_block(
     cx: @Context,
-    b: &ast::blk_,
+    b: &ast::blk,
     fld: @fold::ast_fold
-) -> ast::blk_ {
+) -> ast::blk {
     let resulting_stmts = do b.stmts.iter().filter_map |a| {
         filter_stmt(cx, *a).chain(|stmt| fld.fold_stmt(stmt))
     }.collect();
     let filtered_view_items = do b.view_items.iter().filter_map |a| {
         filter_view_item(cx, a).map(|&x| fld.fold_view_item(x))
     }.collect();
-    ast::blk_ {
+    ast::blk {
         view_items: filtered_view_items,
         stmts: resulting_stmts,
         expr: b.expr.map(|x| fld.fold_expr(*x)),
         id: b.id,
         rules: b.rules,
+        span: b.span,
     }
 }
 

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -289,7 +289,7 @@ fn encode_ast(ebml_w: &mut writer::Encoder, item: ast::inlined_item) {
 // nested items, as otherwise it would get confused when translating
 // inlined items.
 fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
-    fn drop_nested_items(blk: &ast::blk_, fld: @fold::ast_fold) -> ast::blk_ {
+    fn drop_nested_items(blk: &ast::blk, fld: @fold::ast_fold) -> ast::blk {
         let stmts_sans_items = do blk.stmts.iter().filter_map |stmt| {
             match stmt.node {
               ast::stmt_expr(_, _) | ast::stmt_semi(_, _) |
@@ -300,19 +300,20 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
               ast::stmt_mac(*) => fail!("unexpanded macro in astencode")
             }
         }.collect();
-        let blk_sans_items = ast::blk_ {
+        let blk_sans_items = ast::blk {
             view_items: ~[], // I don't know if we need the view_items here,
                              // but it doesn't break tests!
             stmts: stmts_sans_items,
             expr: blk.expr,
             id: blk.id,
-            rules: blk.rules
+            rules: blk.rules,
+            span: blk.span,
         };
         fold::noop_fold_block(&blk_sans_items, fld)
     }
 
     let fld = fold::make_fold(@fold::AstFoldFns {
-        fold_block: fold::wrap(drop_nested_items),
+        fold_block: drop_nested_items,
         .. *fold::default_ast_fold()
     });
 

branches/snap-stage3/src/librustc/middle/borrowck/check_loans.rs

@@ -44,7 +44,7 @@ pub fn check_loans(bccx: @BorrowckCtxt,
                    move_data: move_data::FlowedMoveData,
                    all_loans: &[Loan],
                    body: &ast::blk) {
-    debug!("check_loans(body id=%?)", body.node.id);
+    debug!("check_loans(body id=%?)", body.id);
 
     let clcx = @mut CheckLoanCtxt {
         bccx: bccx,
@@ -751,5 +751,5 @@ fn check_loans_in_block<'a>(blk: &ast::blk,
                                          visit::vt<@mut CheckLoanCtxt<'a>>))
 {
     visit::visit_block(blk, (this, vt));
-    this.check_for_conflicting_loans(blk.node.id);
+    this.check_for_conflicting_loans(blk.id);
 }

branches/snap-stage3/src/librustc/middle/borrowck/gather_loans/mod.rs

@@ -80,8 +80,8 @@ pub fn gather_loans(bccx: @BorrowckCtxt,
         bccx: bccx,
         id_range: id_range::max(),
         all_loans: @mut ~[],
-        item_ub: body.node.id,
-        repeating_ids: ~[body.node.id],
+        item_ub: body.id,
+        repeating_ids: ~[body.id],
         move_data: @mut MoveData::new()
     };
     glcx.gather_fn_arg_patterns(decl, body);
@@ -123,9 +123,9 @@ fn gather_loans_in_fn(fk: &visit::fn_kind,
 
         // Visit closures as part of the containing item.
         &visit::fk_anon(*) | &visit::fk_fn_block(*) => {
-            this.push_repeating_id(body.node.id);
+            this.push_repeating_id(body.id);
             visit::visit_fn(fk, decl, body, sp, id, (this, v));
-            this.pop_repeating_id(body.node.id);
+            this.pop_repeating_id(body.id);
             this.gather_fn_arg_patterns(decl, body);
         }
     }
@@ -134,7 +134,7 @@ fn gather_loans_in_fn(fk: &visit::fn_kind,
 fn gather_loans_in_block(blk: &ast::blk,
                          (this, vt): (@mut GatherLoanCtxt,
                                       visit::vt<@mut GatherLoanCtxt>)) {
-    this.id_range.add(blk.node.id);
+    this.id_range.add(blk.id);
     visit::visit_block(blk, (this, vt));
 }
 
@@ -240,7 +240,7 @@ fn gather_loans_in_expr(ex: @ast::expr,
         let cmt = this.bccx.cat_expr(ex_v);
         for arms.iter().advance |arm| {
             for arm.pats.iter().advance |pat| {
-                this.gather_pat(cmt, *pat, Some((arm.body.node.id, ex.id)));
+                this.gather_pat(cmt, *pat, Some((arm.body.id, ex.id)));
             }
         }
         visit::visit_expr(ex, (this, vt));
@@ -268,16 +268,16 @@ fn gather_loans_in_expr(ex: @ast::expr,
           this.pop_repeating_id(cond.id);
 
           // during body, can only root for the body
-          this.push_repeating_id(body.node.id);
+          this.push_repeating_id(body.id);
           (vt.visit_block)(body, (this, vt));
-          this.pop_repeating_id(body.node.id);
+          this.pop_repeating_id(body.id);
       }
 
       // see explanation attached to the `root_ub` field:
       ast::expr_loop(ref body, _) => {
-          this.push_repeating_id(body.node.id);
+          this.push_repeating_id(body.id);
           visit::visit_expr(ex, (this, vt));
-          this.pop_repeating_id(body.node.id);
+          this.pop_repeating_id(body.id);
       }
 
       ast::expr_fn_block(*) => {
@@ -623,7 +623,7 @@ impl GatherLoanCtxt {
             let arg_cmt = mc_ctxt.cat_rvalue(
                 arg.id,
                 arg.pat.span,
-                body.node.id, // Arguments live only as long as the fn body.
+                body.id, // Arguments live only as long as the fn body.
                 arg_ty);
 
             self.gather_pat(arg_cmt, arg.pat, None);

branches/snap-stage3/src/librustc/middle/cfg/construct.rs

@@ -53,13 +53,13 @@ pub fn construct(tcx: ty::ctxt,
 impl CFGBuilder {
     fn block(&mut self, blk: &ast::blk, pred: CFGIndex) -> CFGIndex {
         let mut stmts_exit = pred;
-        for blk.node.stmts.iter().advance |&stmt| {
+        for blk.stmts.iter().advance |&stmt| {
             stmts_exit = self.stmt(stmt, stmts_exit);
         }
 
-        let expr_exit = self.opt_expr(blk.node.expr, stmts_exit);
+        let expr_exit = self.opt_expr(blk.expr, stmts_exit);
 
-        self.add_node(blk.node.id, [expr_exit])
+        self.add_node(blk.id, [expr_exit])
     }
 
     fn stmt(&mut self, stmt: @ast::stmt, pred: CFGIndex) -> CFGIndex {

branches/snap-stage3/src/librustc/middle/dataflow.rs

@@ -330,7 +330,7 @@ impl<O:DataFlowOperator+Copy+'static> DataFlowContext<O> {
         let pre: @fn(pprust::ann_node) = |node| {
             let (ps, id) = match node {
                 pprust::node_expr(ps, expr) => (ps, expr.id),
-                pprust::node_block(ps, blk) => (ps, blk.node.id),
+                pprust::node_block(ps, blk) => (ps, blk.id),
                 pprust::node_item(ps, _) => (ps, 0),
                 pprust::node_pat(ps, pat) => (ps, pat.id)
             };
@@ -383,18 +383,18 @@ impl<'self, O:DataFlowOperator> PropagationContext<'self, O> {
                   blk: &ast::blk,
                   in_out: &mut [uint],
                   loop_scopes: &mut ~[LoopScope]) {
-        debug!("DataFlowContext::walk_block(blk.node.id=%?, in_out=%s)",
-               blk.node.id, bits_to_str(reslice(in_out)));
+        debug!("DataFlowContext::walk_block(blk.id=%?, in_out=%s)",
+               blk.id, bits_to_str(reslice(in_out)));
 
-        self.merge_with_entry_set(blk.node.id, in_out);
+        self.merge_with_entry_set(blk.id, in_out);
 
-        for blk.node.stmts.iter().advance |&stmt| {
+        for blk.stmts.iter().advance |&stmt| {
             self.walk_stmt(stmt, in_out, loop_scopes);
         }
 
-        self.walk_opt_expr(blk.node.expr, in_out, loop_scopes);
+        self.walk_opt_expr(blk.expr, in_out, loop_scopes);
 
-        self.dfcx.apply_gen_kill(blk.node.id, in_out);
+        self.dfcx.apply_gen_kill(blk.id, in_out);
     }
 
     fn walk_stmt(&mut self,

branches/snap-stage3/src/librustc/middle/effect.rs

@@ -99,9 +99,9 @@ pub fn check_crate(tcx: ty::ctxt,
 
         visit_block: |block, (_, visitor)| {
             let old_unsafe_context = context.unsafe_context;
-            if block.node.rules == unsafe_blk &&
+            if block.rules == unsafe_blk &&
                     context.unsafe_context == SafeContext {
-                context.unsafe_context = UnsafeBlock(block.node.id)
+                context.unsafe_context = UnsafeBlock(block.id)
             }
 
             visit::visit_block(block, ((), visitor));

branches/snap-stage3/src/librustc/middle/kind.rs

@@ -122,7 +122,7 @@ fn check_item(item: @item, (cx, visitor): (Context, visit::vt<Context>)) {
                     None => cx.tcx.sess.bug("trait ref not in def map!"),
                     Some(&trait_def) => {
                         let trait_def_id = ast_util::def_id_of_def(trait_def);
-                        if cx.tcx.lang_items.drop_trait() == Some(trait_def_id) {
+                        if cx.tcx.lang_items.drop_trait() == trait_def_id {
                             // Yes, it's a destructor.
                             match self_type.node {
                                 ty_path(_, ref bounds, path_node_id) => {