Auto merge of #37860 - giannicic:defaultimpl, r=nagisa

[rust.git] / src / librustc_metadata / encoder.rs

diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index d55f489107d7f3a0c398b742312cf6bc9fe4b49a..3676e5a7f0f724d83cd9dc58971f15b219014464 100644 (file)
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -36,7 +36,7 @@
 use syntax::codemap::Spanned;
 use syntax::attr;
 use syntax::symbol::Symbol;
-use syntax_pos::{self, DUMMY_SP};
+use syntax_pos;
 
 use rustc::hir::{self, PatKind};
 use rustc::hir::itemlikevisit::ItemLikeVisitor;
@@ -242,12 +242,12 @@ impl<'a, 'b: 'a, 'tcx: 'b> EntryBuilder<'a, 'b, 'tcx> {
     fn encode_item_variances(&mut self, def_id: DefId) -> LazySeq<ty::Variance> {
         debug!("EntryBuilder::encode_item_variances({:?})", def_id);
         let tcx = self.tcx;
-        self.lazy_seq_from_slice(&tcx.item_variances(def_id))
+        self.lazy_seq_from_slice(&tcx.variances_of(def_id))
     }
 
     fn encode_item_type(&mut self, def_id: DefId) -> Lazy<Ty<'tcx>> {
         let tcx = self.tcx;
-        let ty = tcx.item_type(def_id);
+        let ty = tcx.type_of(def_id);
         debug!("EntryBuilder::encode_item_type({:?}) => {:?}", def_id, ty);
         self.lazy(&ty)
     }
@@ -261,7 +261,7 @@ fn encode_enum_variant_info(&mut self,
                                 (enum_did, Untracked(index)): (DefId, Untracked<usize>))
                                 -> Entry<'tcx> {
         let tcx = self.tcx;
-        let def = tcx.lookup_adt_def(enum_did);
+        let def = tcx.adt_def(enum_did);
         let variant = &def.variants[index];
         let def_id = variant.did;
         debug!("EntryBuilder::encode_enum_variant_info({:?})", def_id);
