Imported Upstream version 1.8.0+dfsg1

[rustc.git] / src / librustc_metadata / csearch.rs

diff --git a/src/librustc_metadata/csearch.rs b/src/librustc_metadata/csearch.rs
index ecbc84023309105f9953e0a7babf1a36c43e79d5..9b534df075bef5dc5a1a751fb9680c23ff48642f 100644 (file)
--- a/src/librustc_metadata/csearch.rs
+++ b/src/librustc_metadata/csearch.rs
@@ -18,11 +18,12 @@ use middle::cstore::{CrateStore, CrateSource, ChildItem, FoundAst};
 use middle::cstore::{NativeLibraryKind, LinkMeta, LinkagePreference};
 use middle::def;
 use middle::lang_items;
-use middle::ty::{self, Ty};
+use middle::ty::{self, Ty, VariantKind};
 use middle::def_id::{DefId, DefIndex};
 
 use rustc::front::map as hir_map;
 use rustc::mir::repr::Mir;
+use rustc::mir::mir_map::MirMap;
 use rustc::util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 
 use std::cell::RefCell;
@@ -39,64 +40,64 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     fn stability(&self, def: DefId) -> Option<attr::Stability>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_stability(&*cdata, def.index)
+        decoder::get_stability(&cdata, def.index)
     }
 
     fn deprecation(&self, def: DefId) -> Option<attr::Deprecation>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_deprecation(&*cdata, def.index)
+        decoder::get_deprecation(&cdata, def.index)
     }
 
     fn closure_kind(&self, _tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureKind
     {
         assert!(!def_id.is_local());
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::closure_kind(&*cdata, def_id.index)
+        decoder::closure_kind(&cdata, def_id.index)
     }
 
     fn closure_ty(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> ty::ClosureTy<'tcx>
     {
         assert!(!def_id.is_local());
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::closure_ty(&*cdata, def_id.index, tcx)
+        decoder::closure_ty(&cdata, def_id.index, tcx)
     }
 
     fn item_variances(&self, def: DefId) -> ty::ItemVariances {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_item_variances(&*cdata, def.index)
+        decoder::get_item_variances(&cdata, def.index)
     }
 
     fn repr_attrs(&self, def: DefId) -> Vec<attr::ReprAttr> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_repr_attrs(&*cdata, def.index)
+        decoder::get_repr_attrs(&cdata, def.index)
     }
 
     fn item_type(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                  -> ty::TypeScheme<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_type(&*cdata, def.index, tcx)
+        decoder::get_type(&cdata, def.index, tcx)
     }
 
     fn item_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                        -> ty::GenericPredicates<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_predicates(&*cdata, def.index, tcx)
+        decoder::get_predicates(&cdata, def.index, tcx)
     }
 
     fn item_super_predicates(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                              -> ty::GenericPredicates<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_super_predicates(&*cdata, def.index, tcx)
+        decoder::get_super_predicates(&cdata, def.index, tcx)
     }
 
     fn item_attrs(&self, def_id: DefId) -> Vec<ast::Attribute>
     {
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::get_item_attrs(&*cdata, def_id.index)
+        decoder::get_item_attrs(&cdata, def_id.index)
     }
 
     fn item_symbol(&self, def: DefId) -> String
@@ -108,13 +109,13 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     fn trait_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::TraitDef<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_trait_def(&*cdata, def.index, tcx)
+        decoder::get_trait_def(&cdata, def.index, tcx)
     }
 
     fn adt_def(&self, tcx: &ty::ctxt<'tcx>, def: DefId) -> ty::AdtDefMaster<'tcx>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_adt_def(&self.intr, &*cdata, def.index, tcx)
+        decoder::get_adt_def(&self.intr, &cdata, def.index, tcx)
     }
 
     fn method_arg_names(&self, did: DefId) -> Vec<String>
@@ -125,7 +126,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
 
     fn item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::get_item_path(&*cdata, def.index);
