---

yaml
---
r: 88945
b: refs/heads/snap-stage3
c: 2c3f926
h: refs/heads/master
i:
  88943: ca3d1fb
v: v3

Author: pcwalton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: deeca5d586bfaa4aa60246f671a8d611d38f6248
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b976226d52d0020c37b89e1dc837bc1efc0f27cc
+refs/heads/snap-stage3: 2c3f92699e1f01301739cb78e3dd567363231d2c
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -951,7 +951,8 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
 
     let lid = ast::DefId { crate: ast::LOCAL_CRATE, node: id };
     {
-        let r = tcx.tcache.find(&lid);
+        let tcache = tcx.tcache.borrow();
+        let r = tcache.get().find(&lid);
         for &tpbt in r.iter() {
             ebml_w.tag(c::tag_table_tcache, |ebml_w| {
                 ebml_w.id(id);
@@ -1247,7 +1248,8 @@ fn decode_side_tables(xcx: @ExtendedDecodeContext,
                     c::tag_table_tcache => {
                         let tpbt = val_dsr.read_ty_param_bounds_and_ty(xcx);
                         let lid = ast::DefId { crate: ast::LOCAL_CRATE, node: id };
-                        dcx.tcx.tcache.insert(lid, tpbt);
+                        let mut tcache = dcx.tcx.tcache.borrow_mut();
+                        tcache.get().insert(lid, tpbt);
                     }
                     c::tag_table_param_defs => {
                         let bounds = val_dsr.read_type_param_def(xcx);

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -953,7 +953,7 @@ pub struct ty_param_substs_and_ty {
     ty: ty::t
 }
 
-type type_cache = @mut HashMap<ast::DefId, ty_param_bounds_and_ty>;
+type type_cache = RefCell<HashMap<ast::DefId, ty_param_bounds_and_ty>>;
 
 pub type node_type_table = @mut HashMap<uint,t>;
 
@@ -986,7 +986,7 @@ pub fn mk_ctxt(s: session::Session,
         items: amap,
         intrinsic_defs: RefCell::new(HashMap::new()),
         freevars: freevars,
-        tcache: @mut HashMap::new(),
+        tcache: RefCell::new(HashMap::new()),
         rcache: mk_rcache(),
         short_names_cache: RefCell::new(HashMap::new()),
         needs_unwind_cleanup_cache: RefCell::new(HashMap::new()),
@@ -3975,8 +3975,9 @@ pub fn enum_variant_with_id(cx: ctxt,
 pub fn lookup_item_type(cx: ctxt,
                         did: ast::DefId)
                      -> ty_param_bounds_and_ty {
+    let mut tcache = cx.tcache.borrow_mut();
     lookup_locally_or_in_crate_store(
-        "tcache", did, cx.tcache,
+        "tcache", did, tcache.get(),
         || csearch::get_type(cx, did))
 }
 
@@ -4071,15 +4072,17 @@ pub fn lookup_field_type(tcx: ctxt,
                       -> ty::t {
     let t = if id.crate == ast::LOCAL_CRATE {
         node_id_to_type(tcx, id.node)
-    }
-    else {
-        match tcx.tcache.find(&id) {
-           Some(&ty_param_bounds_and_ty {ty, ..}) => ty,
-           None => {
-               let tpt = csearch::get_field_type(tcx, struct_id, id);
-               tcx.tcache.insert(id, tpt);
-               tpt.ty
-           }
+    } else {
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            match tcache.get().find(&id) {
+               Some(&ty_param_bounds_and_ty {ty, ..}) => ty,
+               None => {
+                   let tpt = csearch::get_field_type(tcx, struct_id, id);
+                   tcache.get().insert(id, tpt);
+                   tpt.ty
+               }
+            }
         }
     };
     subst(tcx, substs, t)

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -3446,7 +3446,10 @@ pub fn check_const(ccx: @mut CrateCtxt,
                    id: ast::NodeId) {
     let rty = ty::node_id_to_type(ccx.tcx, id);
     let fcx = blank_fn_ctxt(ccx, rty, e.id);
-    let declty = fcx.ccx.tcx.tcache.get(&local_def(id)).ty;
+    let declty = {
+        let tcache = fcx.ccx.tcx.tcache.borrow();
+        tcache.get().get(&local_def(id)).ty
+    };
     check_const_with_ty(fcx, sp, e, declty);
 }
 

branches/snap-stage3/src/librustc/middle/typeck/coherence.rs

@@ -366,7 +366,10 @@ impl CoherenceChecker {
             };
             debug!("new_polytype={}", new_polytype.repr(tcx));
 
-            tcx.tcache.insert(new_did, new_polytype);
+            {
+                let mut tcache = tcx.tcache.borrow_mut();
+                tcache.get().insert(new_did, new_polytype);
+            }
 
             let mut methods = tcx.methods.borrow_mut();
             methods.get().insert(new_did, new_method_ty);
@@ -528,7 +531,8 @@ impl CoherenceChecker {
 
     pub fn get_self_type_for_implementation(&self, implementation: @Impl)
                                             -> ty_param_bounds_and_ty {
-        return self.crate_context.tcx.tcache.get_copy(&implementation.did);
+        let tcache = self.crate_context.tcx.tcache.borrow();
+        return tcache.get().get_copy(&implementation.did);
     }
 
     // Privileged scope checking

branches/snap-stage3/src/librustc/middle/typeck/collect.rs

@@ -173,7 +173,12 @@ pub fn get_enum_variant_types(ccx: &CrateCtxt,
             generics: ty_generics(ccx, generics, 0),
             ty: result_ty
         };
-        tcx.tcache.insert(local_def(variant.node.id), tpt);
+
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(variant.node.id), tpt);
+        }
+
         write_ty_to_tcx(tcx, variant.node.id, result_ty);
     }
 }
@@ -350,7 +355,8 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
                ty.repr(tcx),
                substs.repr(tcx));
 
-        tcx.tcache.insert(m.def_id,
+        let mut tcache = tcx.tcache.borrow_mut();
+        tcache.get().insert(m.def_id,
                           ty_param_bounds_and_ty {
                               generics: ty::Generics {
                                   type_param_defs: @new_type_param_defs,
@@ -440,7 +446,8 @@ pub fn convert_field(ccx: &CrateCtxt,
     let tt = ccx.to_ty(&ExplicitRscope, v.node.ty);
     write_ty_to_tcx(ccx.tcx, v.node.id, tt);
     /* add the field to the tcache */
-    ccx.tcx.tcache.insert(local_def(v.node.id),
+    let mut tcache = ccx.tcx.tcache.borrow_mut();
+    tcache.get().insert(local_def(v.node.id),
                           ty::ty_param_bounds_and_ty {
                               generics: struct_generics.clone(),
                               ty: tt
@@ -470,20 +477,25 @@ fn convert_methods(ccx: &CrateCtxt,
                 m.ident.repr(ccx.tcx),
                 m.id,
                 fty.repr(ccx.tcx));
-        tcx.tcache.insert(
-            local_def(m.id),
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(
+                local_def(m.id),
+
+                // n.b.: the type of a method is parameterized by both
+                // the parameters on the receiver and those on the method
+                // itself
+                ty_param_bounds_and_ty {
+                    generics: ty::Generics {
+                        type_param_defs: @vec::append(
+                            (*rcvr_ty_generics.type_param_defs).clone(),
+                            *m_ty_generics.type_param_defs),
+                        region_param_defs: rcvr_ty_generics.region_param_defs,
+                    },
+                    ty: fty
+                });
+        }
 
-            // n.b.: the type of a method is parameterized by both
-            // the parameters on the receiver and those on the method itself
-            ty_param_bounds_and_ty {
-                generics: ty::Generics {
-                    type_param_defs: @vec::append(
-                        (*rcvr_ty_generics.type_param_defs).clone(),
-                        *m_ty_generics.type_param_defs),
-                    region_param_defs: rcvr_ty_generics.region_param_defs,
-                },
-                ty: fty
-            });
         write_ty_to_tcx(tcx, m.id, fty);
 
         let mut methods = tcx.methods.borrow_mut();
@@ -557,10 +569,14 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::item) {
         let i_ty_generics = ty_generics(ccx, generics, 0);
         let selfty = ccx.to_ty(&ExplicitRscope, selfty);
         write_ty_to_tcx(tcx, it.id, selfty);
-        tcx.tcache.insert(local_def(it.id),
-                          ty_param_bounds_and_ty {
-                              generics: i_ty_generics,
-                              ty: selfty});
+
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id),
+                              ty_param_bounds_and_ty {
+                                  generics: i_ty_generics,
+                                  ty: selfty});
+        }
 
         // If there is a trait reference, treat the methods as always public.
         // This is to work around some incorrect behavior in privacy checking:
@@ -618,7 +634,11 @@ pub fn convert(ccx: &CrateCtxt, it: &ast::item) {
         // Write the class type
         let tpt = ty_of_item(ccx, it);
         write_ty_to_tcx(tcx, it.id, tpt.ty);
-        tcx.tcache.insert(local_def(it.id), tpt);
+
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
+        }
 
         convert_struct(ccx, struct_def, tpt, it.id);
       }
@@ -658,19 +678,29 @@ pub fn convert_struct(ccx: &CrateCtxt,
             if struct_def.fields.len() == 0 {
                 // Enum-like.
                 write_ty_to_tcx(tcx, ctor_id, selfty);
-                tcx.tcache.insert(local_def(ctor_id), tpt);
+
+                {
+                    let mut tcache = tcx.tcache.borrow_mut();
+                    tcache.get().insert(local_def(ctor_id), tpt);
+                }
             } else if struct_def.fields[0].node.kind == ast::unnamed_field {
                 // Tuple-like.
-                let inputs =
+                let inputs = {
+                    let tcache = tcx.tcache.borrow();
                     struct_def.fields.map(
-                        |field| ccx.tcx.tcache.get(
-                            &local_def(field.node.id)).ty);
+                        |field| tcache.get().get(
+                            &local_def(field.node.id)).ty)
+                };
                 let ctor_fn_ty = ty::mk_ctor_fn(tcx, ctor_id, inputs, selfty);
                 write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty);
-                tcx.tcache.insert(local_def(ctor_id), ty_param_bounds_and_ty {
-                    generics: tpt.generics,
-                    ty: ctor_fn_ty
-                });
+                {
+                    let mut tcache = tcx.tcache.borrow_mut();
+                    tcache.get().insert(local_def(ctor_id),
+                                      ty_param_bounds_and_ty {
+                        generics: tpt.generics,
+                        ty: ctor_fn_ty
+                    });
+                }
             }
         }
     }
@@ -695,7 +725,9 @@ pub fn convert_foreign(ccx: &CrateCtxt, i: &ast::foreign_item) {
 
     let tpt = ty_of_foreign_item(ccx, i, abis);
     write_ty_to_tcx(ccx.tcx, i.id, tpt.ty);
-    ccx.tcx.tcache.insert(local_def(i.id), tpt);
+
+    let mut tcache = ccx.tcx.tcache.borrow_mut();
+    tcache.get().insert(local_def(i.id), tpt);
 }
 
 pub fn instantiate_trait_ref(ccx: &CrateCtxt,
@@ -781,15 +813,20 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
                   -> ty::ty_param_bounds_and_ty {
     let def_id = local_def(it.id);
     let tcx = ccx.tcx;
-    match tcx.tcache.find(&def_id) {
-        Some(&tpt) => return tpt,
-        _ => {}
+    {
+        let tcache = tcx.tcache.borrow();
+        match tcache.get().find(&def_id) {
+            Some(&tpt) => return tpt,
+            _ => {}
+        }
     }
     match it.node {
         ast::item_static(t, _, _) => {
             let typ = ccx.to_ty(&ExplicitRscope, t);
             let tpt = no_params(typ);
-            tcx.tcache.insert(local_def(it.id), tpt);
+
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
             return tpt;
         }
         ast::item_fn(decl, purity, abi, ref generics, _) => {
@@ -810,13 +847,18 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
                     tcx.sess.str_of(it.ident),
                     it.id,
                     ppaux::ty_to_str(tcx, tpt.ty));
-            ccx.tcx.tcache.insert(local_def(it.id), tpt);
+
+            let mut tcache = ccx.tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
             return tpt;
         }
         ast::item_ty(t, ref generics) => {
-            match tcx.tcache.find(&local_def(it.id)) {
-                Some(&tpt) => return tpt,
-                None => { }
+            {
+                let mut tcache = tcx.tcache.borrow_mut();
+                match tcache.get().find(&local_def(it.id)) {
+                    Some(&tpt) => return tpt,
+                    None => { }
+                }
             }
 
             let tpt = {
@@ -827,7 +869,8 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
                 }
             };
 
-            tcx.tcache.insert(local_def(it.id), tpt);
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
             return tpt;
         }
         ast::item_enum(_, ref generics) => {
@@ -839,7 +882,9 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
                 generics: ty_generics,
                 ty: t
             };
-            tcx.tcache.insert(local_def(it.id), tpt);
+
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
             return tpt;
         }
         ast::item_trait(..) => {
@@ -855,7 +900,9 @@ pub fn ty_of_item(ccx: &CrateCtxt, it: &ast::item)
                 generics: ty_generics,
                 ty: t
             };
-            tcx.tcache.insert(local_def(it.id), tpt);
+
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt);
             return tpt;
         }
         ast::item_impl(..) | ast::item_mod(_) |
@@ -990,7 +1037,9 @@ pub fn ty_of_foreign_fn_decl(ccx: &CrateCtxt,
         generics: ty_generics,
         ty: t_fn
     };
-    ccx.tcx.tcache.insert(def_id, tpt);
+
+    let mut tcache = ccx.tcx.tcache.borrow_mut();
+    tcache.get().insert(def_id, tpt);
     return tpt;
 }