---

yaml
---
r: 64380
b: refs/heads/snap-stage3
c: 827a6d2
h: refs/heads/master
v: v3

Author: gifnksm

[refs]

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

branches/snap-stage3/doc/tutorial.md

@@ -84,7 +84,7 @@ supported build environments that are most likely to work.
 > know.
 
 [bug-3319]: https://github.com/mozilla/rust/issues/3319
-[wiki-start]:	https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
+[wiki-start]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
 
 To build from source you will also need the following prerequisite
 packages:
@@ -118,7 +118,6 @@ API-documentation tool; `rustpkg`, the Rust package manager;
 `rusti`, the Rust REPL; and `rust`, a tool which acts both as a unified
 interface for them, and for a few common command line scenarios.
 
-[wiki-start]: https://github.com/mozilla/rust/wiki/Note-getting-started-developing-Rust
 [tarball]: http://static.rust-lang.org/dist/rust-0.7.tar.gz
 [win-exe]: http://static.rust-lang.org/dist/rust-0.7-install.exe
 
@@ -410,8 +409,6 @@ println(fmt!("what is this thing: %?", mystery_object));
 
 You can define your own syntax extensions with the macro system. For details, see the [macro tutorial][macros].
 
-[macros]: tutorial-macros.html
-
 # Control structures
 
 ## Conditionals
@@ -1512,8 +1509,6 @@ closures, but they also own them: that is, no other code can access
 them. Owned closures are used in concurrent code, particularly
 for spawning [tasks][tasks].
 
-[tasks]: tutorial-tasks.html
-
 ## Closure compatibility
 
 Rust closures have a convenient subtyping property: you can pass any kind of
@@ -2534,9 +2529,4 @@ There is further documentation on the [wiki].
 [ffi]: tutorial-ffi.html
 
 [wiki]: https://github.com/mozilla/rust/wiki/Docs
-[unit testing]: https://github.com/mozilla/rust/wiki/Doc-unit-testing
-[rustdoc]: https://github.com/mozilla/rust/wiki/Doc-using-rustdoc
-[cargo]: https://github.com/mozilla/rust/wiki/Doc-using-cargo-to-manage-packages
-[attributes]: https://github.com/mozilla/rust/wiki/Doc-attributes
 
-[pound-rust]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust

branches/snap-stage3/src/libextra/dlist.rs

@@ -173,11 +173,11 @@ impl<T> Deque<T> for DList<T> {
                 let tail_own = match tail.prev.resolve() {
                     None => {
                         self.list_tail = Rawlink::none();
-                        self.list_head.take_unwrap()
+                        self.list_head.swap_unwrap()
                     },
                     Some(tail_prev) => {
                         self.list_tail = tail.prev;
-                        tail_prev.next.take_unwrap()
+                        tail_prev.next.swap_unwrap()
                     }
                 };
                 Some(tail_own.value)
@@ -465,7 +465,7 @@ impl<'self, A> ListInsertion<A> for MutDListIterator<'self, A> {
                     Some(prev) => prev,
                 };
                 let mut ins_node = ~Node{value: elt, next: None, prev: Rawlink::none()};
-                let node_own = prev_node.next.take_unwrap();
+                let node_own = prev_node.next.swap_unwrap();
                 ins_node.next = link_with_prev(node_own, Rawlink::some(ins_node));
                 prev_node.next = link_with_prev(ins_node, Rawlink::some(prev_node));
                 self.list.length += 1;

branches/snap-stage3/src/libextra/net/ip.rs

@@ -116,7 +116,7 @@ pub fn get_addr(node: &str, iotask: &iotask)
     let (output_po, output_ch) = stream();
     let mut output_ch = Some(SharedChan::new(output_ch));
     do str::as_buf(node) |node_ptr, len| {
-        let output_ch = output_ch.take_unwrap();
+        let output_ch = output_ch.swap_unwrap();
         debug!("slice len %?", len);
         let handle = create_uv_getaddrinfo_t();
         let handle_ptr: *uv_getaddrinfo_t = &handle;

branches/snap-stage3/src/libextra/sync.rs

@@ -260,7 +260,7 @@ impl<'self> Condvar<'self> {
                             signal_waitqueue(&state.waiters);
                         }
                         // Enqueue ourself to be woken up by a signaller.
-                        let SignalEnd = SignalEnd.take_unwrap();
+                        let SignalEnd = SignalEnd.swap_unwrap();
                         state.blocked[condvar_id].tail.send(SignalEnd);
                     } else {
                         out_of_bounds = Some(state.blocked.len());
@@ -281,7 +281,7 @@ impl<'self> Condvar<'self> {
             // Unconditionally "block". (Might not actually block if a
             // signaller already sent -- I mean 'unconditionally' in contrast
             // with acquire().)
-            let _ = comm::recv_one(WaitEnd.take_unwrap());
+            let _ = comm::recv_one(WaitEnd.swap_unwrap());
         }
 
         // This is needed for a failing condition variable to reacquire the
@@ -353,7 +353,7 @@ impl<'self> Condvar<'self> {
                 }
             }
             do check_cvar_bounds(out_of_bounds, condvar_id, "cond.signal_on()") {
-                let queue = queue.take_unwrap();
+                let queue = queue.swap_unwrap();
                 broadcast_waitqueue(&queue)
             }
         }
