---

yaml
---
r: 42851
b: refs/heads/try
c: 0682ad0
h: refs/heads/master
i:
  42849: 87a941f
  42847: 0f3aa37
v: v3

Author: nikomatsakis

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: 72454f401e3547468819f4dfb67d23f4056aefe1
+refs/heads/try: 0682ad0eb9a6b268498a81b2e16a40544e44f0fa
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/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 }

branches/try/doc/tutorial-borrowed-ptr.md

@@ -50,7 +50,7 @@ Suppose we wanted to write a procedure that computed the distance between any
 two points, no matter where they were stored. For example, we might like to
 compute the distance between `on_the_stack` and `shared_box`, or between
 `shared_box` and `unique_box`. One option is to define a function that takes
-two arguments of type `Point`—that is, it takes the points by value. But if we
+two arguments of type `Point`—that is, it takes the points by value. But we
 define it this way, calling the function will cause the points to be
 copied. For points, this is probably not so bad, but often copies are
 expensive. Worse, if the data type contains mutable fields, copying can change

branches/try/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 {

branches/try/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")

branches/try/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);
 }
 

branches/try/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) };

branches/try/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;

branches/try/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, ());
         }

branches/try/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));

branches/try/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;

branches/try/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
     };
 

branches/try/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;

branches/try/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;

branches/try/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");

branches/try/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;

branches/try/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));