@@ -341,7 +341,7 @@ fn encode_info_for_mod(&mut self,
 
 impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> {
     fn encode_fields(&mut self, adt_def_id: DefId) {
-        let def = self.tcx.lookup_adt_def(adt_def_id);
+        let def = self.tcx.adt_def(adt_def_id);
         for (variant_index, variant) in def.variants.iter().enumerate() {
             for (field_index, field) in variant.fields.iter().enumerate() {
                 self.record(field.did,
@@ -365,7 +365,7 @@ fn encode_field(&mut self,
                                                                                        usize)>))
                     -> Entry<'tcx> {
         let tcx = self.tcx;
-        let variant = &tcx.lookup_adt_def(adt_def_id).variants[variant_index];
+        let variant = &tcx.adt_def(adt_def_id).variants[variant_index];
         let field = &variant.fields[field_index];
 
         let def_id = field.did;
@@ -397,7 +397,7 @@ fn encode_field(&mut self,
     fn encode_struct_ctor(&mut self, (adt_def_id, def_id): (DefId, DefId)) -> Entry<'tcx> {
         debug!("EntryBuilder::encode_struct_ctor({:?})", def_id);
         let tcx = self.tcx;
-        let variant = tcx.lookup_adt_def(adt_def_id).struct_variant();
+        let variant = tcx.adt_def(adt_def_id).struct_variant();
 
         let data = VariantData {
             ctor_kind: variant.ctor_kind,
@@ -439,13 +439,13 @@ fn encode_struct_ctor(&mut self, (adt_def_id, def_id): (DefId, DefId)) -> Entry<
     fn encode_generics(&mut self, def_id: DefId) -> Lazy<ty::Generics> {
         debug!("EntryBuilder::encode_generics({:?})", def_id);
         let tcx = self.tcx;
-        self.lazy(tcx.item_generics(def_id))
+        self.lazy(tcx.generics_of(def_id))
     }
 
     fn encode_predicates(&mut self, def_id: DefId) -> Lazy<ty::GenericPredicates<'tcx>> {
         debug!("EntryBuilder::encode_predicates({:?})", def_id);
         let tcx = self.tcx;
-        self.lazy(&tcx.item_predicates(def_id))
+        self.lazy(&tcx.predicates_of(def_id))
     }
 
     fn encode_info_for_trait_item(&mut self, def_id: DefId) -> Entry<'tcx> {
@@ -547,7 +547,7 @@ fn encode_info_for_impl_item(&mut self, def_id: DefId) -> Entry<'tcx> {
         let kind = match impl_item.kind {
             ty::AssociatedKind::Const => {
                 EntryKind::AssociatedConst(container,
-                    ty::queries::mir_const_qualif::get(self.tcx, ast_item.span, def_id))
+                    self.tcx.at(ast_item.span).mir_const_qualif(def_id))
             }
             ty::AssociatedKind::Method => {
                 let fn_data = if let hir::ImplItemKind::Method(ref sig, body) = ast_item.node {
@@ -570,7 +570,7 @@ fn encode_info_for_impl_item(&mut self, def_id: DefId) -> Entry<'tcx> {
         let (ast, mir) = if let hir::ImplItemKind::Const(_, body) = ast_item.node {
             (Some(body), true)
         } else if let hir::ImplItemKind::Method(ref sig, body) = ast_item.node {
-            let generics = self.tcx.item_generics(def_id);
+            let generics = self.tcx.generics_of(def_id);
             let types = generics.parent_types as usize + generics.types.len();
             let needs_inline = types > 0 || attr::requests_inline(&ast_item.attrs);
             let is_const_fn = sig.constness == hir::Constness::Const;
@@ -656,7 +656,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
             hir::ItemStatic(_, hir::MutMutable, _) => EntryKind::MutStatic,
             hir::ItemStatic(_, hir::MutImmutable, _) => EntryKind::ImmStatic,
             hir::ItemConst(..) => {
-                EntryKind::Const(ty::queries::mir_const_qualif::get(tcx, item.span, def_id))
+                EntryKind::Const(tcx.at(item.span).mir_const_qualif(def_id))
             }
             hir::ItemFn(_, _, constness, .., body) => {
                 let data = FnData {
@@ -674,7 +674,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
             hir::ItemTy(..) => EntryKind::Type,
             hir::ItemEnum(..) => EntryKind::Enum(get_repr_options(&tcx, def_id)),
             hir::ItemStruct(ref struct_def, _) => {
-                let variant = tcx.lookup_adt_def(def_id).struct_variant();
+                let variant = tcx.adt_def(def_id).struct_variant();
 
                 // Encode def_ids for each field and method
                 // for methods, write all the stuff get_trait_method
@@ -694,7 +694,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
                 }), repr_options)
             }
             hir::ItemUnion(..) => {
-                let variant = tcx.lookup_adt_def(def_id).struct_variant();
+                let variant = tcx.adt_def(def_id).struct_variant();
                 let repr_options = get_repr_options(&tcx, def_id);
 
                 EntryKind::Union(self.lazy(&VariantData {
@@ -717,7 +717,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
             hir::ItemImpl(_, polarity, defaultness, ..) => {
                 let trait_ref = tcx.impl_trait_ref(def_id);
                 let parent = if let Some(trait_ref) = trait_ref {
-                    let trait_def = tcx.lookup_trait_def(trait_ref.def_id);
+                    let trait_def = tcx.trait_def(trait_ref.def_id);
                     trait_def.ancestors(def_id).skip(1).next().and_then(|node| {
                         match node {
                             specialization_graph::Node::Impl(parent) => Some(parent),
@@ -733,7 +733,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
                 let coerce_unsized_info =
                     trait_ref.and_then(|t| {
                         if Some(t.def_id) == tcx.lang_items.coerce_unsized_trait() {
-                            Some(ty::queries::coerce_unsized_info::get(tcx, item.span, def_id))
+                            Some(tcx.at(item.span).coerce_unsized_info(def_id))
                         } else {
                             None
                         }
@@ -750,12 +750,12 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
                 EntryKind::Impl(self.lazy(&data))
             }
             hir::ItemTrait(..) => {
-                let trait_def = tcx.lookup_trait_def(def_id);
+                let trait_def = tcx.trait_def(def_id);
                 let data = TraitData {
                     unsafety: trait_def.unsafety,
                     paren_sugar: trait_def.paren_sugar,
                     has_default_impl: tcx.trait_has_default_impl(def_id),
-                    super_predicates: self.lazy(&tcx.item_super_predicates(def_id)),
+                    super_predicates: self.lazy(&tcx.super_predicates_of(def_id)),
                 };
 
                 EntryKind::Trait(self.lazy(&data))
@@ -776,7 +776,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
                         .map(|foreign_item| tcx.hir.local_def_id(foreign_item.id).index))
                 }
                 hir::ItemEnum(..) => {
-                    let def = self.tcx.lookup_adt_def(def_id);
+                    let def = self.tcx.adt_def(def_id);
                     self.lazy_seq(def.variants.iter().map(|v| {
                         assert!(v.did.is_local());
                         v.did.index
@@ -784,7 +784,7 @@ fn encode_info_for_item(&mut self, (def_id, item): (DefId, &'tcx hir::Item)) ->
                 }
                 hir::ItemStruct(..) |
                 hir::ItemUnion(..) => {
-                    let def = self.tcx.lookup_adt_def(def_id);
+                    let def = self.tcx.adt_def(def_id);
                     self.lazy_seq(def.struct_variant().fields.iter().map(|f| {
                         assert!(f.did.is_local());
                         f.did.index
@@ -921,7 +921,7 @@ fn encode_addl_info_for_item(&mut self, item: &hir::Item) {
             hir::ItemEnum(..) => {
                 self.encode_fields(def_id);
 
-                let def = self.tcx.lookup_adt_def(def_id);
+                let def = self.tcx.adt_def(def_id);
                 for (i, variant) in def.variants.iter().enumerate() {
                     self.record(variant.did,
                                 EntryBuilder::encode_enum_variant_info,
@@ -1171,7 +1171,7 @@ fn encode_info_for_embedded_const(&mut self, def_id: DefId) -> Entry<'tcx> {
         let body = tcx.hir.body_owned_by(id);
 
         Entry {
-            kind: EntryKind::Const(ty::queries::mir_const_qualif::get(tcx, DUMMY_SP, def_id)),
+            kind: EntryKind::Const(tcx.mir_const_qualif(def_id)),
             visibility: self.lazy(&ty::Visibility::Public),
             span: self.lazy(&tcx.def_span(def_id)),
             attributes: LazySeq::empty(),
@@ -1541,7 +1541,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 pub fn get_repr_options<'a, 'tcx, 'gcx>(tcx: &TyCtxt<'a, 'tcx, 'gcx>, did: DefId) -> ReprOptions {
-    let ty = tcx.item_type(did);
+    let ty = tcx.type_of(did);
     match ty.sty {
         ty::TyAdt(ref def, _) => return def.repr,
         _ => bug!("{} is not an ADT", ty),