eagerly-bind references to pass into by-value closures.

Author: pcwalton

src/librustc/back/link.rs

@@ -411,10 +411,12 @@ pub mod write {
         let mut llvm_c_strs = Vec::new();
         let mut llvm_args = Vec::new();
         {
+            let llvm_args_ptr = &mut llvm_args;
+            let llvm_c_strs_ptr = &mut llvm_c_strs;
             let add = |arg: &str| {
                 let s = arg.to_c_str();
-                llvm_args.push(s.with_ref(|p| p));
-                llvm_c_strs.push(s);
+                llvm_args_ptr.push(s.with_ref(|p| p));
+                llvm_c_strs_ptr.push(s);
             };
             add("rustc"); // fake program name
             if vectorize_loop { add("-vectorize-loops"); }
@@ -649,7 +651,10 @@ pub fn sanitize(s: &str) -> String {
 
             _ => {
                 let mut tstr = String::new();
-                char::escape_unicode(c, |c| tstr.push_char(c));
+                {
+                    let tstr_ptr = &mut tstr;
+                    char::escape_unicode(c, |c| tstr_ptr.push_char(c));
+                }
                 result.push_char('$');
                 result.push_str(tstr.as_slice().slice_from(1));
             }
@@ -976,8 +981,9 @@ fn link_rlib<'a>(sess: &'a Session,
             // into the archive.
             let bc = obj_filename.with_extension("bc");
             let bc_deflated = obj_filename.with_extension("bc.deflate");
+            let bc_deflated_ptr = &bc_deflated;
             match fs::File::open(&bc).read_to_end().and_then(|data| {
-                fs::File::create(&bc_deflated)
+                fs::File::create(bc_deflated_ptr)
                     .write(match flate::deflate_bytes(data.as_slice()) {
                         Some(compressed) => compressed,
                         None => sess.fatal("failed to compress bytecode")
@@ -991,8 +997,8 @@ fn link_rlib<'a>(sess: &'a Session,
                     sess.abort_if_errors()
                 }
             }
-            a.add_file(&bc_deflated, false);
-            remove(sess, &bc_deflated);
+            a.add_file(bc_deflated_ptr, false);
+            remove(sess, bc_deflated_ptr);
             if !sess.opts.cg.save_temps &&
                !sess.opts.output_types.contains(&OutputTypeBitcode) {
                 remove(sess, &bc);

src/librustc/driver/config.rs

@@ -403,9 +403,13 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
 
 pub fn append_configuration(cfg: &mut ast::CrateConfig,
                             name: InternedString) {
-    if !cfg.iter().any(|mi| mi.name() == name) {
-        cfg.push(attr::mk_word_item(name))
+    {
+        let name_ptr = &name;
+        if cfg.iter().any(|mi| mi.name() == *name_ptr) {
+            return
+        }
     }
+    cfg.push(attr::mk_word_item(name))
 }
 
 pub fn build_configuration(sess: &Session) -> ast::CrateConfig {

src/librustc/driver/driver.rs

@@ -553,14 +553,15 @@ fn write_out_deps(sess: &Session,
         _ => return,
     };
 
+    let deps_filename_ptr = &deps_filename;
     let result = (|| {
         // Build a list of files used to compile the output and
         // write Makefile-compatible dependency rules
         let files: Vec<String> = sess.codemap().files.borrow()
                                    .iter().filter(|fmap| fmap.is_real_file())
                                    .map(|fmap| fmap.name.to_string())
                                    .collect();
-        let mut file = try!(io::File::create(&deps_filename));
+        let mut file = try!(io::File::create(deps_filename_ptr));
         for path in out_filenames.iter() {
             try!(write!(&mut file as &mut Writer,
                           "{}: {}\n\n", path.display(), files.connect(" ")));
@@ -572,7 +573,7 @@ fn write_out_deps(sess: &Session,
         Ok(()) => {}
         Err(e) => {
             sess.fatal(format!("error writing dependencies to `{}`: {}",
-                               deps_filename.display(), e).as_slice());
+                               deps_filename_ptr.display(), e).as_slice());
         }
     }
 }
@@ -713,21 +714,28 @@ pub fn pretty_print_input(sess: Session,
         }
         PpmFlowGraph(nodeid) => {
             let ast_map = ast_map.expect("--pretty flowgraph missing ast_map");
-            let node = ast_map.find(nodeid).unwrap_or_else(|| {
-                sess.fatal(format_strbuf!("--pretty flowgraph couldn't find id: {}",
-                                          nodeid).as_slice())
-            });
-            let block = match node {
-                syntax::ast_map::NodeBlock(block) => block,
-                _ => {
-                    let message = format_strbuf!("--pretty=flowgraph needs block, got {:?}",
-                                                 node);
-
-                    // point to what was found, if there's an
-                    // accessible span.
-                    match ast_map.opt_span(nodeid) {
-                        Some(sp) => sess.span_fatal(sp, message.as_slice()),
-                        None => sess.fatal(message.as_slice())
+            let block = {
+                let sess_ptr = &sess;
+                let node = ast_map.find(nodeid).unwrap_or_else(|| {
+                    sess_ptr.fatal(format_strbuf!(
+                            "--pretty flowgraph couldn't find id: {}",
+                            nodeid).as_slice())
+                });
+                match node {
+                    syntax::ast_map::NodeBlock(block) => block,
+                    _ => {
+                        let message = format_strbuf!("--pretty=flowgraph \
+                                                      needs block, got {:?}",
+                                                     node);
+
+                        // point to what was found, if there's an
+                        // accessible span.
+                        match ast_map.opt_span(nodeid) {
+                            Some(sp) => {
+                                sess_ptr.span_fatal(sp, message.as_slice())
+                            }
+                            None => sess_ptr.fatal(message.as_slice())
+                        }
                     }
                 }
             };

src/librustc/driver/mod.rs

@@ -72,9 +72,12 @@ fn run_compiler(args: &[String]) {
     let odir = matches.opt_str("out-dir").map(|o| Path::new(o));
     let ofile = matches.opt_str("o").map(|o| Path::new(o));
 
-    let pretty = matches.opt_default("pretty", "normal").map(|a| {
-        parse_pretty(&sess, a.as_slice())
-    });
+    let pretty = {
+        let sess_ptr = &sess;
+        matches.opt_default("pretty", "normal").map(|a| {
+            parse_pretty(sess_ptr, a.as_slice())
+        })
+    };
     match pretty {
         Some::<PpMode>(ppm) => {
             driver::pretty_print_input(sess, cfg, &input, ppm, ofile);

src/librustc/metadata/creader.rs

@@ -82,11 +82,14 @@ fn dump_crates(cstore: &CStore) {
 
 fn warn_if_multiple_versions(diag: &SpanHandler, cstore: &CStore) {
     let mut map = HashMap::new();
-    cstore.iter_crate_data(|cnum, data| {
-        let crateid = data.crate_id();
-        let key = (crateid.name.clone(), crateid.path.clone());
-        map.find_or_insert_with(key, |_| Vec::new()).push(cnum);
-    });
+    {
+        let map_ptr = &mut map;
+        cstore.iter_crate_data(|cnum, data| {
+            let crateid = data.crate_id();
+            let key = (crateid.name.clone(), crateid.path.clone());
+            map_ptr.find_or_insert_with(key, |_| Vec::new()).push(cnum);
+        });
+    }
 
     for ((name, _), dupes) in map.move_iter() {
         if dupes.len() == 1 { continue }
@@ -265,16 +268,19 @@ fn visit_item(e: &Env, i: &ast::Item) {
 fn existing_match(e: &Env, crate_id: &CrateId,
                   hash: Option<&Svh>) -> Option<ast::CrateNum> {
     let mut ret = None;
-    e.sess.cstore.iter_crate_data(|cnum, data| {
-        let other_id = data.crate_id();
-        if crate_id.matches(&other_id) {
-            let other_hash = data.hash();
-            match hash {
-                Some(hash) if *hash != other_hash => {}
-                Some(..) | None => { ret = Some(cnum); }
+    {
+        let ret_ptr = &mut ret;
+        e.sess.cstore.iter_crate_data(|cnum, data| {
+            let other_id = data.crate_id();
+            if crate_id.matches(&other_id) {
+                let other_hash = data.hash();
+                match hash {
+                    Some(hash) if *hash != other_hash => {}
+                    Some(..) | None => *ret_ptr = Some(cnum),
+                }
             }
-        }
-    });
+        });
+    }
     return ret;
 }
 
@@ -441,9 +447,14 @@ impl<'a> CrateLoader for Loader<'a> {
             None => { load_ctxt.report_load_errs(); unreachable!() },
         };
         let macros = decoder::get_exported_macros(library.metadata.as_slice());
-        let registrar = decoder::get_macro_registrar_fn(library.metadata.as_slice()).map(|id| {
-            decoder::get_symbol(library.metadata.as_slice(), id).to_string()
-        });
+        let registrar = {
+            let library_ptr = &library;
+            decoder::get_macro_registrar_fn(library.metadata.as_slice())
+                    .map(|id| {
+                decoder::get_symbol(library_ptr.metadata.as_slice(),
+                                    id).to_string()
+            })
+        };
         let mc = MacroCrate {
             lib: library.dylib.clone(),
             macros: macros.move_iter().map(|x| x.to_string()).collect(),