+        let path = decoder::get_item_path(&cdata, def.index);
 
         cdata.with_local_path(|cpath| {
             let mut r = Vec::with_capacity(cpath.len() + path.len());
@@ -137,7 +138,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
 
     fn extern_item_path(&self, def: DefId) -> Vec<hir_map::PathElem> {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::get_item_path(&*cdata, def.index);
+        let path = decoder::get_item_path(&cdata, def.index);
 
         let mut r = Vec::with_capacity(path.len() + 1);
         let crate_name = hir_map::PathMod(token::intern(&cdata.name));
@@ -156,7 +157,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     {
         let mut result = vec![];
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::each_inherent_implementation_for_type(&*cdata, def_id.index,
+        decoder::each_inherent_implementation_for_type(&cdata, def_id.index,
                                                        |iid| result.push(iid));
         result
     }
@@ -176,53 +177,53 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
                               -> Vec<Rc<ty::Method<'tcx>>>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_provided_trait_methods(self.intr.clone(), &*cdata, def.index, tcx)
+        decoder::get_provided_trait_methods(self.intr.clone(), &cdata, def.index, tcx)
     }
 
     fn trait_item_def_ids(&self, def: DefId)
                           -> Vec<ty::ImplOrTraitItemId>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_trait_item_def_ids(&*cdata, def.index)
+        decoder::get_trait_item_def_ids(&cdata, def.index)
     }
 
     fn impl_items(&self, impl_def_id: DefId) -> Vec<ty::ImplOrTraitItemId>
     {
         let cdata = self.get_crate_data(impl_def_id.krate);
-        decoder::get_impl_items(&*cdata, impl_def_id.index)
+        decoder::get_impl_items(&cdata, impl_def_id.index)
     }
 
     fn impl_polarity(&self, def: DefId) -> Option<hir::ImplPolarity>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_impl_polarity(&*cdata, def.index)
+        decoder::get_impl_polarity(&cdata, def.index)
     }
 
     fn impl_trait_ref(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                       -> Option<ty::TraitRef<'tcx>>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_impl_trait(&*cdata, def.index, tcx)
+        decoder::get_impl_trait(&cdata, def.index, tcx)
     }
 
     fn custom_coerce_unsized_kind(&self, def: DefId)
                                   -> Option<ty::adjustment::CustomCoerceUnsized>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_custom_coerce_unsized_kind(&*cdata, def.index)
+        decoder::get_custom_coerce_unsized_kind(&cdata, def.index)
     }
 
     // FIXME: killme
     fn associated_consts(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                          -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_associated_consts(self.intr.clone(), &*cdata, def.index, tcx)
+        decoder::get_associated_consts(self.intr.clone(), &cdata, def.index, tcx)
     }
 
     fn trait_of_item(&self, tcx: &ty::ctxt<'tcx>, def_id: DefId) -> Option<DefId>
     {
         let cdata = self.get_crate_data(def_id.krate);
-        decoder::get_trait_of_item(&*cdata, def_id.index, tcx)
+        decoder::get_trait_of_item(&cdata, def_id.index, tcx)
     }
 
     fn impl_or_trait_item(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
@@ -231,7 +232,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         let cdata = self.get_crate_data(def.krate);
         decoder::get_impl_or_trait_item(
             self.intr.clone(),
-            &*cdata,
+            &cdata,
             def.index,
             tcx)
     }
@@ -245,36 +246,29 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     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)
+        decoder::is_defaulted_trait(&cdata, trait_def_id.index)
     }
 
     fn is_impl(&self, did: DefId) -> bool
     {
         let cdata = self.get_crate_data(did.krate);
-        decoder::is_impl(&*cdata, did.index)
+        decoder::is_impl(&cdata, did.index)
     }
 
     fn is_default_impl(&self, impl_did: DefId) -> bool {
         let cdata = self.get_crate_data(impl_did.krate);
-        decoder::is_default_impl(&*cdata, impl_did.index)
+        decoder::is_default_impl(&cdata, impl_did.index)
     }
 
-    fn is_extern_fn(&self, tcx: &ty::ctxt<'tcx>, did: DefId) -> bool
-    {
+    fn is_extern_item(&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)
+        decoder::is_extern_item(&cdata, did.index, tcx)
     }
 
     fn is_static_method(&self, def: DefId) -> bool
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::is_static_method(&*cdata, def.index)
+        decoder::is_static_method(&cdata, def.index)
     }
 
     fn is_statically_included_foreign_item(&self, id: ast::NodeId) -> bool
@@ -284,7 +278,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
 
     fn is_typedef(&self, did: DefId) -> bool {
         let cdata = self.get_crate_data(did.krate);
-        decoder::is_typedef(&*cdata, did.index)
+        decoder::is_typedef(&cdata, did.index)
     }
 
     fn dylib_dependency_formats(&self, cnum: ast::CrateNum)
