---

yaml
---
r: 112887
b: refs/heads/auto
c: fa6efed
h: refs/heads/master
i:
  112885: 982e384
  112883: 396ba15
  112879: ab28b9c
v: v3

Author: hjr3

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 239557de6de72748a5c7604081b202d53f7d9ac9
+refs/heads/auto: fa6efedccf63c283d7b0916c304ee456d20ab97e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

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

branches/auto/src/librustc/middle/borrowck/check_loans.rs

@@ -18,10 +18,9 @@
 // 4. moves do not affect things loaned out in any way
 
 
-use middle::borrowck::*;
-use euv = middle::expr_use_visitor;
-use middle::freevars;
 use mc = middle::mem_categorization;
+use middle::borrowck::*;
+use middle::moves;
 use middle::ty;
 use middle::typeck::MethodCall;
 use syntax::ast;
@@ -289,7 +288,7 @@ impl<'a> CheckLoanCtxt<'a> {
             }
 
             match new_loan.cause {
-                euv::ClosureCapture(span) => {
+                ClosureCapture(span) => {
                     self.bccx.span_note(
                         span,
                         format!("borrow occurs due to use of `{}` in closure",
@@ -322,17 +321,13 @@ impl<'a> CheckLoanCtxt<'a> {
             };
 
             let borrow_summary = match old_loan.cause {
-                euv::ClosureCapture(_) => {
+                ClosureCapture(_) => {
                     format!("previous borrow of `{}` occurs here due to \
                             use in closure",
                             self.bccx.loan_path_to_str(&*old_loan.loan_path))
                 }
 
-                euv::OverloadedOperator(..) |
-                euv::AddrOf(..) |
-                euv::AutoRef(..) |
-                euv::ClosureInvocation(..) |
-                euv::RefBinding(..) => {
+                AddrOf | AutoRef | RefBinding | ClosureInvocation => {
                     format!("previous borrow of `{}` occurs here",
                             self.bccx.loan_path_to_str(&*old_loan.loan_path))
                 }
@@ -716,33 +711,29 @@ impl<'a> CheckLoanCtxt<'a> {
     fn check_captured_variables(&self,
                                 closure_id: ast::NodeId,
                                 span: Span) {
-        let freevar_mode = freevars::get_capture_mode(self.tcx(), closure_id);
-        freevars::with_freevars(self.tcx(), closure_id, |freevars| {
-            for freevar in freevars.iter() {
-                let var_id = ast_util::def_id_of_def(freevar.def).node;
-                let var_path = Rc::new(LpVar(var_id));
-                self.check_if_path_is_moved(closure_id, span,
-                                            MovedInCapture, &var_path);
-                match freevar_mode {
-                    freevars::CaptureByRef => { }
-                    freevars::CaptureByValue => {
-                        check_by_move_capture(self, closure_id, freevar, &*var_path);
-                    }
+        for cap_var in self.bccx.capture_map.get(&closure_id).iter() {
+            let var_id = ast_util::def_id_of_def(cap_var.def).node;
+            self.check_if_path_is_moved(closure_id, span,
+                                        MovedInCapture, &Rc::new(LpVar(var_id)));
+            match cap_var.mode {
+                moves::CapRef | moves::CapCopy => {}
+                moves::CapMove => {
+                    check_by_move_capture(self, closure_id, cap_var, &LpVar(var_id));
                 }
             }
-        });
+        }
         return;
 
         fn check_by_move_capture(this: &CheckLoanCtxt,
                                  closure_id: ast::NodeId,
-                                 freevar: &freevars::freevar_entry,
+                                 cap_var: &moves::CaptureVar,
                                  move_path: &LoanPath) {
             let move_err = this.analyze_move_out_from(closure_id, move_path);
             match move_err {
                 MoveOk => {}
                 MoveWhileBorrowed(loan_path, loan_span) => {
                     this.bccx.span_err(
-                        freevar.span,
+                        cap_var.span,
                         format!("cannot move `{}` into closure \
                                 because it is borrowed",
                                 this.bccx.loan_path_to_str(move_path)));