---

yaml
---
r: 105047
b: refs/heads/snap-stage3
c: aa75194
h: refs/heads/master
i:
  105045: 88db9cf
  105043: 981a8af
  105039: 2337d62
v: v3

Author: flaper87

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 0e6f90eb89021342935de9af2f014fbee5805855
+refs/heads/snap-stage3: aa7519400e15ae92687cea17b8264ad32f5f5faf
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/tutorial.md

@@ -1395,7 +1395,7 @@ let mut y = ~5; // mutable
 In contrast with
 owned boxes, where the holder of an owned box is the owner of the pointed-to
 memory, references never imply ownership - they are "borrowed".
-You can borrow a reference to
+A reference can be borrowed to
 any object, and the compiler verifies that it cannot outlive the lifetime of
 the object.
 

branches/snap-stage3/src/libarena/lib.rs

@@ -54,11 +54,11 @@ struct Chunk {
 }
 impl Chunk {
     fn capacity(&self) -> uint {
-        self.data.borrow().capacity()
+        self.data.deref().borrow().get().capacity()
     }
 
     unsafe fn as_ptr(&self) -> *u8 {
-        self.data.borrow().as_ptr()
+        self.data.deref().borrow().get().as_ptr()
     }
 }
 

branches/snap-stage3/src/librustc/back/archive.rs