@@ -1436,7 +1436,7 @@ mod tests {
         do x.write_downgrade |xwrite| {
             let mut xopt = Some(xwrite);
             do y.write_downgrade |_ywrite| {
-                y.downgrade(xopt.take_unwrap());
+                y.downgrade(xopt.swap_unwrap());
                 error!("oops, y.downgrade(x) should have failed!");
             }
         }

branches/snap-stage3/src/libextra/treemap.rs

@@ -552,7 +552,7 @@ fn mutate_values<'r, K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
 // Remove left horizontal link by rotating right
 fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     if node.left.map_default(false, |x| x.level == node.level) {
-        let mut save = node.left.take_unwrap();
+        let mut save = node.left.swap_unwrap();
         swap(&mut node.left, &mut save.right); // save.right now None
         swap(node, &mut save);
         node.right = Some(save);
@@ -564,7 +564,7 @@ fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
 fn split<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     if node.right.map_default(false,
       |x| x.right.map_default(false, |y| y.level == node.level)) {
-        let mut save = node.right.take_unwrap();
+        let mut save = node.right.swap_unwrap();
         swap(&mut node.right, &mut save.left); // save.left now None
         save.level += 1;
         swap(node, &mut save);
@@ -643,7 +643,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
           Equal => {
             if save.left.is_some() {
                 if save.right.is_some() {
-                    let mut left = save.left.take_unwrap();
+                    let mut left = save.left.swap_unwrap();
                     if left.right.is_some() {
                         heir_swap(save, &mut left.right);
                     } else {
@@ -653,13 +653,13 @@ fn remove<K: TotalOrd, V>(node: &mut Option<~TreeNode<K, V>>,
                     save.left = Some(left);
                     (remove(&mut save.left, key), true)
                 } else {
-                    let new = save.left.take_unwrap();
+                    let new = save.left.swap_unwrap();
                     let ~TreeNode{value, _} = replace(save, new);
-                    *save = save.left.take_unwrap();
+                    *save = save.left.swap_unwrap();
                     (Some(value), true)
                 }
             } else if save.right.is_some() {
-                let new = save.right.take_unwrap();
+                let new = save.right.swap_unwrap();
                 let ~TreeNode{value, _} = replace(save, new);
                 (Some(value), true)
             } else {

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.id));
+                s, ~"block " + int::to_str(blk.node.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: |a,b| fold_block(ctxt, a, b),
+          fold_block: fold::wrap(|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,22 +133,21 @@ 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,20 +300,19 @@ 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,
-            span: blk.span,
+            rules: blk.rules
         };
         fold::noop_fold_block(&blk_sans_items, fld)
     }
 
     let fld = fold::make_fold(@fold::AstFoldFns {
-        fold_block: drop_nested_items,
+        fold_block: fold::wrap(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.id);
+    debug!("check_loans(body id=%?)", body.node.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.id);
+    this.check_for_conflicting_loans(blk.node.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.id,
-        repeating_ids: ~[body.id],
+        item_ub: body.node.id,
+        repeating_ids: ~[body.node.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.id);
+            this.push_repeating_id(body.node.id);
             visit::visit_fn(fk, decl, body, sp, id, (this, v));
-            this.pop_repeating_id(body.id);
+            this.pop_repeating_id(body.node.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.id);
+    this.id_range.add(blk.node.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.id, ex.id)));
+                this.gather_pat(cmt, *pat, Some((arm.body.node.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.id);
+          this.push_repeating_id(body.node.id);
           (vt.visit_block)(body, (this, vt));
-          this.pop_repeating_id(body.id);
+          this.pop_repeating_id(body.node.id);
       }
 
       // see explanation attached to the `root_ub` field:
       ast::expr_loop(ref body, _) => {
-          this.push_repeating_id(body.id);
+          this.push_repeating_id(body.node.id);
           visit::visit_expr(ex, (this, vt));
-          this.pop_repeating_id(body.id);
+          this.pop_repeating_id(body.node.id);
       }
 
       ast::expr_fn_block(*) => {
@@ -623,7 +623,7 @@ impl GatherLoanCtxt {
             let arg_cmt = mc_ctxt.cat_rvalue(
                 arg.id,
                 arg.pat.span,
-                body.id, // Arguments live only as long as the fn body.
+                body.node.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.stmts.iter().advance |&stmt| {
+        for blk.node.stmts.iter().advance |&stmt| {
             stmts_exit = self.stmt(stmt, stmts_exit);
         }
 
-        let expr_exit = self.opt_expr(blk.expr, stmts_exit);
+        let expr_exit = self.opt_expr(blk.node.expr, stmts_exit);
 
-        self.add_node(blk.id, [expr_exit])
+        self.add_node(blk.node.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.id),
+                pprust::node_block(ps, blk) => (ps, blk.node.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.id=%?, in_out=%s)",
-               blk.id, bits_to_str(reslice(in_out)));
+        debug!("DataFlowContext::walk_block(blk.node.id=%?, in_out=%s)",
+               blk.node.id, bits_to_str(reslice(in_out)));
 
-        self.merge_with_entry_set(blk.id, in_out);
+        self.merge_with_entry_set(blk.node.id, in_out);
 
-        for blk.stmts.iter().advance |&stmt| {
+        for blk.node.stmts.iter().advance |&stmt| {
             self.walk_stmt(stmt, in_out, loop_scopes);
         }
 
-        self.walk_opt_expr(blk.expr, in_out, loop_scopes);
+        self.walk_opt_expr(blk.node.expr, in_out, loop_scopes);
 
-        self.dfcx.apply_gen_kill(blk.id, in_out);
+        self.dfcx.apply_gen_kill(blk.node.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.rules == unsafe_blk &&
+            if block.node.rules == unsafe_blk &&
                     context.unsafe_context == SafeContext {
-                context.unsafe_context = UnsafeBlock(block.id)
+                context.unsafe_context = UnsafeBlock(block.node.id)
             }
 
             visit::visit_block(block, ((), visitor));