use rustc::hir::intravisit::{Visitor, NestedVisitorMap};
use rustc::hir::intravisit;
+use rustc_i128::{u128, i128};
+
use super::index_builder::{FromId, IndexBuilder, Untracked};
pub struct EncodeContext<'a, 'tcx: 'a> {
encoder_methods! {
emit_usize(usize);
+ emit_u128(u128);
emit_u64(u64);
emit_u32(u32);
emit_u16(u16);
emit_u8(u8);
emit_isize(isize);
+ emit_i128(i128);
emit_i64(i64);
emit_i32(i32);
emit_i16(i16);
let data = VariantData {
ctor_kind: variant.ctor_kind,
- disr: variant.disr_val.to_u64_unchecked(),
+ disr: variant.disr_val.to_u128_unchecked(),
struct_ctor: None,
};
- let enum_id = tcx.map.as_local_node_id(enum_did).unwrap();
- let enum_vis = &tcx.map.expect_item(enum_id).vis;
+ let enum_id = tcx.hir.as_local_node_id(enum_did).unwrap();
+ let enum_vis = &tcx.hir.expect_item(enum_id).vis;
Entry {
kind: EntryKind::Variant(self.lazy(&data)),
&hir::Visibility)>)
-> Entry<'tcx> {
let tcx = self.tcx;
- let def_id = tcx.map.local_def_id(id);
+ let def_id = tcx.hir.local_def_id(id);
let data = ModData {
reexports: match self.reexports.get(&id) {
span: self.lazy(&md.inner),
attributes: self.encode_attributes(attrs),
children: self.lazy_seq(md.item_ids.iter().map(|item_id| {
- tcx.map.local_def_id(item_id.id).index
+ tcx.hir.local_def_id(item_id.id).index
})),
stability: self.encode_stability(def_id),
deprecation: self.encode_deprecation(def_id),
let field = &variant.fields[field_index];
let def_id = field.did;
- let variant_id = tcx.map.as_local_node_id(variant.did).unwrap();
- let variant_data = tcx.map.expect_variant_data(variant_id);
+ let variant_id = tcx.hir.as_local_node_id(variant.did).unwrap();
+ let variant_data = tcx.hir.expect_variant_data(variant_id);
Entry {
kind: EntryKind::Field,
let data = VariantData {
ctor_kind: variant.ctor_kind,
- disr: variant.disr_val.to_u64_unchecked(),
+ disr: variant.disr_val.to_u128_unchecked(),
struct_ctor: Some(def_id.index),
};
- let struct_id = tcx.map.as_local_node_id(adt_def_id).unwrap();
- let struct_vis = &tcx.map.expect_item(struct_id).vis;
+ let struct_id = tcx.hir.as_local_node_id(adt_def_id).unwrap();
+ let struct_vis = &tcx.hir.expect_item(struct_id).vis;
Entry {
kind: EntryKind::Struct(self.lazy(&data)),
}
}
- fn encode_generics(&mut self, def_id: DefId) -> Lazy<ty::Generics<'tcx>> {
+ fn encode_generics(&mut self, def_id: DefId) -> Lazy<Generics<'tcx>> {
let tcx = self.tcx;
- self.lazy(tcx.item_generics(def_id))
+ let g = tcx.item_generics(def_id);
+ let regions = self.lazy_seq_ref(&g.regions);
+ let types = self.lazy_seq_ref(&g.types);
+ self.lazy(&Generics {
+ parent: g.parent,
+ parent_regions: g.parent_regions,
+ parent_types: g.parent_types,
+ regions: regions,
+ types: types,
+ has_self: g.has_self,
+ })
}
fn encode_predicates(&mut self, def_id: DefId) -> Lazy<ty::GenericPredicates<'tcx>> {
fn encode_info_for_trait_item(&mut self, def_id: DefId) -> Entry<'tcx> {
let tcx = self.tcx;
- let node_id = tcx.map.as_local_node_id(def_id).unwrap();
- let ast_item = tcx.map.expect_trait_item(node_id);
+ let node_id = tcx.hir.as_local_node_id(def_id).unwrap();
+ let ast_item = tcx.hir.expect_trait_item(node_id);
let trait_item = tcx.associated_item(def_id);
let container = match trait_item.defaultness {
}
fn encode_info_for_impl_item(&mut self, def_id: DefId) -> Entry<'tcx> {
- let node_id = self.tcx.map.as_local_node_id(def_id).unwrap();
- let ast_item = self.tcx.map.expect_impl_item(node_id);
+ let node_id = self.tcx.hir.as_local_node_id(def_id).unwrap();
+ let ast_item = self.tcx.hir.expect_impl_item(node_id);
let impl_item = self.tcx.associated_item(def_id);
let container = match impl_item.defaultness {
fn encode_fn_arg_names_for_body(&mut self, body_id: hir::BodyId)
-> LazySeq<ast::Name> {
let _ignore = self.tcx.dep_graph.in_ignore();
- let body = self.tcx.map.body(body_id);
+ let body = self.tcx.hir.body(body_id);
self.lazy_seq(body.arguments.iter().map(|arg| {
match arg.pat.node {
PatKind::Binding(_, _, name, _) => name.node,
// for methods, write all the stuff get_trait_method
// needs to know
let struct_ctor = if !struct_def.is_struct() {
- Some(tcx.map.local_def_id(struct_def.id()).index)
+ Some(tcx.hir.local_def_id(struct_def.id()).index)
} else {
None
};
EntryKind::Struct(self.lazy(&VariantData {
ctor_kind: variant.ctor_kind,
- disr: variant.disr_val.to_u64_unchecked(),
+ disr: variant.disr_val.to_u128_unchecked(),
struct_ctor: struct_ctor,
}))
}
EntryKind::Union(self.lazy(&VariantData {
ctor_kind: variant.ctor_kind,
- disr: variant.disr_val.to_u64_unchecked(),
+ disr: variant.disr_val.to_u128_unchecked(),
struct_ctor: None,
}))
}
hir::ItemForeignMod(ref fm) => {
self.lazy_seq(fm.items
.iter()
- .map(|foreign_item| tcx.map.local_def_id(foreign_item.id).index))
+ .map(|foreign_item| tcx.hir.local_def_id(foreign_item.id).index))
}
hir::ItemEnum(..) => {
let def = self.tcx.lookup_adt_def(def_id);
/// so it's easier to do that here then to wait until we would encounter
/// normally in the visitor walk.
fn encode_addl_info_for_item(&mut self, item: &hir::Item) {
- let def_id = self.tcx.map.local_def_id(item.id);
+ let def_id = self.tcx.hir.local_def_id(item.id);
match item.node {
hir::ItemStatic(..) |
hir::ItemConst(..) |
// If the struct has a constructor, encode it.
if !struct_def.is_struct() {
- let ctor_def_id = self.tcx.map.local_def_id(struct_def.id());
+ let ctor_def_id = self.tcx.hir.local_def_id(struct_def.id());
self.record(ctor_def_id,
EncodeContext::encode_struct_ctor,
(def_id, ctor_def_id));
impl<'a, 'b, 'tcx> Visitor<'tcx> for EncodeVisitor<'a, 'b, 'tcx> {
fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
- NestedVisitorMap::OnlyBodies(&self.index.tcx.map)
+ NestedVisitorMap::OnlyBodies(&self.index.tcx.hir)
}
fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
intravisit::walk_expr(self, ex);
}
fn visit_item(&mut self, item: &'tcx hir::Item) {
intravisit::walk_item(self, item);
- let def_id = self.index.tcx.map.local_def_id(item.id);
+ let def_id = self.index.tcx.hir.local_def_id(item.id);
match item.node {
hir::ItemExternCrate(_) |
hir::ItemUse(..) => (), // ignore these
}
fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem) {
intravisit::walk_foreign_item(self, ni);
- let def_id = self.index.tcx.map.local_def_id(ni.id);
+ let def_id = self.index.tcx.hir.local_def_id(ni.id);
self.index.record(def_id,
EncodeContext::encode_info_for_foreign_item,
(def_id, ni));
self.index.encode_info_for_ty(ty);
}
fn visit_macro_def(&mut self, macro_def: &'tcx hir::MacroDef) {
- let def_id = self.index.tcx.map.local_def_id(macro_def.id);
+ let def_id = self.index.tcx.hir.local_def_id(macro_def.id);
self.index.record(def_id, EncodeContext::encode_info_for_macro_def, macro_def);
}
}
impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> {
fn encode_info_for_ty(&mut self, ty: &hir::Ty) {
if let hir::TyImplTrait(_) = ty.node {
- let def_id = self.tcx.map.local_def_id(ty.id);
+ let def_id = self.tcx.hir.local_def_id(ty.id);
self.record(def_id, EncodeContext::encode_info_for_anon_ty, def_id);
}
}
fn encode_info_for_expr(&mut self, expr: &hir::Expr) {
match expr.node {
hir::ExprClosure(..) => {
- let def_id = self.tcx.map.local_def_id(expr.id);
+ let def_id = self.tcx.hir.local_def_id(expr.id);
self.record(def_id, EncodeContext::encode_info_for_closure, def_id);
}
_ => {}
let data = ClosureData {
kind: tcx.closure_kind(def_id),
- ty: self.lazy(&tcx.tables().closure_tys[&def_id]),
+ ty: self.lazy(&tcx.closure_tys.borrow()[&def_id]),
};
Entry {
}
fn encode_info_for_items(&mut self) -> Index {
- let krate = self.tcx.map.krate();
+ let krate = self.tcx.hir.krate();
let mut index = IndexBuilder::new(self);
index.record(DefId::local(CRATE_DEF_INDEX),
EncodeContext::encode_info_for_mod,
}
fn encode_def_path_table(&mut self) -> Lazy<DefPathTable> {
- let definitions = self.tcx.map.definitions();
+ let definitions = self.tcx.hir.definitions();
self.lazy(definitions.def_path_table())
}
}
impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'a, 'tcx> {
fn visit_item(&mut self, item: &hir::Item) {
if let hir::ItemImpl(..) = item.node {
- let impl_id = self.tcx.map.local_def_id(item.id);
+ let impl_id = self.tcx.hir.local_def_id(item.id);
if let Some(trait_ref) = self.tcx.impl_trait_ref(impl_id) {
self.impls
.entry(trait_ref.def_id)
tcx: self.tcx,
impls: FxHashMap(),
};
- self.tcx.map.krate().visit_all_item_likes(&mut visitor);
+ self.tcx.hir.krate().visit_all_item_likes(&mut visitor);
let all_impls: Vec<_> = visitor.impls
.into_iter()
fn encode_exported_symbols(&mut self) -> LazySeq<DefIndex> {
let exported_symbols = self.exported_symbols;
let tcx = self.tcx;
- self.lazy_seq(exported_symbols.iter().map(|&id| tcx.map.local_def_id(id).index))
+ self.lazy_seq(exported_symbols.iter().map(|&id| tcx.hir.local_def_id(id).index))
}
fn encode_dylib_dependency_formats(&mut self) -> LazySeq<Option<LinkagePreference>> {
plugin_registrar_fn: tcx.sess
.plugin_registrar_fn
.get()
- .map(|id| tcx.map.local_def_id(id).index),
+ .map(|id| tcx.hir.local_def_id(id).index),
macro_derive_registrar: if is_proc_macro {
let id = tcx.sess.derive_registrar_fn.get().unwrap();
- Some(tcx.map.local_def_id(id).index)
+ Some(tcx.hir.local_def_id(id).index)
} else {
None
},