---

yaml
---
r: 40642
b: refs/heads/dist-snap
c: 1282fc8
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: a05ba09d904b366f467479cb022c76f287befa43
+refs/heads/dist-snap: 1282fc80740b5c462a094c45f65cb1ce0c1d7756
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/path.rs

@@ -502,7 +502,7 @@ impl PosixPath : GenericPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(move ss); }
-        PosixPath { components: move v, ..self }
+        PosixPath { components: move v, ..copy self }
     }
 
     pure fn pop() -> PosixPath {
@@ -707,7 +707,7 @@ impl WindowsPath : GenericPath {
         let mut v = copy self.components;
         let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
         unsafe { v.push_all_move(move ss); }
-        return WindowsPath { components: move v, ..self }
+        return WindowsPath { components: move v, ..copy self }
     }
 
     pure fn pop() -> WindowsPath {

branches/dist-snap/src/libcore/task/mod.rs

@@ -215,25 +215,25 @@ pub type TaskOpts = {
 // the run function move them in.
 
 // FIXME (#3724): Replace the 'consumed' bit with move mode on self
-pub enum TaskBuilder = {
+pub struct TaskBuilder {
     opts: TaskOpts,
     gen_body: fn@(v: fn~()) -> fn~(),
     can_not_copy: Option<util::NonCopyable>,
     mut consumed: bool,
-};
+}
 
 /**
  * Generate the base configuration for spawning a task, off of which more
  * configuration methods can be chained.
  * For example, task().unlinked().spawn is equivalent to spawn_unlinked.
  */
 pub fn task() -> TaskBuilder {
-    TaskBuilder({
+    TaskBuilder {
         opts: default_task_opts(),
         gen_body: |body| move body, // Identity function
         can_not_copy: None,
         mut consumed: false,
-    })
+    }
 }
 
 #[doc(hidden)] // FIXME #3538
@@ -244,7 +244,7 @@ priv impl TaskBuilder {
         }
         self.consumed = true;
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
@@ -254,7 +254,7 @@ priv impl TaskBuilder {
             gen_body: self.gen_body,
             can_not_copy: None,
             mut consumed: false
-        })
+        }
     }
 }
 
