De-@ CStore uses.

14 files changed, 109 insertions, 122 deletions

diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs
index 6830acc1960..2e6b842f3f9 100644
--- a/src/librustc/back/link.rs
+++ b/src/librustc/back/link.rs
@@ -1000,7 +1000,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) {
             }
         };
         a.add_rlib(&p, name, sess.lto()).unwrap();
-        let native_libs = csearch::get_native_libraries(sess.cstore, cnum);
+        let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
         for &(kind, ref lib) in native_libs.iter() {
             let name = match kind {
                 cstore::NativeStatic => "static library",
@@ -1302,8 +1302,8 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
     // * If one form of linking fails, the second is also attempted
     // * If both forms fail, then we emit an error message
 
-    let dynamic = get_deps(sess.cstore, cstore::RequireDynamic);
-    let statik = get_deps(sess.cstore, cstore::RequireStatic);
+    let dynamic = get_deps(&sess.cstore, cstore::RequireDynamic);
+    let statik = get_deps(&sess.cstore, cstore::RequireStatic);
     match (dynamic, statik, sess.opts.cg.prefer_dynamic, dylib) {
         (_, Some(deps), false, false) => {
             add_static_crates(args, sess, tmpdir, deps)
@@ -1459,7 +1459,7 @@ fn add_upstream_rust_crates(args: &mut Vec<~str>, sess: &Session,
 // be instantiated in the target crate, meaning that the native symbol must
 // also be resolved in the target crate.
 fn add_upstream_native_libraries(args: &mut Vec<~str>, sess: &Session) {
-    let cstore = sess.cstore;
+    let cstore = &sess.cstore;
     cstore.iter_crate_data(|cnum, _| {
         let libs = csearch::get_native_libraries(cstore, cnum);
         for &(kind, ref lib) in libs.iter() {
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 9eeb5bb7ad7..dee0cf23ec7 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -1004,7 +1004,6 @@ pub fn build_session_(sopts: @session::Options,
                       -> Session {
     let target_cfg = build_target_config(sopts);
     let p_s = parse::new_parse_sess_special_handler(span_diagnostic_handler, codemap);
-    let cstore = @CStore::new(token::get_ident_interner());
     let default_sysroot = match sopts.maybe_sysroot {
         Some(_) => None,
         None => Some(filesearch::get_or_default_sysroot())
@@ -1022,7 +1021,7 @@ pub fn build_session_(sopts: @session::Options,
     Session {
         targ_cfg: target_cfg,
         opts: sopts,
-        cstore: cstore,
+        cstore: CStore::new(token::get_ident_interner()),
         parse_sess: p_s,
         codemap: codemap,
         // For a library crate, this is always none
diff --git a/src/librustc/driver/session.rs b/src/librustc/driver/session.rs
index 20bbab27434..5cdfe3691c7 100644
--- a/src/librustc/driver/session.rs
+++ b/src/librustc/driver/session.rs
@@ -176,7 +176,7 @@ pub enum CrateType {
 pub struct Session {
     targ_cfg: @Config,
     opts: @Options,
-    cstore: @metadata::cstore::CStore,
+    cstore: metadata::cstore::CStore,
     parse_sess: @ParseSess,
     codemap: @codemap::CodeMap,
     // For a library crate, this is always none
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 5c81b622704..359f28f2ad1 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -120,12 +120,10 @@ struct Env<'a> {
 }
 
 fn visit_crate(e: &Env, c: &ast::Crate) {
-    let cstore = e.sess.cstore;
-
     for a in c.attrs.iter().filter(|m| m.name().equiv(&("link_args"))) {
         match a.value_str() {
-          Some(ref linkarg) => cstore.add_used_link_args(linkarg.get()),
-          None => { /* fallthrough */ }
+            Some(ref linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
+            None => { /* fallthrough */ }
         }
     }
 }
@@ -195,7 +193,6 @@ fn visit_item(e: &Env, i: &ast::Item) {
             }
 
             // First, add all of the custom link_args attributes
-            let cstore = e.sess.cstore;
             let link_args = i.attrs.iter()
                 .filter_map(|at| if at.name().equiv(&("link_args")) {
                     Some(at)
@@ -205,13 +202,12 @@ fn visit_item(e: &Env, i: &ast::Item) {
                 .to_owned_vec();
             for m in link_args.iter() {
                 match m.value_str() {
-                    Some(linkarg) => cstore.add_used_link_args(linkarg.get()),
+                    Some(linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
                     None => { /* fallthrough */ }
                 }
             }
 
             // Next, process all of the #[link(..)]-style arguments
-            let cstore = e.sess.cstore;
             let link_args = i.attrs.iter()
                 .filter_map(|at| if at.name().equiv(&("link")) {
                     Some(at)
@@ -260,7 +256,7 @@ fn visit_item(e: &Env, i: &ast::Item) {
                         if n.get().is_empty() {
                             e.sess.span_err(m.span, "#[link(name = \"\")] given with empty name");
                         } else {
-                            cstore.add_used_library(n.get().to_owned(), kind);
+                            e.sess.cstore.add_used_library(n.get().to_owned(), kind);
                         }
                     }
                     None => {}
@@ -344,18 +340,15 @@ fn resolve_crate(e: &mut Env,
                 cnum: cnum
             };
 
-            let cstore = e.sess.cstore;
-            cstore.set_crate_data(cnum, cmeta);
-            cstore.add_used_crate_source(cstore::CrateSource {
+            e.sess.cstore.set_crate_data(cnum, cmeta);
+            e.sess.cstore.add_used_crate_source(cstore::CrateSource {
                 dylib: dylib,
                 rlib: rlib,
                 cnum: cnum,
             });
-            return cnum;
-        }
-        Some(cnum) => {
-            return cnum;
+            cnum
         }
+        Some(cnum) => cnum
     }
 }
 
@@ -415,12 +408,12 @@ impl<'a> CrateLoader for Loader<'a> {
     }
 
     fn get_exported_macros(&mut self, cnum: ast::CrateNum) -> Vec<~str> {
-        csearch::get_exported_macros(self.env.sess.cstore, cnum).move_iter()
-                                                                .collect()
+        csearch::get_exported_macros(&self.env.sess.cstore, cnum).move_iter()
+                                                                 .collect()
     }
 
     fn get_registrar_symbol(&mut self, cnum: ast::CrateNum) -> Option<~str> {
-        let cstore = self.env.sess.cstore;
+        let cstore = &self.env.sess.cstore;
         csearch::get_macro_registrar_fn(cstore, cnum)
             .map(|did| csearch::get_symbol(cstore, did))
     }
diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index 64e12679da1..95c85a04b19 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -34,19 +34,19 @@ pub struct StaticMethodInfo {
     vis: ast::Visibility,
 }
 
-pub fn get_symbol(cstore: @cstore::CStore, def: ast::DefId) -> ~str {
+pub fn get_symbol(cstore: &cstore::CStore, def: ast::DefId) -> ~str {
     let cdata = cstore.get_crate_data(def.krate).data();
     return decoder::get_symbol(cdata, def.node);
 }
 
-pub fn get_type_param_count(cstore: @cstore::CStore, def: ast::DefId)
+pub fn get_type_param_count(cstore: &cstore::CStore, def: ast::DefId)
                          -> uint {
     let cdata = cstore.get_crate_data(def.krate).data();
     return decoder::get_type_param_count(cdata, def.node);
 }
 
 /// Iterates over all the language items in the given crate.
-pub fn each_lang_item(cstore: @cstore::CStore,
+pub fn each_lang_item(cstore: &cstore::CStore,
                       cnum: ast::CrateNum,
                       f: |ast::NodeId, uint| -> bool)
                       -> bool {
@@ -55,7 +55,7 @@ pub fn each_lang_item(cstore: @cstore::CStore,
 }
 
 /// Iterates over each child of the given item.
-pub fn each_child_of_item(cstore: @cstore::CStore,
+pub fn each_child_of_item(cstore: &cstore::CStore,
                           def_id: ast::DefId,
                           callback: |decoder::DefLike,
                                      ast::Ident,
@@ -72,7 +72,7 @@ pub fn each_child_of_item(cstore: @cstore::CStore,
 }
 
 /// Iterates over each top-level crate item.
-pub fn each_top_level_item_of_crate(cstore: @cstore::CStore,
+pub fn each_top_level_item_of_crate(cstore: &cstore::CStore,
                                     cnum: ast::CrateNum,
                                     callback: |decoder::DefLike,
                                                ast::Ident,
@@ -88,7 +88,7 @@ pub fn each_top_level_item_of_crate(cstore: @cstore::CStore,
 }
 
 pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     let path = decoder::get_item_path(cdata, def.node);
 
@@ -110,14 +110,14 @@ pub enum found_ast {
 pub fn maybe_get_item_ast(tcx: &ty::ctxt, def: ast::DefId,
                           decode_inlined_item: decoder::DecodeInlinedItem)
                        -> found_ast {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::maybe_get_item_ast(cdata, tcx, def.node, decode_inlined_item)
 }
 
 pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
                       -> Vec<@ty::VariantInfo> {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     return decoder::get_enum_variants(cstore.intr, cdata, def.node, tcx)
 }
@@ -125,16 +125,16 @@ pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
 /// Returns information about the given implementation.
 pub fn get_impl(tcx: &ty::ctxt, impl_def_id: ast::DefId)
                 -> ty::Impl {
-    let cdata = tcx.cstore.get_crate_data(impl_def_id.krate);
-    decoder::get_impl(tcx.cstore.intr, cdata, impl_def_id.node, tcx)
+    let cdata = tcx.sess.cstore.get_crate_data(impl_def_id.krate);
+    decoder::get_impl(tcx.sess.cstore.intr, cdata, impl_def_id.node, tcx)
 }
 
 pub fn get_method(tcx: &ty::ctxt, def: ast::DefId) -> ty::Method {
-    let cdata = tcx.cstore.get_crate_data(def.krate);
-    decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
+    let cdata = tcx.sess.cstore.get_crate_data(def.krate);
+    decoder::get_method(tcx.sess.cstore.intr, cdata, def.node, tcx)
 }
 
-pub fn get_method_name_and_explicit_self(cstore: @cstore::CStore,
+pub fn get_method_name_and_explicit_self(cstore: &cstore::CStore,
                                          def: ast::DefId)
                                      -> (ast::Ident, ast::ExplicitSelf_)
 {
@@ -142,13 +142,13 @@ pub fn get_method_name_and_explicit_self(cstore: @cstore::CStore,
     decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node)
 }
 
-pub fn get_trait_method_def_ids(cstore: @cstore::CStore,
+pub fn get_trait_method_def_ids(cstore: &cstore::CStore,
                                 def: ast::DefId) -> Vec<ast::DefId> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_method_def_ids(cdata, def.node)
 }
 
-pub fn get_item_variances(cstore: @cstore::CStore,
+pub fn get_item_variances(cstore: &cstore::CStore,
                           def: ast::DefId) -> ty::ItemVariances {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_item_variances(cdata, def.node)
@@ -157,38 +157,38 @@ pub fn get_item_variances(cstore: @cstore::CStore,
 pub fn get_provided_trait_methods(tcx: &ty::ctxt,
                                   def: ast::DefId)
                                -> Vec<@ty::Method> {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_provided_trait_methods(cstore.intr, cdata, def.node, tcx)
 }
 
 pub fn get_supertraits(tcx: &ty::ctxt, def: ast::DefId) -> Vec<@ty::TraitRef> {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_supertraits(cdata, def.node, tcx)
 }
 
-pub fn get_type_name_if_impl(cstore: @cstore::CStore, def: ast::DefId)
+pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: ast::DefId)
                           -> Option<ast::Ident> {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type_name_if_impl(cdata, def.node)
 }
 
-pub fn get_static_methods_if_impl(cstore: @cstore::CStore,
+pub fn get_static_methods_if_impl(cstore: &cstore::CStore,
                                   def: ast::DefId)
                                -> Option<Vec<StaticMethodInfo> > {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_static_methods_if_impl(cstore.intr, cdata, def.node)
 }
 
-pub fn get_item_attrs(cstore: @cstore::CStore,
+pub fn get_item_attrs(cstore: &cstore::CStore,
                       def_id: ast::DefId,
                       f: |Vec<@ast::MetaItem> |) {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::get_item_attrs(cdata, def_id.node, f)
 }
 
-pub fn get_struct_fields(cstore: @cstore::CStore,
+pub fn get_struct_fields(cstore: &cstore::CStore,
                          def: ast::DefId)
                       -> Vec<ty::field_ty> {
     let cdata = cstore.get_crate_data(def.krate);
@@ -198,20 +198,20 @@ pub fn get_struct_fields(cstore: @cstore::CStore,
 pub fn get_type(tcx: &ty::ctxt,
                 def: ast::DefId)
              -> ty::ty_param_bounds_and_ty {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type(cdata, def.node, tcx)
 }
 
 pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_def(cdata, def.node, tcx)
 }
 
 pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
                       def: ast::DefId) -> ty::ty_param_bounds_and_ty {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(class_id.krate);
     let all_items = reader::get_doc(reader::Doc(cdata.data()), tag_items);
     let class_doc = expect(tcx.diag,
@@ -234,7 +234,7 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
 // if there is one.
 pub fn get_impl_trait(tcx: &ty::ctxt,
                       def: ast::DefId) -> Option<@ty::TraitRef> {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_impl_trait(cdata, def.node, tcx)
 }
@@ -242,12 +242,12 @@ pub fn get_impl_trait(tcx: &ty::ctxt,
 // Given a def_id for an impl, return information about its vtables
 pub fn get_impl_vtables(tcx: &ty::ctxt,
                         def: ast::DefId) -> typeck::impl_res {
-    let cstore = tcx.cstore;
+    let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_impl_vtables(cdata, def.node, tcx)
 }
 
-pub fn get_impl_method(cstore: @cstore::CStore,
+pub fn get_impl_method(cstore: &cstore::CStore,
                        def: ast::DefId,
                        mname: ast::Ident)
                     -> Option<ast::DefId> {
@@ -255,35 +255,35 @@ pub fn get_impl_method(cstore: @cstore::CStore,
     decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
 }
 
-pub fn get_item_visibility(cstore: @cstore::CStore,
+pub fn get_item_visibility(cstore: &cstore::CStore,
                            def_id: ast::DefId)
                         -> ast::Visibility {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::get_item_visibility(cdata, def_id.node)
 }
 
-pub fn get_native_libraries(cstore: @cstore::CStore,
+pub fn get_native_libraries(cstore: &cstore::CStore,
                             crate_num: ast::CrateNum)
                                 -> Vec<(cstore::NativeLibaryKind, ~str)> {
     let cdata = cstore.get_crate_data(crate_num);
     decoder::get_native_libraries(cdata)
 }
 
-pub fn each_impl(cstore: @cstore::CStore,
+pub fn each_impl(cstore: &cstore::CStore,
                  crate_num: ast::CrateNum,
                  callback: |ast::DefId|) {
     let cdata = cstore.get_crate_data(crate_num);
     decoder::each_impl(cdata, callback)
 }
 
-pub fn each_implementation_for_type(cstore: @cstore::CStore,
+pub fn each_implementation_for_type(cstore: &cstore::CStore,
                                     def_id: ast::DefId,
                                     callback: |ast::DefId|) {
     let cdata = cstore.get_crate_data(def_id.krate);
     decoder::each_implementation_for_type(cdata, def_id.node, callback)
 }
 
-pub fn each_implementation_for_trait(cstore: @cstore::CStore,
+pub fn each_implementation_for_trait(cstore: &cstore::CStore,
                                      def_id: ast::DefId,
                                      callback: |ast::DefId|) {
     let cdata = cstore.get_crate_data(def_id.krate);
@@ -293,7 +293,7 @@ pub fn each_implementation_for_trait(cstore: @cstore::CStore,
 /// If the given def ID describes a method belonging to a trait (either a
 /// default method or an implementation of a trait method), returns the ID of
 /// the trait that the method belongs to. Otherwise, returns `None`.
-pub fn get_trait_of_method(cstore: @cstore::CStore,
+pub fn get_trait_of_method(cstore: &cstore::CStore,
                            def_id: ast::DefId,
                            tcx: &ty::ctxt)
                            -> Option<ast::DefId> {
@@ -301,14 +301,14 @@ pub fn get_trait_of_method(cstore: @cstore::CStore,
     decoder::get_trait_of_method(cdata, def_id.node, tcx)
 }
 
-pub fn get_macro_registrar_fn(cstore: @cstore::CStore,
+pub fn get_macro_registrar_fn(cstore: &cstore::CStore,
                               crate_num: ast::CrateNum)
                               -> Option<ast::DefId> {
     let cdata = cstore.get_crate_data(crate_num);
     decoder::get_macro_registrar_fn(cdata)
 }
 
-pub fn get_exported_macros(cstore: @cstore::CStore,
+pub fn get_exported_macros(cstore: &cstore::CStore,
                            crate_num: ast::CrateNum)
                            -> Vec<~str> {
     let cdata = cstore.get_crate_data(crate_num);
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index b4d2eed0b9b..a1ee7d39ed7 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -74,7 +74,7 @@ pub struct EncodeParams<'a> {
     item_symbols: &'a RefCell<NodeMap<~str>>,
     non_inlineable_statics: &'a RefCell<NodeSet>,
     link_meta: &'a LinkMeta,
-    cstore: @cstore::CStore,
+    cstore: &'a cstore::CStore,
     encode_inlined_item: EncodeInlinedItem<'a>,
 }
 
diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs
index ef1a84fd886..2ce34a31129 100644
--- a/src/librustc/middle/lang_items.rs
+++ b/src/librustc/middle/lang_items.rs
@@ -165,7 +165,7 @@ impl<'a> LanguageItemCollector<'a> {
     }
 
     pub fn collect_external_language_items(&mut self) {
-        let crate_store = self.session.cstore;
+        let crate_store = &self.session.cstore;
         crate_store.iter_crate_data(|crate_number, _crate_metadata| {
             each_lang_item(crate_store, crate_number, |node_id, item_index| {
                 let def_id = ast::DefId { krate: crate_number, node: node_id };
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 88ba1b990c1..6ea26a9c5aa 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -1100,7 +1100,7 @@ fn check_unused_result(cx: &Context, s: &ast::Stmt) {
                     _ => {}
                 }
             } else {
-                csearch::get_item_attrs(cx.tcx.sess.cstore, did, |attrs| {
+                csearch::get_item_attrs(&cx.tcx.sess.cstore, did, |attrs| {
                     if attr::contains_name(attrs.as_slice(), "must_use") {
                         cx.span_lint(UnusedMustUse, s.span,
                                      "unused result which must be used");
@@ -1562,7 +1562,7 @@ fn check_stability(cx: &Context, e: &ast::Expr) {
         let mut s = None;
         // run through all the attributes and take the first
         // stability one.
-        csearch::get_item_attrs(cx.tcx.cstore, id, |meta_items| {
+        csearch::get_item_attrs(&cx.tcx.sess.cstore, id, |meta_items| {
             if s.is_none() {
                 s = attr::find_stability(meta_items.move_iter())
             }
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 1c98f745ab0..1de38d8a461 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -585,7 +585,7 @@ impl<'a> PrivacyVisitor<'a> {
                 }
             }
         } else {
-            let cstore = self.tcx.sess.cstore;
+            let cstore = &self.tcx.sess.cstore;
             match enum_id {
                 Some(enum_id) => {
                     let v = csearch::get_enum_variants(self.tcx, enum_id);
diff --git a/src/librustc/middle/resolve.rs b/src/librustc/middle/resolve.rs
index 1641623b9cb..bea776eb209 100644
--- a/src/librustc/middle/resolve.rs
+++ b/src/librustc/middle/resolve.rs
@@ -1690,11 +1690,11 @@ impl<'a> Resolver<'a> {
               // to the trait info.
 
               let method_def_ids =
-                csearch::get_trait_method_def_ids(self.session.cstore, def_id);
+                csearch::get_trait_method_def_ids(&self.session.cstore, def_id);
               let mut interned_method_names = HashSet::new();
               for &method_def_id in method_def_ids.iter() {
                   let (method_name, explicit_self) =
-                      csearch::get_method_name_and_explicit_self(self.session.cstore,
+                      csearch::get_method_name_and_explicit_self(&self.session.cstore,
                                                                  method_def_id);
 
                   debug!("(building reduced graph for \
@@ -1743,7 +1743,7 @@ impl<'a> Resolver<'a> {
                     crate) building type and value for {}",
                    final_ident);
             child_name_bindings.define_type(def, DUMMY_SP, is_public);
-            if csearch::get_struct_fields(self.session.cstore, def_id).len() == 0 {
+            if csearch::get_struct_fields(&self.session.cstore, def_id).len() == 0 {
                 child_name_bindings.define_value(def, DUMMY_SP, is_public);
             }
             self.structs.insert(def_id);
@@ -1775,7 +1775,7 @@ impl<'a> Resolver<'a> {
                     DefForeignMod(def_id) => {
                         // Foreign modules have no names. Recur and populate
                         // eagerly.
-                        csearch::each_child_of_item(self.session.cstore,
+                        csearch::each_child_of_item(&self.session.cstore,
                                                     def_id,
                                                     |def_like,
                                                      child_ident,
@@ -1805,11 +1805,11 @@ impl<'a> Resolver<'a> {
             }
             DlImpl(def) => {
                 // We only process static methods of impls here.
-                match csearch::get_type_name_if_impl(self.session.cstore, def) {
+                match csearch::get_type_name_if_impl(&self.session.cstore, def) {
                     None => {}
                     Some(final_ident) => {
                         let static_methods_opt =
-                            csearch::get_static_methods_if_impl(self.session.cstore, def);
+                            csearch::get_static_methods_if_impl(&self.session.cstore, def);
                         match static_methods_opt {
                             Some(ref static_methods) if
                                 static_methods.len() >= 1 => {
@@ -1910,7 +1910,7 @@ impl<'a> Resolver<'a> {
             Some(def_id) => def_id,
         };
 
-        csearch::each_child_of_item(self.session.cstore,
+        csearch::each_child_of_item(&self.session.cstore,
                                     def_id,
                                     |def_like, child_ident, visibility| {
             debug!("(populating external module) ... found ident: {}",
@@ -1936,7 +1936,7 @@ impl<'a> Resolver<'a> {
     /// crate.
     fn build_reduced_graph_for_external_crate(&mut self,
                                               root: @Module) {
-        csearch::each_top_level_item_of_crate(self.session.cstore,
+        csearch::each_top_level_item_of_crate(&self.session.cstore,
                                               root.def_id
                                                   .get()
                                                   .unwrap()
diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs
index 6dff780cc3c..56ceb867735 100644
--- a/src/librustc/middle/trans/base.rs
+++ b/src/librustc/middle/trans/base.rs
@@ -246,7 +246,7 @@ fn get_extern_rust_fn(ccx: &CrateContext, inputs: &[ty::t], output: ty::t,
     }
 
     let f = decl_rust_fn(ccx, false, inputs, output, name);
-    csearch::get_item_attrs(ccx.tcx.cstore, did, |meta_items| {
+    csearch::get_item_attrs(&ccx.sess().cstore, did, |meta_items| {
         set_llvm_fn_attrs(meta_items.iter().map(|&x| attr::mk_attr(x)).to_owned_vec(), f)
     });
 
@@ -555,7 +555,7 @@ pub fn get_res_dtor(ccx: &CrateContext,
         get_item_val(ccx, did.node)
     } else {
         let tcx = ccx.tcx;
-        let name = csearch::get_symbol(ccx.sess().cstore, did);
+        let name = csearch::get_symbol(&ccx.sess().cstore, did);
         let class_ty = ty::subst_tps(tcx,
                                      substs,
                                      None,
@@ -874,7 +874,7 @@ pub fn fail_if_zero<'a>(
 }
 
 pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> ValueRef {
-    let name = csearch::get_symbol(ccx.sess().cstore, did);
+    let name = csearch::get_symbol(&ccx.sess().cstore, did);
     match ty::get(t).sty {
         ty::ty_bare_fn(ref fn_ty) => {
             match fn_ty.abis.for_target(ccx.sess().targ_cfg.os,
@@ -1966,7 +1966,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                                 match external_srcs.get().find(&i.id) {
                                     Some(&did) => {
                                         debug!("but found in other crate...");
-                                        (csearch::get_symbol(ccx.sess().cstore,
+                                        (csearch::get_symbol(&ccx.sess().cstore,
                                                              did), false)
                                     }
                                     None => (sym, true)
@@ -2394,7 +2394,7 @@ pub fn decl_crate_map(sess: &Session, mapmeta: LinkMeta,
     let targ_cfg = sess.targ_cfg;
     let int_type = Type::int(targ_cfg.arch);
     let mut n_subcrates = 1;
-    let cstore = sess.cstore;
+    let cstore = &sess.cstore;
     while cstore.have_crate_data(n_subcrates) { n_subcrates += 1; }
     let is_top = !sess.building_library.get() || sess.opts.cg.gen_crate_map;
     let sym_name = if is_top {
@@ -2432,7 +2432,7 @@ pub fn fill_crate_map(ccx: &CrateContext, map: ValueRef) {
                 llvm::LLVMConstPointerCast(get_item_val(ccx, did.node),
                                            ccx.int_type.ptr_to().to_ref())
             } else {
-                let name = csearch::get_symbol(ccx.sess().cstore, did);
+                let name = csearch::get_symbol(&ccx.sess().cstore, did);
                 let global = name.with_c_str(|buf| {
                     llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf)
                 });
@@ -2462,7 +2462,7 @@ pub fn crate_ctxt_to_encode_parms<'r>(cx: &'r CrateContext, ie: encoder::EncodeI
             item_symbols: item_symbols,
             non_inlineable_statics: &cx.non_inlineable_statics,
             link_meta: link_meta,
-            cstore: cx.sess().cstore,
+            cstore: &cx.sess().cstore,
             encode_inlined_item: ie,
         }
 }
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index d013c8fa1b9..20385c97102 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -581,7 +581,7 @@ fn trans_def<'a>(bcx: &'a Block<'a>,
                     unsafe {
                         let llty = type_of::type_of(bcx.ccx(), const_ty);
                         let symbol = csearch::get_symbol(
-                            bcx.ccx().sess().cstore,
+                            &bcx.ccx().sess().cstore,
                             did);
                         let llval = symbol.with_c_str(|buf| {
                                 llvm::LLVMAddGlobal(bcx.ccx().llmod,
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 550306a955b..aa92cf30498 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -13,7 +13,6 @@
 use back::svh::Svh;
 use driver::session::Session;
 use metadata::csearch;
-use metadata;
 use middle::const_eval;
 use middle::lang_items::{ExchangeHeapLangItem, OpaqueStructLangItem};
 use middle::lang_items::{TyDescStructLangItem, TyVisitorTraitLangItem};
@@ -259,7 +258,6 @@ pub struct ctxt {
     // quite often.
     interner: RefCell<FnvHashMap<intern_key, ~t_box_>>,
     next_id: Cell<uint>,
-    cstore: @metadata::cstore::CStore,
     sess: Session,
     def_map: resolve::DefMap,
 
@@ -1093,7 +1091,6 @@ pub fn mk_ctxt(s: Session,
         diag: s.diagnostic(),
         interner: RefCell::new(FnvHashMap::new()),
         next_id: Cell::new(primitives::LAST_PRIMITIVE_ID),
-        cstore: s.cstore,
         sess: s,
         def_map: dm,
         region_maps: region_maps,
@@ -3806,7 +3803,7 @@ pub fn trait_method_def_ids(cx: &ctxt, id: ast::DefId) -> @Vec<DefId> {
                                      id,
                                      trait_method_def_ids.get(),
                                      || {
-        @csearch::get_trait_method_def_ids(cx.cstore, id)
+        @csearch::get_trait_method_def_ids(&cx.sess.cstore, id)
     })
 }
 
@@ -4175,7 +4172,7 @@ pub fn each_attr(tcx: &ctxt, did: DefId, f: |@MetaItem| -> bool) -> bool {
         item.attrs.iter().advance(|attr| f(attr.node.value))
     } else {
         let mut cont = true;
-        csearch::get_item_attrs(tcx.cstore, did, |meta_items| {
+        csearch::get_item_attrs(&tcx.sess.cstore, did, |meta_items| {
             if cont {
                 cont = meta_items.iter().advance(|ptrptr| f(*ptrptr));
             }
@@ -4246,38 +4243,36 @@ pub fn lookup_field_type(tcx: &ctxt,
 // Look up the list of field names and IDs for a given struct
 // Fails if the id is not bound to a struct.
 pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec<field_ty> {
-  if did.krate == ast::LOCAL_CRATE {
-      {
-          match cx.map.find(did.node) {
-           Some(ast_map::NodeItem(i)) => {
-             match i.node {
-                ast::ItemStruct(struct_def, _) => {
-                   struct_field_tys(struct_def.fields.as_slice())
-                }
-                _ => cx.sess.bug("struct ID bound to non-struct")
-             }
-           }
-           Some(ast_map::NodeVariant(ref variant)) => {
-              match (*variant).node.kind {
-                ast::StructVariantKind(struct_def) => {
-                  struct_field_tys(struct_def.fields.as_slice())
+    if did.krate == ast::LOCAL_CRATE {
+        match cx.map.find(did.node) {
+            Some(ast_map::NodeItem(i)) => {
+                match i.node {
+                    ast::ItemStruct(struct_def, _) => {
+                        struct_field_tys(struct_def.fields.as_slice())
+                    }
+                    _ => cx.sess.bug("struct ID bound to non-struct")
                 }
-                _ => {
-                  cx.sess.bug("struct ID bound to enum variant that isn't \
-                               struct-like")
+            }
+            Some(ast_map::NodeVariant(ref variant)) => {
+                match (*variant).node.kind {
+                    ast::StructVariantKind(struct_def) => {
+                        struct_field_tys(struct_def.fields.as_slice())
+                    }
+                    _ => {
+                        cx.sess.bug("struct ID bound to enum variant that \
+                                    isn't struct-like")
+                    }
                 }
-              }
-           }
-           _ => {
-               cx.sess.bug(
-                   format!("struct ID not bound to an item: {}",
+            }
+            _ => {
+                cx.sess.bug(
+                    format!("struct ID not bound to an item: {}",
                         cx.map.node_to_str(did.node)));
-           }
-          }
-      }
-  } else {
-    return csearch::get_struct_fields(cx.sess.cstore, did);
-  }
+            }
+        }
+    } else {
+        csearch::get_struct_fields(&cx.sess.cstore, did)
+    }
 }
 
 pub fn lookup_struct_field(cx: &ctxt,
@@ -4650,7 +4645,7 @@ pub fn item_variances(tcx: &ctxt, item_id: ast::DefId) -> @ItemVariances {
     let mut item_variance_map = tcx.item_variance_map.borrow_mut();
     lookup_locally_or_in_crate_store(
         "item_variance_map", item_id, item_variance_map.get(),
-        || @csearch::get_item_variances(tcx.cstore, item_id))
+        || @csearch::get_item_variances(&tcx.sess.cstore, item_id))
 }
 
 /// Records a trait-to-implementation mapping.
@@ -4687,7 +4682,7 @@ pub fn populate_implementations_for_type_if_necessary(tcx: &ctxt,
         }
     }
 
-    csearch::each_implementation_for_type(tcx.sess.cstore, type_id,
+    csearch::each_implementation_for_type(&tcx.sess.cstore, type_id,
             |implementation_def_id| {
         let implementation = @csearch::get_impl(tcx, implementation_def_id);
 
@@ -4756,7 +4751,7 @@ pub fn populate_implementations_for_trait_if_necessary(
         }
     }
 
-    csearch::each_implementation_for_trait(tcx.sess.cstore, trait_id,
+    csearch::each_implementation_for_trait(&tcx.sess.cstore, trait_id,
             |implementation_def_id| {
         let implementation = @csearch::get_impl(tcx, implementation_def_id);
 
@@ -4810,7 +4805,7 @@ pub fn trait_id_of_impl(tcx: &ctxt,
 pub fn trait_of_method(tcx: &ctxt, def_id: ast::DefId)
                        -> Option<ast::DefId> {
     if def_id.krate != LOCAL_CRATE {
-        return csearch::get_trait_of_method(tcx.cstore, def_id, tcx);
+        return csearch::get_trait_of_method(&tcx.sess.cstore, def_id, tcx);
     }
     let method;
     {
diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs
index bd61190a79f..894c70c7b61 100644
--- a/src/librustc/middle/typeck/coherence.rs
+++ b/src/librustc/middle/typeck/coherence.rs
@@ -450,7 +450,7 @@ impl<'a> CoherenceChecker<'a> {
                             session.span_note(self.span_of_impl(implementation_b),
                                               "note conflicting implementation here");
                         } else {
-                            let crate_store = self.crate_context.tcx.sess.cstore;
+                            let crate_store = &self.crate_context.tcx.sess.cstore;
                             let cdata = crate_store.get_crate_data(implementation_b.did.krate);
                             session.note(
                                 "conflicting implementation in crate `" + cdata.name + "`");
@@ -468,7 +468,7 @@ impl<'a> CoherenceChecker<'a> {
             return;
         }
 
-        let crate_store = self.crate_context.tcx.sess.cstore;
+        let crate_store = &self.crate_context.tcx.sess.cstore;
         csearch::each_implementation_for_trait(crate_store, trait_def_id, |impl_def_id| {
             let implementation = @csearch::get_impl(self.crate_context.tcx, impl_def_id);
             let _ = lookup_item_type(self.crate_context.tcx, implementation.did);
@@ -682,7 +682,7 @@ impl<'a> CoherenceChecker<'a> {
     fn add_external_crates(&self) {
         let mut impls_seen = HashSet::new();
 
-        let crate_store = self.crate_context.tcx.sess.cstore;
+        let crate_store = &self.crate_context.tcx.sess.cstore;
         crate_store.iter_crate_data(|crate_number, _crate_metadata| {
             each_impl(crate_store, crate_number, |def_id| {
                 assert_eq!(crate_number, def_id.krate);