---

yaml
---
r: 33951
b: refs/heads/snap-stage3
c: 7203be1
h: refs/heads/master
i:
  33949: adf266b
  33947: 4cccb6f
  33943: 1eadd91
  33935: 009c3e0
  33919: ecb866d
v: v3

Author: pcwalton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b58e1f6690c16ee77e21cfab145a0ee307a00695
+refs/heads/snap-stage3: 7203be1109d6e29dce14a842d454922c665ade3f
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -316,7 +316,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         match st.tcx.rcache.find({cnum: st.crate, pos: pos, len: len}) {
           Some(tt) => return tt,
           None => {
-            let ps = @{pos: pos ,.. *st};
+            let ps = @{pos: pos ,.. copy *st};
             let tt = parse_ty(ps, conv);
             st.tcx.rcache.insert({cnum: st.crate, pos: pos, len: len}, tt);
             return tt;

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

@@ -4,12 +4,11 @@ use middle::typeck::{method_map, method_map_entry};
 
 use core::vec;
 use std::map::HashMap;
-use syntax::ast::{by_copy, by_move, by_ref, by_val, crate, expr, expr_assign};
-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_match, expr_paren};
+use syntax::ast::{box, by_copy, by_move, by_ref, by_val, crate, deref, expr};
+use syntax::ast::{expr_addr_of, expr_assign, expr_assign_op, expr_binary};
+use syntax::ast::{expr_call, expr_copy, expr_field, expr_index, expr_match};
+use syntax::ast::{expr_method_call, expr_paren, expr_path, expr_swap};
+use syntax::ast::{expr_unary, neg, node_id, not, sty_uniq, sty_value, uniq};
 use syntax::visit;
 use syntax::visit::vt;
 
@@ -115,17 +114,25 @@ fn compute_modes_for_expr(expr: @expr,
             compute_modes_for_expr(arg, arg_cx, v);
         }
         expr_unary(unop, arg) => {
-            // Ditto.
-            let arg_cx = VisitContext { mode: ReadValue, ..cx };
-            compute_modes_for_expr(arg, arg_cx, v);
-
             match unop {
                 deref => {
+                    // Derefs function as reads.
+                    let arg_cx = VisitContext { mode: ReadValue, ..cx };
+                    compute_modes_for_expr(arg, arg_cx, v);
+
                     // This is an lvalue, so it needs a value mode recorded
                     // for it.
                     record_mode_for_expr(expr, cx);
                 }
-                box(_) | uniq(_) | not | neg => {}
+                box(_) | uniq(_) => {
+                    let arg_cx = VisitContext { mode: MoveValue, ..cx };
+                    compute_modes_for_expr(arg, arg_cx, v);
+                }
+                not | neg => {
+                    // Takes its argument by ref.
+                    let arg_cx = VisitContext { mode: ReadValue, ..cx };
+                    compute_modes_for_expr(arg, arg_cx, v);
+                }
             }
         }
         expr_field(arg, _, _) => {

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2457,7 +2457,7 @@ fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool {
 
 fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool {
     let fcx = match blk.node.rules {
-      ast::unsafe_blk => @fn_ctxt {purity: ast::unsafe_fn,.. *fcx0},
+      ast::unsafe_blk => @fn_ctxt {purity: ast::unsafe_fn,.. copy *fcx0},
       ast::default_blk => fcx0
     };
     do fcx.with_region_lb(blk.node.id) {

branches/snap-stage3/src/test/compile-fail/move-based-on-type-tuple.rs

@@ -0,0 +1,4 @@
+fn dup(x: ~int) -> ~(~int,~int) { ~(x, x) } //~ ERROR use of moved variable
+fn main() {
+    dup(~3);
+}