@@ -265,16 +265,16 @@ impl TaskBuilder {
      */
     fn unlinked() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: false,
                 supervised: self.opts.supervised,
                 mut notify_chan: move notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
     /**
      * Unidirectionally link the child task's failure with the parent's. The
@@ -283,33 +283,33 @@ impl TaskBuilder {
      */
     fn supervised() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: false,
                 supervised: true,
                 mut notify_chan: move notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
     /**
      * Link the child task's and parent task's failures. If either fails, the
      * other will be killed.
      */
     fn linked() -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: true,
                 supervised: false,
                 mut notify_chan: move notify_chan,
                 sched: self.opts.sched
             },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
 
     /**
@@ -345,30 +345,30 @@ impl TaskBuilder {
         blk(move notify_pipe_po);
 
         // Reconfigure self to use a notify channel.
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
                 mut notify_chan: Some(move notify_pipe_ch),
                 sched: self.opts.sched
             },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
     /// Configure a custom scheduler mode for the task.
     fn sched_mode(mode: SchedMode) -> TaskBuilder {
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
                 mut notify_chan: move notify_chan,
                 sched: Some({ mode: mode, foreign_stack_size: None})
             },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
 
     /**
@@ -386,7 +386,7 @@ impl TaskBuilder {
     fn add_wrapper(wrapper: fn@(v: fn~()) -> fn~()) -> TaskBuilder {
         let prev_gen_body = self.gen_body;
         let notify_chan = replace(&mut self.opts.notify_chan, None);
-        TaskBuilder({
+        TaskBuilder {
             opts: {
                 linked: self.opts.linked,
                 supervised: self.opts.supervised,
@@ -399,8 +399,8 @@ impl TaskBuilder {
             gen_body: |move prev_gen_body,
                        body| { wrapper(prev_gen_body(move body)) },
             can_not_copy: None,
-            .. *self.consume()
-        })
+            .. self.consume()
+        }
     }
 
     /**
@@ -782,11 +782,11 @@ fn test_spawn_linked_sup_fail_up() { // child fails; parent fails
     };
 
     let b0 = task();
-    let b1 = TaskBuilder({
+    let b1 = TaskBuilder {
         opts: move opts,
         can_not_copy: None,
         .. *b0
-    });
+    };
     do b1.spawn { fail; }
     comm::recv(po); // We should get punted awake
 }
@@ -802,11 +802,11 @@ fn test_spawn_linked_sup_fail_down() { // parent fails; child fails
     };
 
     let b0 = task();
-    let b1 = TaskBuilder({
+    let b1 = TaskBuilder {
         opts: move opts,
         can_not_copy: None,
         .. *b0
-    });
+    };
     do b1.spawn { loop { task::yield(); } }
     fail; // *both* mechanisms would be wrong if this didn't kill the child...
 }

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

@@ -17,6 +17,8 @@
 // 3. assignments do not affect things loaned out as immutable
 // 4. moves to dnot affect things loaned out in any way
 
+use middle::ty::{CopyValue, MoveValue, ReadValue};
+
 use dvec::DVec;
 
 export check_loans;
@@ -624,6 +626,12 @@ fn check_loans_in_expr(expr: @ast::expr,
 
     self.check_for_conflicting_loans(expr.id);
 
+    // If this is a move, check it.
+    match self.tcx().value_modes.find(expr.id) {
+        Some(MoveValue) => self.check_move_out(expr),
+        Some(ReadValue) | Some(CopyValue) | None => {}
+    }
+
     match expr.node {
       ast::expr_path(*) if self.bccx.last_use_map.contains_key(expr.id) => {
         self.check_last_use(expr);

branches/dist-snap/src/librustc/middle/mode.rs

@@ -9,7 +9,7 @@ use syntax::ast::{expr_addr_of, expr_assign_op, expr_binary, expr_call};
 use syntax::ast::{expr_copy, expr_field, expr_index, expr_method_call};
 use syntax::ast::{expr_path, expr_swap, expr_unary, node_id, sty_uniq};
 use syntax::ast::{sty_value};
-use syntax::ast::{box, uniq, deref, not, neg, expr_paren};
+use syntax::ast::{box, uniq, deref, not, neg, expr_match, expr_paren};
 use syntax::visit;
 use syntax::visit::vt;
 
@@ -158,6 +158,21 @@ fn compute_modes_for_expr(expr: @expr,
             compute_modes_for_expr(arg, cx, v);
             record_mode_for_expr(expr, cx);
         }
+        expr_match(head, ref arms) => {
+            let by_move_bindings_present =
+                pat_util::arms_have_by_move_bindings(cx.tcx.def_map, *arms);
+            if by_move_bindings_present {
+                // Propagate the current mode flag downward.
+                visit::visit_expr(expr, cx, v);
+            } else {
+                // We aren't moving into any pattern, so this is just a read.
+                let head_cx = VisitContext { mode: ReadValue, ..cx };
+                compute_modes_for_expr(head, head_cx, v);
+                for arms.each |arm| {
+                    (v.visit_arm)(*arm, cx, v);
+                }
+            }
+        }
         _ => {
             // XXX: Spell out every expression above so when we add them we
             // don't forget to update this file.

branches/dist-snap/src/librustc/middle/pat_util.rs

@@ -19,6 +19,7 @@ use std::map::HashMap;
 export pat_binding_ids, pat_bindings, pat_id_map, PatIdMap;
 export pat_is_variant_or_struct, pat_is_binding, pat_is_binding_or_wild;
 export pat_is_const;
+export arms_have_by_move_bindings;
 
 type PatIdMap = std::map::HashMap<ident, node_id>;
 
@@ -91,3 +92,22 @@ fn pat_binding_ids(dm: resolve::DefMap, pat: @pat) -> ~[node_id] {
     pat_bindings(dm, pat, |_bm, b_id, _sp, _pt| found.push(b_id) );
     return found;
 }
+
+fn arms_have_by_move_bindings(dm: resolve::DefMap, +arms: &[arm]) -> bool {
+    for arms.each |arm| {
+        for arm.pats.each |pat| {
+            let mut found = false;
+            do pat_bindings(dm, *pat) |binding_mode, _node_id, _span, _path| {
+                match binding_mode {
+                    bind_by_move => found = true,
+                    bind_by_implicit_ref |
+                    bind_by_ref(*) |
+                    bind_by_value => {}
+                }
+            }
+            if found { return true; }
+        }
+    }
+    return false;
+}
+

branches/dist-snap/src/librustdoc/attr_pass.rs

@@ -18,6 +18,7 @@ of the natural-language documentation for a crate.
 
 use doc::ItemUtils;
 use extract::to_str;
+use fold::Fold;
 use syntax::ast;
 use syntax::ast_map;
 use std::map::HashMap;
@@ -33,14 +34,14 @@ fn run(
     srv: astsrv::Srv,
     +doc: doc::Doc
 ) -> doc::Doc {
-    let fold = fold::Fold({
+    let fold = Fold {
         fold_crate: fold_crate,
         fold_item: fold_item,
         fold_enum: fold_enum,
         fold_trait: fold_trait,
         fold_impl: fold_impl,
-        .. *fold::default_any_fold(srv)
-    });
+        .. fold::default_any_fold(srv)
+    };
     (fold.fold_doc)(&fold, doc)
 }
 

branches/dist-snap/src/librustdoc/desc_to_brief_pass.rs

@@ -16,6 +16,7 @@ is interpreted as the brief description.
 */
 
 use doc::ItemUtils;
+use fold::Fold;
 
 pub fn mk_pass() -> Pass {
     {
@@ -28,12 +29,12 @@ fn run(
     _srv: astsrv::Srv,
     +doc: doc::Doc
 ) -> doc::Doc {
-    let fold = fold::Fold({
+    let fold = Fold {
         fold_item: fold_item,
         fold_trait: fold_trait,
         fold_impl: fold_impl,
-        .. *fold::default_any_fold(())
-    });
+        .. fold::default_any_fold(())
+    };
     (fold.fold_doc)(&fold, doc)
 }