@@ -298,7 +292,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     {
         let mut result = vec![];
         let crate_data = self.get_crate_data(cnum);
-        decoder::each_lang_item(&*crate_data, |did, lid| {
+        decoder::each_lang_item(&crate_data, |did, lid| {
             result.push((did, lid)); true
         });
         result
@@ -308,7 +302,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
                           -> Vec<lang_items::LangItem>
     {
         let cdata = self.get_crate_data(cnum);
-        decoder::get_missing_lang_items(&*cdata)
+        decoder::get_missing_lang_items(&cdata)
     }
 
     fn is_staged_api(&self, cnum: ast::CrateNum) -> bool
@@ -345,7 +339,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     fn crate_struct_field_attrs(&self, cnum: ast::CrateNum)
                                 -> FnvHashMap<DefId, Vec<ast::Attribute>>
     {
-        decoder::get_struct_field_attrs(&*self.get_crate_data(cnum))
+        decoder::get_struct_field_attrs(&self.get_crate_data(cnum))
     }
 
     fn plugin_registrar_fn(&self, cnum: ast::CrateNum) -> Option<DefId>
@@ -360,33 +354,44 @@ 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)
+        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)
+        decoder::get_reachable_ids(&cdata)
     }
 
     fn def_path(&self, def: DefId) -> hir_map::DefPath
     {
         let cdata = self.get_crate_data(def.krate);
-        let path = decoder::def_path(&*cdata, def.index);
+        let path = decoder::def_path(&cdata, def.index);
         let local_path = cdata.local_def_path();
         local_path.into_iter().chain(path).collect()
     }
 
+    fn variant_kind(&self, def_id: DefId) -> Option<VariantKind> {
+        let cdata = self.get_crate_data(def_id.krate);
+        decoder::get_variant_kind(&cdata, def_id.index)
+    }
+
+    fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>
+    {
+        let cdata = self.get_crate_data(struct_def_id.krate);
+        decoder::get_struct_ctor_def_id(&cdata, struct_def_id.index)
+    }
+
     fn tuple_struct_definition_if_ctor(&self, did: DefId) -> Option<DefId>
     {
         let cdata = self.get_crate_data(did.krate);
-        decoder::get_tuple_struct_definition_if_ctor(&*cdata, did.index)
+        decoder::get_tuple_struct_definition_if_ctor(&cdata, did.index)
     }
 
     fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
     {
         let cdata = self.get_crate_data(def.krate);
-        decoder::get_struct_field_names(&self.intr, &*cdata, def.index)
+        decoder::get_struct_field_names(&self.intr, &cdata, def.index)
     }
 
     fn item_children(&self, def_id: DefId) -> Vec<ChildItem>
@@ -395,7 +400,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         let crate_data = self.get_crate_data(def_id.krate);
         let get_crate_data = |cnum| self.get_crate_data(cnum);
         decoder::each_child_of_item(
-            self.intr.clone(), &*crate_data,
+            self.intr.clone(), &crate_data,
             def_id.index, get_crate_data,
             |def, name, vis| result.push(ChildItem {
                 def: def,
@@ -411,7 +416,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
         let crate_data = self.get_crate_data(cnum);
         let get_crate_data = |cnum| self.get_crate_data(cnum);
         decoder::each_top_level_item_of_crate(
-            self.intr.clone(), &*crate_data, get_crate_data,
+            self.intr.clone(), &crate_data, get_crate_data,
             |def, name, vis| result.push(ChildItem {
                 def: def,
                 name: name,
@@ -425,13 +430,18 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
     {
         let cdata = self.get_crate_data(def.krate);
         let decode_inlined_item = Box::new(astencode::decode_inlined_item);
-        decoder::maybe_get_item_ast(&*cdata, tcx, def.index, decode_inlined_item)
+        decoder::maybe_get_item_ast(&cdata, tcx, def.index, decode_inlined_item)
     }
 
     fn maybe_get_item_mir(&self, tcx: &ty::ctxt<'tcx>, def: DefId)
                           -> Option<Mir<'tcx>> {
         let cdata = self.get_crate_data(def.krate);
-        decoder::maybe_get_item_mir(&*cdata, tcx, def.index)
+        decoder::maybe_get_item_mir(&cdata, tcx, def.index)
+    }
+
+    fn is_item_mir_available(&self, def: DefId) -> bool {
+        let cdata = self.get_crate_data(def.krate);
+        decoder::is_item_mir_available(&cdata, def.index)
     }
 
     fn crates(&self) -> Vec<ast::CrateNum>
@@ -486,7 +496,7 @@ impl<'tcx> CrateStore<'tcx> for cstore::CStore {
                        item_symbols: &RefCell<NodeMap<String>>,
                        link_meta: &LinkMeta,
                        reachable: &NodeSet,
-                       mir_map: &NodeMap<Mir<'tcx>>,
+                       mir_map: &MirMap<'tcx>,
                        krate: &hir::Crate) -> Vec<u8>
     {
         let encode_inlined_item: encoder::EncodeInlinedItem =