remove csearch from the rest of rustc

Author: arielb1

src/librustc/metadata/creader.rs

@@ -242,7 +242,7 @@ impl<'a> CrateReader<'a> {
             // We're also sure to compare *paths*, not actual byte slices. The
             // `source` stores paths which are normalized which may be different
             // from the strings on the command line.
-            let source = self.sess.cstore.get_used_crate_source(cnum).unwrap();
+            let source = self.sess.cstore.do_get_used_crate_source(cnum).unwrap();
             if let Some(locs) = self.sess.opts.externs.get(name) {
                 let found = locs.iter().any(|l| {
                     let l = fs::canonicalize(l).ok();
@@ -415,7 +415,7 @@ impl<'a> CrateReader<'a> {
                 if explicitly_linked && !data.explicitly_linked.get() {
                     data.explicitly_linked.set(explicitly_linked);
                 }
-                (cnum, data, self.sess.cstore.get_used_crate_source(cnum).unwrap())
+                (cnum, data, self.sess.cstore.do_get_used_crate_source(cnum).unwrap())
             }
             LookupResult::Loaded(library) => {
                 self.register_crate(root, ident, name, span, library,

src/librustc/metadata/cstore.rs

@@ -159,7 +159,7 @@ impl CStore {
         I: FnMut(ast::CrateNum, &crate_metadata, Option<CrateSource>),
     {
         for (&k, v) in self.metas.borrow().iter() {
-            let origin = self.get_used_crate_source(k);
+            let origin = self.do_get_used_crate_source(k);
             origin.as_ref().map(|cs| { assert!(k == cs.cnum); });
             i(k, &**v, origin);
         }
@@ -172,8 +172,9 @@ impl CStore {
         }
     }
 
-    pub fn get_used_crate_source(&self, cnum: ast::CrateNum)
-                                     -> Option<CrateSource> {
+    // TODO: killdo
+    pub fn do_get_used_crate_source(&self, cnum: ast::CrateNum)
+                                    -> Option<CrateSource> {
         self.used_crate_sources.borrow_mut()
             .iter().find(|source| source.cnum == cnum).cloned()
     }
@@ -196,8 +197,9 @@ impl CStore {
     // In order to get this left-to-right dependency ordering, we perform a
     // topological sort of all crates putting the leaves at the right-most
     // positions.
-    pub fn get_used_crates(&self, prefer: LinkagePreference)
-                           -> Vec<(ast::CrateNum, Option<PathBuf>)> {
+    // TODO: killdo
+    pub fn do_get_used_crates(&self, prefer: LinkagePreference)
+                              -> Vec<(ast::CrateNum, Option<PathBuf>)> {
         let mut ordering = Vec::new();
         fn visit(cstore: &CStore, cnum: ast::CrateNum,
                  ordering: &mut Vec<ast::CrateNum>) {

src/librustc/metadata/util.rs

@@ -11,24 +11,36 @@
 use front::map as ast_map;
 use metadata::cstore;
 use metadata::decoder;
+use metadata::encoder;
+use metadata::loader;
 use middle::astencode;
+use middle::def;
 use middle::lang_items;
-use middle::ty;
+use middle::ty::{self, Ty};
 use middle::def_id::{DefId, DefIndex};
+use util::nodemap::{NodeMap, NodeSet};
 
 use std::any::Any;
+use std::cell::RefCell;
 use std::rc::Rc;
+use std::path::PathBuf;
 use syntax::ast;
 use syntax::attr;
+use rustc_back::target::Target;
 use rustc_front::hir;
 
+pub use metadata::common::LinkMeta;
+pub use metadata::creader::validate_crate_name;
 pub use metadata::csearch::FoundAst;
+pub use metadata::cstore::CrateSource;
 pub use metadata::cstore::LinkagePreference;
+pub use metadata::cstore::NativeLibraryKind;
 pub use metadata::decoder::DecodeInlinedItem;
 pub use metadata::decoder::DefLike;
 pub use metadata::inline::InlinedItem;
 
 pub use self::DefLike::{DlDef, DlField, DlImpl};
+pub use self::NativeLibraryKind::{NativeStatic, NativeFramework, NativeUnknown};
 
 pub struct ChildItem {
     pub def: DefLike,
@@ -54,6 +66,7 @@ pub trait CrateStore<'tcx> : Any {
     fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                              -> ty::GenericPredicates<'tcx>;
     fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>;
+    fn item_symbol(&self, def: DefId) -> String;
     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId)-> ty::TraitDef<'tcx>;
     fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>;
     fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>;
@@ -86,14 +99,21 @@ pub trait CrateStore<'tcx> : Any {
     fn is_defaulted_trait(&self, did: DefId) -> bool;
     fn is_impl(&self, did: DefId) -> bool;
     fn is_static_method(&self, did: DefId) -> bool;
+    fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool;
+    fn is_static(&self, did: DefId) -> bool;
 
-    // metadata
+    // crate metadata
     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
                                     -> Vec<(ast::CrateNum, LinkagePreference)>;
     fn lang_items(&self, cnum: ast::CrateNum) -> Vec<(DefIndex, usize)>;
     fn missing_lang_items(&self, cnum: ast::CrateNum) -> Vec<lang_items::LangItem>;
     fn is_staged_api(&self, cnum: ast::CrateNum) -> bool;
+    fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool;
+    fn is_allocator(&self, cnum: ast::CrateNum) -> bool;
+    fn crate_name(&self, cnum: ast::CrateNum) -> String;
     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>;
+    fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>;
+    fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec<DefId>;
 
     // resolve
     fn def_path(&self, def: DefId) -> ast_map::DefPath;
@@ -102,9 +122,24 @@ pub trait CrateStore<'tcx> : Any {
     fn item_children(&self, did: DefId) -> Vec<ChildItem>;
     fn crate_top_level_items(&self, cnum: ast::CrateNum) -> Vec<ChildItem>;
 
-    // misc.
+    // misc. metadata
     fn maybe_get_item_ast(&'tcx self, tcx: &ty::ctxt<'tcx>, def: DefId)
                           -> FoundAst<'tcx>;
+
+    // utility functions
+    fn metadata_filename(&self) -> &str;
+    fn metadata_section_name(&self, target: &Target) -> &str;
+    fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec<u8>;
+    fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option<PathBuf>)>;
+    fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource;
+    fn encode_metadata(&self,
+                       tcx: &ty::ctxt<'tcx>,
+                       reexports: &def::ExportMap,
+                       item_symbols: &RefCell<NodeMap<String>>,
+                       link_meta: &LinkMeta,
+                       reachable: &NodeSet,
+                       krate: &hir::Crate) -> Vec<u8>;
+    fn metadata_encoding_version(&self) -> &[u8];
 }
 
 impl<'tcx> CrateStore<'tcx> for cstore::CStore {
@@ -165,6 +200,12 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         decoder::get_item_attrs(&*cdata, def_id.index)
     }
 
+    fn item_symbol(&self, def: DefId) -> String
+    {
+        let cdata = self.get_crate_data(def.krate);
+        decoder::get_symbol(&cdata, def.index)
+    }
+
     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
@@ -285,21 +326,36 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         decoder::is_const_fn(&cdata, did.index)
     }
 
-    fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool {
+    fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool
+    {
         let cdata = self.get_crate_data(trait_def_id.krate);
         decoder::is_defaulted_trait(&*cdata, trait_def_id.index)
     }
 
-    fn is_impl(&self, did: DefId) -> bool {
+    fn is_impl(&self, did: DefId) -> bool
+    {
         let cdata = self.get_crate_data(did.krate);
         decoder::is_impl(&*cdata, did.index)
     }
 
-    fn is_static_method(&self, def: DefId) -> bool {
+    fn is_static_method(&self, def: DefId) -> bool
+    {
         let cdata = self.get_crate_data(def.krate);
         decoder::is_static_method(&*cdata, def.index)
     }
 
+    fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool
+    {
+        let cdata = self.get_crate_data(did.krate);
+        decoder::is_extern_fn(&*cdata, did.index, tcx)
+    }
+
+    fn is_static(&self, did: DefId) -> bool
+    {
+        let cdata = self.get_crate_data(did.krate);
+        decoder::is_static(&*cdata, did.index)
+    }
+
     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
                                 -> Vec<(ast::CrateNum, LinkagePreference)>
     {
@@ -329,6 +385,21 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         self.get_crate_data(cnum).staged_api
     }
 
+    fn is_explicitly_linked(&self, cnum: ast::CrateNum) -> bool
+    {
+        self.get_crate_data(cnum).explicitly_linked.get()
+    }
+
+    fn is_allocator(&self, cnum: ast::CrateNum) -> bool
+    {
+        self.get_crate_data(cnum).is_allocator()
+    }
+
+    fn crate_name(&self, cnum: ast::CrateNum) -> String
+    {
+        self.get_crate_data(cnum).name.clone()
+    }
+
     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
     {
         let cdata = self.get_crate_data(cnum);
@@ -338,6 +409,18 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         })
     }
 
+    fn native_libraries(&self, cnum: ast::CrateNum) -> Vec<(NativeLibraryKind, String)>
+    {
+        let cdata = self.get_crate_data(cnum);
+        decoder::get_native_libraries(&*cdata)
+    }
+
+    fn reachable_ids(&self, cnum: ast::CrateNum) -> Vec<DefId>
+    {
+        let cdata = self.get_crate_data(cnum);
+        decoder::get_reachable_ids(&*cdata)
+    }
+
     fn def_path(&self, def: DefId) -> ast_map::DefPath
     {
         let cdata = self.get_crate_data(def.krate);
@@ -396,4 +479,58 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
         decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
     }
+
+    fn metadata_filename(&self) -> &str
+    {
+        loader::METADATA_FILENAME
+    }
+
+    fn metadata_section_name(&self, target: &Target) -> &str
+    {
+        loader::meta_section_name(target)
+    }
+    fn encode_type(&self, tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Vec<u8>
+    {
+        encoder::encoded_ty(tcx, ty)
+    }
+
+    fn used_crates(&self, prefer: LinkagePreference) -> Vec<(ast::CrateNum, Option<PathBuf>)>
+    {
+        self.do_get_used_crates(prefer)
+    }
+
+    fn used_crate_source(&self, cnum: ast::CrateNum) -> CrateSource
+    {
+        self.do_get_used_crate_source(cnum).unwrap()
+    }
+
+    fn encode_metadata(&self,
+                       tcx: &ty::ctxt<'tcx>,
+                       reexports: &def::ExportMap,
+                       item_symbols: &RefCell<NodeMap<String>>,
+                       link_meta: &LinkMeta,
+                       reachable: &NodeSet,
+                       krate: &hir::Crate) -> Vec<u8>
+    {
+        let encode_inlined_item: encoder::EncodeInlinedItem =
+            Box::new(|ecx, rbml_w, ii| astencode::encode_inlined_item(ecx, rbml_w, ii));
+
+        let encode_params = encoder::EncodeParams {
+            diag: tcx.sess.diagnostic(),
+            tcx: tcx,
+            reexports: reexports,
+            item_symbols: item_symbols,
+            link_meta: link_meta,
+            cstore: self,
+            encode_inlined_item: encode_inlined_item,
+            reachable: reachable
+        };
+        encoder::encode_metadata(encode_params, krate)
+
+    }
+
+    fn metadata_encoding_version(&self) -> &[u8]
+    {
+        encoder::metadata_encoding_version
+    }
 }