Finalize moves-based-on-type implementation.

Changes:

- Refactor move mode computation
- Removes move mode arguments, unary move, capture clauses
  (though they still parse for backwards compatibility)
- Simplify how moves are handled in trans
- Fix a number of illegal copies that cropped up
- Workaround for bug involving def-ids in params
  (see details below)

Future work (I'll open bugs for these...):

- Improve error messages for moves that are due
  to bindings
- Add support for moving owned content like a.b.c
  to borrow check, test in trans (but I think it'll
  "just work")
- Proper fix for def-ids in params

Def ids in params:

Move captures into a map instead of recomputing.

This is a workaround for a larger bug having to do with the def-ids associated
with ty_params, which are not always properly preserved when inlining.  I am
not sure of my preferred fix for the larger bug yet.  This current fix removes
the only code in trans that I know of which relies on ty_param def-ids, but
feels fragile.

Author: nikomatsakis

doc/rust.md

@@ -1234,7 +1234,7 @@ For example:
 
 ~~~~
 trait Num {
-    static pure fn from_int(n: int) -> self;
+    static pure fn from_int(n: int) -> Self;
 }
 impl float: Num {
     static pure fn from_int(n: int) -> float { n as float }

doc/tutorial-tasks.md

@@ -440,8 +440,8 @@ Finally, tasks can be configured to not propagate failure to each
 other at all, using `task::spawn_unlinked` for _isolated failure_.
 
 ~~~
-# fn random() -> int { 100 }
-# fn sleep_for(i: int) { for i.times { task::yield() } }
+# fn random() -> uint { 100 }
+# fn sleep_for(i: uint) { for i.times { task::yield() } }
 # do task::try::<()> {
 let (time1, time2) = (random(), random());
 do task::spawn_unlinked {

src/etc/tidy.py

@@ -51,7 +51,7 @@ def do_license_check(name, contents):
                 report_err("TODO is deprecated; use FIXME")
             idx = line.find("// NOTE")
             if idx != -1:
-                report_warn("NOTE:" + line[idx + len("// NOTE"):])
+                report_warn("NOTE" + line[idx + len("// NOTE"):])
         if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")

src/libcargo/cargo.rc

@@ -1965,19 +1965,17 @@ pub fn main() {
         c = configure(o);
     }
 
-    let c = &move c;
-
     match o.free[1] {
-        ~"init" => cmd_init(c),
-        ~"install" => cmd_install(c),
-        ~"uninstall" => cmd_uninstall(c),
-        ~"list" => cmd_list(c),
-        ~"search" => cmd_search(c),
-        ~"sources" => cmd_sources(c),
+        ~"init" => cmd_init(&c),
+        ~"install" => cmd_install(&c),
+        ~"uninstall" => cmd_uninstall(&c),
+        ~"list" => cmd_list(&c),
+        ~"search" => cmd_search(&c),
+        ~"sources" => cmd_sources(&c),
         _ => cmd_usage()
     }
 
-    dump_cache(c);
-    dump_sources(c);
+    dump_cache(&c);
+    dump_sources(&c);
 }
 

src/libcore/private/global.rs

@@ -177,8 +177,10 @@ fn get_global_state() -> Exclusive<GlobalState> {
         let state = ~exclusive(state);
 
         // Convert it to an integer
-        let state_ptr: &Exclusive<GlobalState> = state;
-        let state_i: int = unsafe { transmute(state_ptr) };
+        let state_i: int = unsafe {
+            let state_ptr: &Exclusive<GlobalState> = state;
+            transmute(state_ptr)
+        };
 
         // Swap our structure into the global pointer
         let prev_i = unsafe { atomic_cxchg(&mut *global_ptr, 0, state_i) };

src/libcore/task/mod.rs

@@ -836,12 +836,20 @@ fn test_run_basic() {
     po.recv();
 }
 
+#[test]
+struct Wrapper {
+    mut f: Option<Chan<()>>
+}
+
 #[test]
 fn test_add_wrapper() {
     let (po, ch) = stream::<()>();
     let b0 = task();
+    let ch = Wrapper { f: Some(ch) };
     let b1 = do b0.add_wrapper |body| {
+        let ch = Wrapper { f: Some(ch.f.swap_unwrap()) };
         fn~(move body) {
+            let ch = ch.f.swap_unwrap();
             body();
             ch.send(());
         }
@@ -929,9 +937,12 @@ fn test_spawn_sched_childs_on_default_sched() {
     // Assuming tests run on the default scheduler
     let default_id = unsafe { rt::rust_get_sched_id() };
 
+    let ch = Wrapper { f: Some(ch) };
     do spawn_sched(SingleThreaded) {
         let parent_sched_id = unsafe { rt::rust_get_sched_id() };
+        let ch = Wrapper { f: Some(ch.f.swap_unwrap()) };
         do spawn {
+            let ch = ch.f.swap_unwrap();
             let child_sched_id = unsafe { rt::rust_get_sched_id() };
             assert parent_sched_id != child_sched_id;
             assert child_sched_id == default_id;

src/librustc/back/rpath.rs

@@ -191,7 +191,7 @@ pub fn minimize_rpaths(rpaths: &[Path]) -> ~[Path] {
     let mut minimized = ~[];
     for rpaths.each |rpath| {
         let s = rpath.to_str();
-        if !set.contains_key(s) {
+        if !set.contains_key_ref(&s) {
             minimized.push(/*bad*/copy *rpath);
             set.insert(s, ());
         }

src/librustc/driver/driver.rs

@@ -16,7 +16,7 @@ use front;
 use lib::llvm::llvm;
 use metadata::{creader, cstore, filesearch};
 use metadata;
-use middle::{trans, freevars, kind, ty, typeck, lint};
+use middle::{trans, freevars, kind, ty, typeck, lint, astencode};
 use middle;
 use session::{Session, Session_, OptLevel, No, Less, Default, Aggressive};
 use session;
@@ -281,20 +281,26 @@ pub fn compile_upto(sess: Session, cfg: ast::crate_cfg,
         time(time_passes, ~"loop checking", ||
              middle::check_loop::check_crate(ty_cx, crate));
 
-        time(time_passes, ~"mode computation", ||
-             middle::mode::compute_modes(ty_cx, method_map, crate));
+        let middle::moves::MoveMaps {moves_map, variable_moves_map,
+                                     capture_map} =
+            time(time_passes, ~"compute moves", ||
+                 middle::moves::compute_moves(ty_cx, method_map, crate));
 
         time(time_passes, ~"match checking", ||
-             middle::check_match::check_crate(ty_cx, method_map, crate));
+             middle::check_match::check_crate(ty_cx, method_map,
+                                              moves_map, crate));
 
         let last_use_map =
             time(time_passes, ~"liveness checking", ||
-                 middle::liveness::check_crate(ty_cx, method_map, crate));
+                 middle::liveness::check_crate(ty_cx, method_map,
+                                               variable_moves_map,
+                                               capture_map, crate));
 
         let (root_map, mutbl_map, write_guard_map) =
             time(time_passes, ~"borrow checking", ||
                  middle::borrowck::check_crate(ty_cx, method_map,
-                                               last_use_map, crate));
+                                               moves_map, capture_map,
+                                               crate));
 
         time(time_passes, ~"kind checking", ||
              kind::check_crate(ty_cx, method_map, last_use_map, crate));
@@ -304,12 +310,16 @@ pub fn compile_upto(sess: Session, cfg: ast::crate_cfg,
 
         if upto == cu_no_trans { return {crate: crate, tcx: Some(ty_cx)}; }
 
-        let maps = {mutbl_map: mutbl_map,
-                    root_map: root_map,
-                    last_use_map: last_use_map,
-                    method_map: method_map,
-                    vtable_map: vtable_map,
-                    write_guard_map: write_guard_map};
+        let maps = astencode::Maps {
+            mutbl_map: mutbl_map,
+            root_map: root_map,
+            last_use_map: last_use_map,
+            method_map: method_map,
+            vtable_map: vtable_map,
+            write_guard_map: write_guard_map,
+            moves_map: moves_map,
+            capture_map: capture_map
+        };
 
         time(time_passes, ~"translation", ||
              trans::base::trans_crate(sess, crate, ty_cx,
@@ -528,7 +538,7 @@ pub fn build_session_options(+binary: ~str,
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
             let lint_name = str::replace(*lint_name, ~"-", ~"_");
-            match lint_dict.find(lint_name) {
+            match lint_dict.find(/*bad*/ copy lint_name) {
               None => {
                 early_error(demitter, fmt!("unknown %s flag: %s",
                                            level_name, lint_name));

src/librustc/front/config.rs

@@ -190,7 +190,7 @@ pub fn metas_in_cfg(cfg: ast::crate_cfg,
     if !has_cfg_metas { return true; }
 
     for cfg_metas.each |cfg_mi| {
-        if attr::contains(/*bad*/copy cfg, *cfg_mi) { return true; }
+        if attr::contains(cfg, *cfg_mi) { return true; }
     }
 
     return false;

src/librustc/front/test.rs

@@ -46,7 +46,7 @@ pub fn modify_for_testing(sess: session::Session,
     // We generate the test harness when building in the 'test'
     // configuration, either with the '--test' or '--cfg test'
     // command line options.
-    let should_test = attr::contains(/*bad*/copy crate.node.config,
+    let should_test = attr::contains(crate.node.config,
                                      attr::mk_word_item(~"test"));
 
     if should_test {
@@ -510,7 +510,7 @@ fn mk_test_wrapper(cx: test_ctxt,
     let wrapper_expr = ast::expr  {
         id: cx.sess.next_node_id(),
         callee_id: cx.sess.next_node_id(),
-        node: ast::expr_fn(ast::ProtoBare, wrapper_decl, wrapper_body, @~[]),
+        node: ast::expr_fn(ast::ProtoBare, wrapper_decl, wrapper_body),
         span: span
     };
 

src/librustc/lib/llvm.rs

@@ -1344,23 +1344,22 @@ pub fn mk_type_names() -> type_names {
 }
 
 pub fn type_to_str(names: type_names, ty: TypeRef) -> @str {
-    return type_to_str_inner(names, ~[], ty);
+    return type_to_str_inner(names, [], ty);
 }
 
-pub fn type_to_str_inner(names: type_names, +outer0: ~[TypeRef], ty: TypeRef)
+pub fn type_to_str_inner(names: type_names, +outer0: &[TypeRef], ty: TypeRef)
                       -> @str {
     unsafe {
         match type_has_name(names, ty) {
           option::Some(n) => return n,
           _ => {}
         }
 
-        // FIXME #2543: Bad copy.
-        let outer = vec::append_one(copy outer0, ty);
+        let outer = vec::append_one(outer0.to_vec(), ty);
 
         let kind = llvm::LLVMGetTypeKind(ty);
 
-        fn tys_str(names: type_names, outer: ~[TypeRef],
+        fn tys_str(names: type_names, outer: &[TypeRef],
                    tys: ~[TypeRef]) -> @str {
             let mut s = ~"";
             let mut first: bool = true;

src/librustc/metadata/common.rs

@@ -133,7 +133,8 @@ pub enum astencode_tag { // Reserves 0x50 -- 0x6f
     tag_table_vtable_map = 0x61,
     tag_table_adjustments = 0x62,
     tag_table_legacy_boxed_trait = 0x63,
-    tag_table_value_mode = 0x64
+    tag_table_moves_map = 0x64,
+    tag_table_capture_map = 0x65
 }
 
 pub const tag_item_trait_method_sort: uint = 0x70;

src/librustc/metadata/creader.rs

@@ -163,8 +163,8 @@ fn visit_item(e: env, i: @ast::item) {
                 None => /*bad*/copy *e.intr.get(i.ident)
             };
             if attr::find_attrs_by_name(i.attrs, ~"nolink").is_empty() {
-                already_added = !cstore::add_used_library(cstore,
-                                                          foreign_name);
+                already_added =
+                    !cstore::add_used_library(cstore, copy foreign_name);
             }
             if !link_args.is_empty() && already_added {
                 e.diag.span_fatal(i.span, ~"library '" + foreign_name +
@@ -281,7 +281,8 @@ fn resolve_crate_deps(e: env, cdata: @~[u8]) -> cstore::cnum_map {
         let cmetas = metas_with(/*bad*/copy dep.vers, ~"vers", ~[]);
         debug!("resolving dep crate %s ver: %s hash: %s",
                *e.intr.get(dep.name), dep.vers, dep.hash);
-        match existing_match(e, metas_with_ident(*e.intr.get(cname), cmetas),
+        match existing_match(e, metas_with_ident(copy *e.intr.get(cname),
+                                                 copy cmetas),
                              dep.hash) {
           Some(local_cnum) => {
             debug!("already have it");

src/librustc/metadata/encoder.rs

@@ -648,14 +648,22 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: writer::Encoder,
         /* Encode the dtor */
         do struct_def.dtor.iter |dtor| {
             index.push({val: dtor.node.id, pos: ebml_w.writer.tell()});
-          encode_info_for_ctor(ecx, ebml_w, dtor.node.id,
+          encode_info_for_ctor(ecx,
+                               ebml_w,
+                               dtor.node.id,
                                ecx.tcx.sess.ident_of(
                                    ecx.tcx.sess.str_of(item.ident) +
                                    ~"_dtor"),
-                               path, if tps.len() > 0u {
-                                   Some(ii_dtor(*dtor, item.ident, tps,
+                               path,
+                               if tps.len() > 0u {
+                                   Some(ii_dtor(copy *dtor,
+                                                item.ident,
+                                                copy tps,
                                                 local_def(item.id))) }
-                               else { None }, tps);
+                               else {
+                                   None
+                               },
+                               tps);
         }
 
         /* Index the class*/
@@ -869,27 +877,35 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: writer::Encoder,
                         syntax::parse::token::special_idents::invalid);
     visit::visit_crate(*crate, (), visit::mk_vt(@visit::Visitor {
         visit_expr: |_e, _cx, _v| { },
-        visit_item: |i, cx, v, copy ebml_w| {
-            visit::visit_item(i, cx, v);
-            match ecx.tcx.items.get(i.id) {
-              ast_map::node_item(_, pt) => {
-                encode_info_for_item(ecx, ebml_w, i, index, *pt);
-              }
-              _ => fail ~"bad item"
+        visit_item: {
+            let ebml_w = copy ebml_w;
+            |i, cx, v| {
+                visit::visit_item(i, cx, v);
+                match ecx.tcx.items.get(i.id) {
+                    ast_map::node_item(_, pt) => {
+                        encode_info_for_item(ecx, ebml_w, i,
+                                             index, *pt);
+                    }
+                    _ => fail ~"bad item"
+                }
             }
         },
-        visit_foreign_item: |ni, cx, v, copy ebml_w| {
-            visit::visit_foreign_item(ni, cx, v);
-            match ecx.tcx.items.get(ni.id) {
-              ast_map::node_foreign_item(_, abi, pt) => {
-                encode_info_for_foreign_item(ecx, ebml_w, ni,
-                                             index, /*bad*/copy *pt, abi);
-              }
-              // case for separate item and foreign-item tables
-              _ => fail ~"bad foreign item"
+        visit_foreign_item: {
+            let ebml_w = copy ebml_w;
+            |ni, cx, v| {
+                visit::visit_foreign_item(ni, cx, v);
+                match ecx.tcx.items.get(ni.id) {
+                    ast_map::node_foreign_item(_, abi, pt) => {
+                        encode_info_for_foreign_item(ecx, ebml_w, ni,
+                                                     index, /*bad*/copy *pt,
+                                                     abi);
+                    }
+                    // case for separate item and foreign-item tables
+                    _ => fail ~"bad foreign item"
+                }
             }
-        }
-        ,.. *visit::default_visitor()
+        },
+        ..*visit::default_visitor()
     }));
     ebml_w.end_tag();
     return /*bad*/copy *index;

src/librustc/metadata/loader.rs

@@ -165,7 +165,8 @@ pub fn note_linkage_attrs(intr: @ident_interner, diag: span_handler,
     }
 }
 
-fn crate_matches(crate_data: @~[u8], +metas: ~[@ast::meta_item],
+fn crate_matches(crate_data: @~[u8],
+                 metas: &[@ast::meta_item],
                  hash: ~str) -> bool {
     let attrs = decoder::get_crate_attributes(crate_data);
     let linkage_metas = attr::find_linkage_metas(attrs);
@@ -177,7 +178,7 @@ fn crate_matches(crate_data: @~[u8], +metas: ~[@ast::meta_item],
 }
 
 pub fn metadata_matches(extern_metas: ~[@ast::meta_item],
-                        local_metas: ~[@ast::meta_item]) -> bool {
+                        local_metas: &[@ast::meta_item]) -> bool {
 
     debug!("matching %u metadata requirements against %u items",
            vec::len(local_metas), vec::len(extern_metas));

src/librustc/metadata/tydecode.rs

@@ -275,6 +275,7 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
       }
       'p' => {
         let did = parse_def(st, TypeParameter, conv);
+        debug!("parsed ty_param: did=%?", did);
         return ty::mk_param(st.tcx, parse_int(st) as uint, did);
       }
       's' => {
@@ -422,7 +423,6 @@ fn parse_arg(st: @pstate, conv: conv_did) -> ty::arg {
 
 fn parse_mode(st: @pstate) -> ast::mode {
     let m = ast::expl(match next(st) {
-        '-' => ast::by_move,
         '+' => ast::by_copy,
         '=' => ast::by_ref,
         '#' => ast::by_val,

src/librustc/metadata/tyencode.rs

@@ -342,7 +342,6 @@ pub fn enc_arg(w: io::Writer, cx: @ctxt, arg: ty::arg) {
 
 pub fn enc_mode(w: io::Writer, cx: @ctxt, m: mode) {
     match ty::resolved_mode(cx.tcx, m) {
-      by_move => w.write_char('-'),
       by_copy => w.write_char('+'),
       by_ref => w.write_char('='),
       by_val => w.write_char('#')