---

yaml
---
r: 151223
b: refs/heads/try2
c: 0006671
h: refs/heads/master
i:
  151221: c860930
  151219: c0704aa
  151215: 914dfd5
v: v3

Author: justinnoah

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ee03529fa9c84471f0e24d749017ce88b7d2b81e
+refs/heads/try2: 000667158b7fc7f72e7ca6e8a43e9aaca834726f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -1197,7 +1197,7 @@ fn eq(xs: &List, ys: &List) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current element in both lists is equal, keep going.
+        // If the current elements of both lists are equal, keep going.
         (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1304,7 +1304,7 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current element in both lists is equal, keep going.
+        // If the current elements of both lists are equal, keep going.
         (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1333,7 +1333,7 @@ impl<T: Eq> Eq for List<T> {
         match (self, ys) {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
-            // If the current element in both lists is equal, keep going.
+            // If the current elements of both lists are equal, keep going.
             (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                     if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.

branches/try2/src/librustc/back/rpath.rs

@@ -133,7 +133,7 @@ pub fn get_rpath_relative_to_output(os: abi::Os,
 }
 
 pub fn get_install_prefix_rpath(sysroot: &Path, target_triple: &str) -> ~str {
-    let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX");
+    let install_prefix = env!("CFG_PREFIX");
 
     let tlib = filesearch::relative_target_lib_path(sysroot, target_triple);
     let mut path = Path::new(install_prefix);
@@ -171,7 +171,7 @@ mod test {
     fn test_prefix_rpath() {
         let sysroot = filesearch::get_or_default_sysroot();
         let res = get_install_prefix_rpath(&sysroot, "triple");
-        let mut d = Path::new((option_env!("CFG_PREFIX")).expect("CFG_PREFIX"));
+        let mut d = Path::new(env!("CFG_PREFIX"));
         d.push("lib");
         d.push(filesearch::rustlibdir());
         d.push("triple/lib");

branches/try2/src/librustc/driver/driver.rs

@@ -23,7 +23,7 @@ use metadata::{creader, filesearch};
 use metadata::cstore::CStore;
 use metadata::creader::Loader;
 use metadata;
-use middle::{trans, freevars, kind, ty, typeck, lint, reachable};
+use middle::{trans, freevars, kind, ty, typeck, lint, astencode, reachable};
 use middle;
 use util::common::time;
 use util::ppaux;
@@ -35,6 +35,7 @@ use std::cell::{Cell, RefCell};
 use std::io;
 use std::io::fs;
 use std::io::MemReader;
+use std::mem::drop;
 use std::os;
 use getopts::{optopt, optmulti, optflag, optflagopt};
 use getopts;
@@ -277,6 +278,7 @@ pub struct CrateAnalysis {
     pub exported_items: middle::privacy::ExportedItems,
     pub public_items: middle::privacy::PublicItems,
     pub ty_cx: ty::ctxt,
+    pub maps: astencode::Maps,
     pub reachable: NodeSet,
 }
 
@@ -352,14 +354,21 @@ pub fn phase_3_run_analysis_passes(sess: Session,
     time(time_passes, "effect checking", (), |_|
          middle::effect::check_crate(&ty_cx, krate));
 
+    let middle::moves::MoveMaps {moves_map, capture_map} =
+        time(time_passes, "compute moves", (), |_|
+             middle::moves::compute_moves(&ty_cx, krate));
+
     time(time_passes, "match checking", (), |_|
-         middle::check_match::check_crate(&ty_cx, krate));
+         middle::check_match::check_crate(&ty_cx, &moves_map, krate));
 
     time(time_passes, "liveness checking", (), |_|
-         middle::liveness::check_crate(&ty_cx, krate));
+         middle::liveness::check_crate(&ty_cx, &capture_map, krate));
 
     time(time_passes, "borrow checking", (), |_|
-         middle::borrowck::check_crate(&ty_cx, krate));
+         middle::borrowck::check_crate(&ty_cx, &moves_map,
+                                       &capture_map, krate));
+
+    drop(moves_map);
 
     time(time_passes, "kind checking", (), |_|
          kind::check_crate(&ty_cx, krate));
@@ -383,6 +392,9 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         ty_cx: ty_cx,
         exported_items: exported_items,
         public_items: public_items,
+        maps: astencode::Maps {
+            capture_map: RefCell::new(capture_map)
+        },
         reachable: reachable_map
     }
 }
@@ -798,8 +810,7 @@ pub fn host_triple() -> &'static str {
     // Instead of grabbing the host triple (for the current host), we grab (at
     // compile time) the target triple that this rustc is built with and
     // calling that (at runtime) the host triple.
-    (option_env!("CFG_COMPILER_HOST_TRIPLE")).
-        expect("CFG_COMPILER_HOST_TRIPLE")
+    env!("CFG_COMPILER_HOST_TRIPLE")
 }
 
 pub fn build_session_options(matches: &getopts::Matches) -> session::Options {

branches/try2/src/librustc/lib.rs

@@ -86,13 +86,13 @@ pub mod middle {
     pub mod astencode;
     pub mod lang_items;
     pub mod privacy;
+    pub mod moves;
     pub mod entry;
     pub mod effect;
     pub mod reachable;
     pub mod graph;
     pub mod cfg;
     pub mod dead;
-    pub mod expr_use_visitor;
 }
 
 pub mod front {

branches/try2/src/librustc/metadata/decoder.rs

@@ -610,7 +610,7 @@ fn each_child_of_item_or_crate(intr: Rc<IdentInterner>,
                 // Hand off the item to the callback.
                 let def_like = item_to_def_like(child_item_doc,
                                                 child_def_id,
-                                                child_def_id.krate);
+                                                cdata.cnum);
                 // These items have a public visibility because they're part of
                 // a public re-export.
                 callback(def_like, token::str_to_ident(name), ast::Public);

branches/try2/src/librustc/middle/astencode.rs

@@ -24,7 +24,8 @@ use metadata::tydecode::{DefIdSource, NominalType, TypeWithId, TypeParameter,
                          RegionParameter};
 use metadata::tyencode;
 use middle::typeck::{MethodCall, MethodCallee, MethodOrigin};
-use middle::{ty, typeck};
+use middle::{ty, typeck, moves};
+use middle;
 use util::ppaux::ty_to_str;
 
 use syntax::{ast, ast_map, ast_util, codemap, fold};
@@ -35,6 +36,7 @@ use syntax;
 
 use libc;
 use std::cast;
+use std::cell::RefCell;
 use std::io::Seek;
 use std::io::MemWriter;
 use std::rc::Rc;
@@ -50,9 +52,15 @@ use writer = serialize::ebml::writer;
 #[cfg(test)] use syntax::parse;
 #[cfg(test)] use syntax::print::pprust;
 
+// Auxiliary maps of things to be encoded
+pub struct Maps {
+    pub capture_map: RefCell<middle::moves::CaptureMap>,
+}
+
 struct DecodeContext<'a> {
     cdata: &'a cstore::crate_metadata,
     tcx: &'a ty::ctxt,
+    maps: &'a Maps
 }
 
 struct ExtendedDecodeContext<'a> {
@@ -76,7 +84,8 @@ pub type Encoder<'a> = writer::Encoder<'a, MemWriter>;
 
 pub fn encode_inlined_item(ecx: &e::EncodeContext,
                            ebml_w: &mut Encoder,
-                           ii: e::InlinedItemRef) {
+                           ii: e::InlinedItemRef,
+                           maps: &Maps) {
     let id = match ii {
         e::IIItemRef(i) => i.id,
         e::IIForeignRef(i) => i.id,
@@ -92,7 +101,7 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext,
     ebml_w.start_tag(c::tag_ast as uint);
     id_range.encode(ebml_w);
     encode_ast(ebml_w, ii);
-    encode_side_tables_for_ii(ecx, ebml_w, &ii);
+    encode_side_tables_for_ii(ecx, maps, ebml_w, &ii);
     ebml_w.end_tag();
 
     debug!("< Encoded inlined fn: {} ({})",
@@ -102,12 +111,14 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext,
 
 pub fn decode_inlined_item(cdata: &cstore::crate_metadata,
                            tcx: &ty::ctxt,
+                           maps: &Maps,
                            path: Vec<ast_map::PathElem>,
                            par_doc: ebml::Doc)
                            -> Result<ast::InlinedItem, Vec<ast_map::PathElem>> {
     let dcx = &DecodeContext {
         cdata: cdata,
         tcx: tcx,
+        maps: maps
     };
     match par_doc.opt_child(c::tag_ast) {
       None => Err(path),
@@ -540,6 +551,32 @@ impl tr for freevar_entry {
     }
 }
 
+// ______________________________________________________________________
+// Encoding and decoding of CaptureVar information
+
+trait capture_var_helper {
+    fn read_capture_var(&mut self, xcx: &ExtendedDecodeContext)
+                        -> moves::CaptureVar;
+}
+
+impl<'a> capture_var_helper for reader::Decoder<'a> {
+    fn read_capture_var(&mut self, xcx: &ExtendedDecodeContext)
+                        -> moves::CaptureVar {
+        let cvar: moves::CaptureVar = Decodable::decode(self).unwrap();
+        cvar.tr(xcx)
+    }
+}
+
+impl tr for moves::CaptureVar {
+    fn tr(&self, xcx: &ExtendedDecodeContext) -> moves::CaptureVar {
+        moves::CaptureVar {
+            def: self.def.tr(xcx),
+            span: self.span.tr(xcx),
+            mode: self.mode
+        }
+    }
+}
+
 // ______________________________________________________________________
 // Encoding and decoding of MethodCallee
 
@@ -898,6 +935,7 @@ impl<'a> write_tag_and_id for Encoder<'a> {
 struct SideTableEncodingIdVisitor<'a,'b> {
     ecx_ptr: *libc::c_void,
     new_ebml_w: &'a mut Encoder<'b>,
+    maps: &'a Maps,
 }
 
 impl<'a,'b> ast_util::IdVisitingOperation for
@@ -915,11 +953,12 @@ impl<'a,'b> ast_util::IdVisitingOperation for
         let ecx: &e::EncodeContext = unsafe {
             cast::transmute(self.ecx_ptr)
         };
-        encode_side_tables_for_id(ecx, &mut new_ebml_w, id)
+        encode_side_tables_for_id(ecx, self.maps, &mut new_ebml_w, id)
     }
 }
 
 fn encode_side_tables_for_ii(ecx: &e::EncodeContext,
+                             maps: &Maps,
                              ebml_w: &mut Encoder,
                              ii: &ast::InlinedItem) {
     ebml_w.start_tag(c::tag_table as uint);
@@ -935,11 +974,13 @@ fn encode_side_tables_for_ii(ecx: &e::EncodeContext,
             cast::transmute(ecx)
         },
         new_ebml_w: &mut new_ebml_w,
+        maps: maps,
     });
     ebml_w.end_tag();
 }
 
 fn encode_side_tables_for_id(ecx: &e::EncodeContext,
+                             maps: &Maps,
                              ebml_w: &mut Encoder,
                              id: ast::NodeId) {
     let tcx = ecx.tcx;
@@ -1055,6 +1096,17 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             })
         })
     }
+
+    for &cap_vars in maps.capture_map.borrow().find(&id).iter() {
+        ebml_w.tag(c::tag_table_capture_map, |ebml_w| {
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val, |ebml_w| {
+                ebml_w.emit_from_vec(cap_vars.as_slice(), |ebml_w, cap_var| {
+                    cap_var.encode(ebml_w)
+                });
+            })
+        })
+    }
 }
 
 trait doc_decoder_helpers {
@@ -1353,6 +1405,15 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext,
                         let adj: ty::AutoAdjustment = val_dsr.read_auto_adjustment(xcx);
                         dcx.tcx.adjustments.borrow_mut().insert(id, adj);
                     }
+                    c::tag_table_capture_map => {
+                        let cvars =
+                                val_dsr.read_to_vec(
+                                            |val_dsr| Ok(val_dsr.read_capture_var(xcx)))
+                                       .unwrap()
+                                       .move_iter()
+                                       .collect();
+                        dcx.maps.capture_map.borrow_mut().insert(id, Rc::new(cvars));
+                    }
                     _ => {
                         xcx.dcx.tcx.sess.bug(
                             format!("unknown tag found in side tables: {:x}", tag));