@@ -206,8 +206,12 @@ impl<'a> Archive<'a> {
 
         let mut rustpath = filesearch::rust_path();
         rustpath.push(self.sess.filesearch().get_target_lib_path());
-        let search = self.sess.opts.addl_lib_search_paths.borrow();
-        for path in search.iter().chain(rustpath.iter()) {
+        let addl_lib_search_paths = self.sess
+                                        .opts
+                                        .addl_lib_search_paths
+                                        .borrow();
+        let path = addl_lib_search_paths.get().iter();
+        for path in path.chain(rustpath.iter()) {
             debug!("looking for {} inside {}", name, path.display());
             let test = path.join(oslibname.as_slice());
             if test.exists() { return test }

branches/snap-stage3/src/librustc/back/link.rs

@@ -209,8 +209,9 @@ pub mod write {
             // Emit the bytecode if we're either saving our temporaries or
             // emitting an rlib. Whenever an rlib is created, the bytecode is
             // inserted into the archive in order to allow LTO against it.
+            let crate_types = sess.crate_types.borrow();
             if sess.opts.cg.save_temps ||
-               (sess.crate_types.borrow().contains(&session::CrateTypeRlib) &&
+               (crate_types.get().contains(&session::CrateTypeRlib) &&
                 sess.opts.output_types.contains(&OutputTypeExe)) {
                 output.temp_path(OutputTypeBitcode).with_c_str(|buf| {
                     llvm::LLVMWriteBitcodeToFile(llmod, buf);
@@ -549,14 +550,15 @@ fn symbol_hash(tcx: &ty::ctxt, symbol_hasher: &mut Sha256,
 }
 
 fn get_symbol_hash(ccx: &CrateContext, t: ty::t) -> ~str {
-    match ccx.type_hashcodes.borrow().find(&t) {
+    match ccx.type_hashcodes.borrow().get().find(&t) {
         Some(h) => return h.to_str(),
         None => {}
     }
 
+    let mut type_hashcodes = ccx.type_hashcodes.borrow_mut();
     let mut symbol_hasher = ccx.symbol_hasher.borrow_mut();
-    let hash = symbol_hash(ccx.tcx(), &mut *symbol_hasher, t, &ccx.link_meta);
-    ccx.type_hashcodes.borrow_mut().insert(t, hash.clone());
+    let hash = symbol_hash(ccx.tcx(), symbol_hasher.get(), t, &ccx.link_meta);
+    type_hashcodes.get().insert(t, hash.clone());
     hash
 }
 
@@ -777,7 +779,8 @@ pub fn link_binary(sess: &Session,
                    outputs: &OutputFilenames,
                    id: &CrateId) -> Vec<Path> {
     let mut out_filenames = Vec::new();
-    for &crate_type in sess.crate_types.borrow().iter() {
+    let crate_types = sess.crate_types.borrow();
+    for &crate_type in crate_types.get().iter() {
         let out_file = link_binary_output(sess, trans, crate_type, outputs, id);
         out_filenames.push(out_file);
     }
@@ -884,7 +887,9 @@ fn link_rlib<'a>(sess: &'a Session,
                  out_filename: &Path) -> Archive<'a> {
     let mut a = Archive::create(sess, out_filename, obj_filename);
 
-    for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() {
+    let used_libraries = sess.cstore.get_used_libraries();
+    let used_libraries = used_libraries.borrow();
+    for &(ref l, kind) in used_libraries.get().iter() {
         match kind {
             cstore::NativeStatic => {
                 a.add_native_library(l.as_slice()).unwrap();
@@ -1222,7 +1227,9 @@ fn link_args(sess: &Session,
     // Finally add all the linker arguments provided on the command line along
     // with any #[link_args] attributes found inside the crate
     args.push_all(sess.opts.cg.link_args.as_slice());
-    for arg in sess.cstore.get_used_link_args().borrow().iter() {
+    let used_link_args = sess.cstore.get_used_link_args();
+    let used_link_args = used_link_args.borrow();
+    for arg in used_link_args.get().iter() {
         args.push(arg.clone());
     }
     return args;
@@ -1240,7 +1247,8 @@ fn link_args(sess: &Session,
 // in the current crate. Upstream crates with native library dependencies
 // may have their native library pulled in above.
 fn add_local_native_libraries(args: &mut Vec<~str>, sess: &Session) {
-    for path in sess.opts.addl_lib_search_paths.borrow().iter() {
+    let addl_lib_search_paths = sess.opts.addl_lib_search_paths.borrow();
+    for path in addl_lib_search_paths.get().iter() {
         // FIXME (#9639): This needs to handle non-utf8 paths
         args.push("-L" + path.as_str().unwrap().to_owned());
     }
@@ -1251,7 +1259,9 @@ fn add_local_native_libraries(args: &mut Vec<~str>, sess: &Session) {
         args.push("-L" + path.as_str().unwrap().to_owned());
     }
 
-    for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() {
+    let used_libraries = sess.cstore.get_used_libraries();
+    let used_libraries = used_libraries.borrow();
+    for &(ref l, kind) in used_libraries.get().iter() {
         match kind {
             cstore::NativeUnknown | cstore::NativeStatic => {
                 args.push("-l" + *l);

branches/snap-stage3/src/librustc/back/lto.rs

@@ -27,7 +27,8 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
     }
 
     // Make sure we actually can run LTO
-    for crate_type in sess.crate_types.borrow().iter() {
+    let crate_types = sess.crate_types.borrow();
+    for crate_type in crate_types.get().iter() {
         match *crate_type {
             session::CrateTypeExecutable | session::CrateTypeStaticlib => {}
             _ => {

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -512,7 +512,8 @@ fn write_out_deps(sess: &Session,
         let file = outputs.path(*output_type);
         match *output_type {
             link::OutputTypeExe => {
-                for output in sess.crate_types.borrow().iter() {
+                let crate_types = sess.crate_types.borrow();
+                for output in crate_types.get().iter() {
                     let p = link::filename_for_input(sess, *output, &id, &file);
                     out_filenames.push(p);
                 }
@@ -541,10 +542,10 @@ fn write_out_deps(sess: &Session,
 
     // Build a list of files used to compile the output and
     // write Makefile-compatible dependency rules
-    let files: Vec<~str> = sess.codemap().files.borrow()
+    let files: Vec<~str> = sess.codemap().files.borrow().get()
                                .iter().filter_map(|fmap| {
-                                    if fmap.is_real_file() {
-                                        Some(fmap.name.clone())
+                                    if fmap.deref().is_real_file() {
+                                        Some(fmap.deref().name.clone())
                                     } else {
                                         None
                                     }
@@ -682,7 +683,7 @@ pub fn pretty_print_input(sess: Session,
     };
 
     let src_name = source_name(input);
-    let src = sess.codemap().get_filemap(src_name).src.as_bytes().to_owned();
+    let src = sess.codemap().get_filemap(src_name).deref().src.as_bytes().to_owned();
     let mut rdr = MemReader::new(src);
 
     match ppm {

branches/snap-stage3/src/librustc/driver/session.rs

@@ -253,11 +253,11 @@ impl Session {
                     sp: Span,
                     msg: ~str) {
         let mut lints = self.lints.borrow_mut();
-        match lints.find_mut(&id) {
+        match lints.get().find_mut(&id) {
             Some(arr) => { arr.push((lint, sp, msg)); return; }
             None => {}
         }
-        lints.insert(id, vec!((lint, sp, msg)));
+        lints.get().insert(id, vec!((lint, sp, msg)));
     }
     pub fn next_node_id(&self) -> ast::NodeId {
         self.reserve_node_ids(1)

branches/snap-stage3/src/librustc/front/test.rs

@@ -88,7 +88,10 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
     }
 
     fn fold_item(&mut self, i: @ast::Item) -> SmallVector<@ast::Item> {
-        self.cx.path.borrow_mut().push(i.ident);
+        {
+            let mut path = self.cx.path.borrow_mut();
+            path.get().push(i.ident);
+        }
         debug!("current path: {}",
                ast_util::path_name_i(self.cx.path.get().as_slice()));
 
@@ -109,15 +112,21 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
                         ignore: is_ignored(&self.cx, i),
                         should_fail: should_fail(i)
                     };
-                    self.cx.testfns.borrow_mut().push(test);
+                    {
+                        let mut testfns = self.cx.testfns.borrow_mut();
+                        testfns.get().push(test);
+                    }
                     // debug!("have {} test/bench functions",
                     //        cx.testfns.len());
                 }
             }
         }
 
         let res = fold::noop_fold_item(i, self);
-        self.cx.path.borrow_mut().pop();
+        {
+            let mut path = self.cx.path.borrow_mut();
+            path.get().pop();
+        }
         res
     }
 
@@ -405,9 +414,12 @@ fn is_test_crate(krate: &ast::Crate) -> bool {
 
 fn mk_test_descs(cx: &TestCtxt) -> @ast::Expr {
     let mut descs = Vec::new();
-    debug!("building test vector from {} tests", cx.testfns.borrow().len());
-    for test in cx.testfns.borrow().iter() {
-        descs.push(mk_test_desc_and_fn_rec(cx, test));
+    {
+        let testfns = cx.testfns.borrow();
+        debug!("building test vector from {} tests", testfns.get().len());
+        for test in testfns.get().iter() {
+            descs.push(mk_test_desc_and_fn_rec(cx, test));
+        }
     }
 
     let inner_expr = @ast::Expr {

branches/snap-stage3/src/librustc/lib/llvm.rs

@@ -1831,11 +1831,13 @@ impl TypeNames {
     }
 
     pub fn associate_type(&self, s: &str, t: &Type) {
-        assert!(self.named_types.borrow_mut().insert(s.to_owned(), t.to_ref()));
+        let mut named_types = self.named_types.borrow_mut();
+        assert!(named_types.get().insert(s.to_owned(), t.to_ref()));
     }
 
     pub fn find_type(&self, s: &str) -> Option<Type> {
-        self.named_types.borrow().find_equiv(&s).map(|x| Type::from_ref(*x))
+        let named_types = self.named_types.borrow();
+        named_types.get().find_equiv(&s).map(|x| Type::from_ref(*x))
     }
 
     pub fn type_to_str(&self, ty: Type) -> ~str {

branches/snap-stage3/src/librustc/metadata/creader.rs

@@ -51,10 +51,11 @@ pub fn read_crates(sess: &Session,
     };
     visit_crate(&e, krate);
     visit::walk_crate(&mut e, krate, ());
-    dump_crates(e.crate_cache.borrow().as_slice());
+    let crate_cache = e.crate_cache.borrow();
+    dump_crates(crate_cache.get().as_slice());
     warn_if_multiple_versions(&mut e,
                               sess.diagnostic(),
-                              e.crate_cache.borrow().as_slice());
+                              crate_cache.get().as_slice());
 }
 
 impl<'a> visit::Visitor<()> for Env<'a> {
@@ -267,7 +268,8 @@ fn visit_item(e: &Env, i: &ast::Item) {
 
 fn existing_match(e: &Env, crate_id: &CrateId,
                   hash: Option<&Svh>) -> Option<ast::CrateNum> {
-    for c in e.crate_cache.borrow().iter() {
+    let crate_cache = e.crate_cache.borrow();
+    for c in crate_cache.get().iter() {
         if !crate_id.matches(&c.crate_id) { continue }
         match hash {
             Some(hash) if *hash != c.hash => {}
@@ -307,12 +309,15 @@ fn resolve_crate(e: &mut Env,
 
             // Claim this crate number and cache it
             let cnum = e.next_crate_num;
-            e.crate_cache.borrow_mut().push(cache_entry {
-                cnum: cnum,
-                span: span,
-                hash: hash,
-                crate_id: crate_id,
-            });
+            {
+                let mut crate_cache = e.crate_cache.borrow_mut();
+                crate_cache.get().push(cache_entry {
+                    cnum: cnum,
+                    span: span,
+                    hash: hash,
+                    crate_id: crate_id,
+                });
+            }
             e.next_crate_num += 1;
 
             // Maintain a reference to the top most crate.